Exemple #1
0
        private static T Internal_CreateTask <T>() where T : Task
        {
            switch (typeof(T))
            {
            case Type taskType when taskType == typeof(MoveTask):
            {
                MoveTask t = new MoveTask();
                return(t as T);
            }

            case Type taskType when taskType == typeof(MoveTask2):
            {
                MoveTask2 t = new MoveTask2();
                return(t as T);
            }

            case Type taskType when taskType == typeof(EngageAtPositionsTask):
            {
                EngageAtPositionsTask t = new EngageAtPositionsTask();
                return(t as T);
            }

            default:
                throw new ArgumentException(
                          message: "Not a recognized type of task");
                //return null;
            }
        }
Exemple #2
0
        public int SolveParallelCompatibilityConflicts()
        {
            foreach (var pl in new List <TaskPlan2>(unit.GetParticipatedGroupsPlans()))
            {
                if (pl.GetCurrentTaskInPlan() != this)
                {
                    UnitGroup ug = pl.GetCurrentTaskInPlan().GetActorGroup() as UnitGroup;

                    MoveTask mvtsk = pl.GetCurrentTaskInPlan() as MoveTask;
                    if (mvtsk != null && GetActorGroup() != mvtsk.GetActorGroup())
                    {
                        if (mvtsk.unit == unit && unit.IsLeaf())
                        {
                            mvtsk.actorGroupAsUG.RemoveUnitFromGroup(unit);
                            return(1);
                        }
                    }
                }
            }

            return(0);
        }
Exemple #3
0
        protected override void InstanceSetTaskPlan(TaskPlan2 taskPlan)
        {
            base.InstanceSetTaskPlan(taskPlan);

            if (taskPlan != null)
            {
                UpdateFormationFacing(unit, GetTaskMarker().GetWorldPosition());

                unit.GetFormation().FormTest();

                foreach (var subg in actorGroupAsUG.GetSubGroupsAsUG())
                {
                    Vector3 wpos;
                    wpos = subg.GetActorsAsUnits()[0].GetFormation().GetAcceptableMovementTargetPosition(GetTaskMarker().GetWorldPosition());

                    MoveTaskMarker tm = TaskMarker.CreateInstanceAtWorldPosition <MoveTaskMarker>(wpos);
                    tm.AddWaypointMarker(WaypointMarker.CreateWaypointMarker(wpos));

                    MoveTask chmvt = tm.GetTask() as MoveTask;

                    chmvt.parentActorMoveTask = this;
                    subActorsMoveTasks.Add(subg, chmvt);

                    chmvt.SubscribeOnDestruction("removeparentssubactorsmovetasks", () => subActorsMoveTasks.Remove(subg));

                    subg.SubscribeOnParentGroupChange("onchangeparentgroup",
                                                      () =>
                    {
                        chmvt.parentActorMoveTask = null;
                        subActorsMoveTasks.Remove(subg);
                        subg.UnsubscribeOnParentGroupChange("onchangeparentgroup");
                    });

                    var        prevtask = GetTaskPlan().GetTaskInPlanBefore(this) as MoveTask;
                    TaskMarker chprevtm;
                    if (prevtask != null && prevtask.subActorsMoveTasks.ContainsKey(subg))
                    {
                        chprevtm = prevtask.subActorsMoveTasks[subg].GetTaskMarker();
                    }
                    else
                    {
                        chprevtm = null;
                    }

                    TaskPlan2 chtp = tm.InsertAssociatedTaskIntoPlan(subg, chprevtm);
                }

                /*SubscribeOnDestruction("parentactormovetaskchange", () =>
                 * {
                 *  foreach (var chmvt in new List<MoveTask>(subActorsMoveTasks.Values))
                 *  {
                 *      chmvt.EndExecution();
                 *      chmvt.parentActorMoveTask = null;
                 *  }
                 *  subActorsMoveTasks.Clear();
                 * });*/

                SetPhase(TaskPhase.Staging);
            }
            else
            {
                foreach (var chmvt in new List <MoveTask>(subActorsMoveTasks.Values))
                {
                    chmvt.EndExecution();
                    chmvt.parentActorMoveTask = null;
                }
                subActorsMoveTasks.Clear();
            }
        }