Esempio n. 1
0
 public LayMines(Actor self, List <CPos> minefield = null)
 {
     minelayer      = self.Trait <Minelayer>();
     ammoPools      = self.TraitsImplementing <AmmoPool>().ToArray();
     movement       = self.Trait <IMove>();
     moveInfo       = self.Info.TraitInfo <IMoveInfo>();
     rearmableInfo  = self.Info.TraitInfoOrDefault <RearmableInfo>();
     this.minefield = minefield;
 }
 /// <summary>
 /// Moves the transaction back to a specific step (all undo functions for the back steps will be executed).
 /// </summary>
 /// <param name="id">The step id to move.</param>
 /// <param name="comparer">The equality comparer.</param>
 public void GoBack(TStepId id, IEqualityComparer <TStepId> comparer)
 {
     this.MoveInfo = new MoveInfo <TStepId>()
     {
         Id = id,
         Comparer = comparer ?? EqualityComparer <TStepId> .Default,
         MoveType = MoveType.Back
     };
 }
Esempio n. 3
0
        protected BaseMovesModel(IMoveInfo move)
            : this()
        {
            GenericMove = move;

            if (GenericMove.GetDate() == DateTime.MinValue)
            {
                Date = now.ToShortDateString();
            }

            arrangeDetails();
        }
Esempio n. 4
0
        public Resupply(Actor self, Actor host, WDist closeEnough, bool stayOnResupplier = false)
        {
            this.host             = Target.FromActor(host);
            this.closeEnough      = closeEnough;
            this.stayOnResupplier = stayOnResupplier;
            allRepairsUnits       = host.TraitsImplementing <RepairsUnits>().ToArray();
            health                = self.TraitOrDefault <IHealth>();
            repairable            = self.TraitOrDefault <Repairable>();
            repairableNear        = self.TraitOrDefault <RepairableNear>();
            rearmable             = self.TraitOrDefault <Rearmable>();
            notifyResupplies      = host.TraitsImplementing <INotifyResupply>().ToArray();
            notifyBeingResupplied = self.TraitsImplementing <INotifyBeingResupplied>().ToArray();
            transportCallers      = self.TraitsImplementing <ICallForTransport>().ToArray();
            move            = self.Trait <IMove>();
            aircraft        = move as Aircraft;
            moveInfo        = self.Info.TraitInfo <IMoveInfo>();
            playerResources = self.Owner.PlayerActor.Trait <PlayerResources>();

            var valued = self.Info.TraitInfoOrDefault <ValuedInfo>();

            unitCost = valued != null ? valued.Cost : 0;

            var cannotRepairAtHost = health == null || health.DamageState == DamageState.Undamaged ||
                                     !allRepairsUnits.Any() ||
                                     ((repairable == null || !repairable.Info.RepairActors.Contains(host.Info.Name)) &&
                                      (repairableNear == null || !repairableNear.Info.RepairActors.Contains(host.Info.Name)));

            if (!cannotRepairAtHost)
            {
                activeResupplyTypes |= ResupplyType.Repair;

                // HACK: Reservable logic can't handle repairs, so force a take-off if resupply included repairs.
                // TODO: Make reservation logic or future docking logic properly handle this.
                wasRepaired = true;
            }

            var cannotRearmAtHost = rearmable == null || !rearmable.Info.RearmActors.Contains(host.Info.Name) || rearmable.RearmableAmmoPools.All(p => p.HasFullAmmo);

            if (!cannotRearmAtHost)
            {
                activeResupplyTypes |= ResupplyType.Rearm;
            }
        }
        public static async Task MoveForward <TStepId, TData>(MoveToStepContext <TStepId, TData> context)
#endif
        {
            IStepEnumerator <TStepId, TData> stepEnumerator = context.Session.StepEnumerator;
            IMoveInfo <TStepId> moveInfo = context.Session.MoveInfo;
            int moveCount = 0;

            do
            {
                stepEnumerator.MoveNext();
                ++moveCount;
            }while (stepEnumerator.CurrentStep != null &&
                    !moveInfo.Comparer.Equals(stepEnumerator.CurrentStep.Id, moveInfo.Id));

            context.Session.MoveInfo = null;

            if (stepEnumerator.CurrentStep == null)
            {
                for (int i = 0; i < moveCount; ++i)
                {
                    stepEnumerator.MovePrevious();
                }

#if NET35 || NOASYNC
                RunUndoOperation.RunUndo(new RunUndoContext <TStepId, TData>()
#else
                await RunUndoOperation.RunUndo(new RunUndoContext <TStepId, TData>()
#endif
                {
                    Result          = ResultType.Failed,
                    CaughtException = new InvalidOperationException(string.Format("Could not move forward to a step with id '{0}' as the step does not exist.", moveInfo.Id)),
                    Session         = context.Session
                });

                return;
            }

#if NET35 || NOASYNC
            context.MoveToStepFinishAction();
#else
            await context.MoveToStepFinishAction();
#endif
        }
Esempio n. 6
0
        public static MoveValueType ValueType(this IMoveInfo move)
        {
            var type = MoveValueType.Empty;

            if (move.Value != 0)
            {
                type += (Int32)MoveValueType.Unique;
            }

            var details = move.DetailList
                          .Sum(d => d.Amount * d.Value);

            if (move.DetailList.Any() && details != 0)
            {
                type += (Int32)MoveValueType.Detailed;
            }

            return(type);
        }
        public static async Task MoveBack <TStepId, TData>(MoveToStepContext <TStepId, TData> context)
#endif
        {
            IMoveInfo <TStepId> moveInfo = context.Session.MoveInfo;
            bool stepFound = false;

            Func <ITransactionStep <TStepId, TData>, bool> processStepPredicate = step =>
            {
                if (step == null)
                {
                    return(false);
                }

                if (stepFound)
                {
                    return(false);
                }
                else
                {
                    stepFound = moveInfo.Comparer.Equals(step.Id, moveInfo.Id);
                    return(true);
                }
            };

#if NET35 || NOASYNC
            RunUndoOperation.RunUndo(new RunUndoContext <TStepId, TData>()
#else
            await RunUndoOperation.RunUndo(new RunUndoContext <TStepId, TData>()
#endif
            {
                Session = context.Session,
                NoSessionEnd = true,
                ProcessStepPredicate = processStepPredicate,
#if NET35 || NOASYNC
                UndoFinishAction = () => MoveBackUndoFinishAction(context, stepFound)
#else
                UndoFinishAction = async() => await MoveBackUndoFinishAction(context, stepFound)
#endif
            });
Esempio n. 8
0
 public EntersTunnels(Actor self, EntersTunnelsInfo info)
 {
     this.info = info;
     move      = self.Trait <IMove>();
     moveInfo  = self.Info.TraitInfo <IMoveInfo>();
 }
Esempio n. 9
0
 public static Boolean IsDetailed(this IMoveInfo move)
 {
     return(move.ValueType() == MoveValueType.Detailed);
 }
Esempio n. 10
0
 protected BaseMovesModel(IMoveInfo iMove, OperationType type)
     : this(iMove)
 {
     Type = type;
 }