private void FindPath()
        {
            this.squadPawns
                = map.mapPawns
                  .AllPawnsSpawned.FindAll((obj) => obj.Faction == Faction.OfPlayer);

            Log.Message("Starting PathFinding");

            SquadPather pather =
                new SquadPather(map);


            Log.Message("Starting PathFinding" + squadPawns[0]
                        .Position.GetRegion(map)
                        .Equals(this.target)
                        );

            this.path = pather.GetSquadPathFromTo(
                squadPawns[0].Position.GetRegion(map),
                this.target,
                this.fac,
                100
                );

            Log.Message("nodes Counts " + this.path.nodes.Count);
        }
        //TODO FINISH EVENT SYSTEM.................................................................................

        private void FindPathSafe()
        {
            if (!this.target.IsValid)
            {
                throw new NullReferenceException();
            }

            SquadPather pather =
                new SquadPather(map);

            this.PathOfSquad = pather.GetSquadPathFromTo(squadPawns[0].Position.GetRegion(map)
                                                         , targetRegion
                                                         , fac, 0f).nodes;
        }
Example #3
0
        private void FindPath()
        {
            if (this.cur_target != this.target)
            {
                cur_target = target;
            }

            SquadPather pather = new SquadPather(map);

            this.squadPath = pather.GetSquadPathFromTo(squadPawns.First().GetRegion()
                                                       , target, faction, 0f).nodes;

            if (squadPath.Count() == 0)
            {
                this.cur_target = null;

                this.target = null;
            }

            foreach (Pawn pawn in squadPawns)
            {
                if (!squadOrdersForPawns.ContainsKey(pawn))
                {
                    squadOrdersForPawns.Add(pawn, new JobNode());

                    squadOrdersForPawns[pawn].jobs = new List <Job>();
                }

                squadOrdersForPawns[pawn].jobs.Clear();

                foreach (Region region in this.squadPath)
                {
                    squadOrdersForPawns[pawn].jobs.Add(GotoJob(region.RandomCell));
                }
            }
        }
Example #4
0
        private Job Search(Pawn pawn)
        {
            //float verbRange = pawn.equipment?.PrimaryEq?.PrimaryVerb.verbProps.range ?? 0;

            var AntiScore = 0;

            var Score = FindSightAndRange(pawn, out AntiScore);


            if (AntiScore > squadPawns.Count())
            {
                return(new Job(JobDefOf.FleeAndCower));
            }

            if (AntiScore == 0 && Score == 0)
            {
                SquadPather pather = new SquadPather(map);

                Pawn enemy = null;

                var Min = 10000;

                var temp_x = 0;

                foreach (Pawn p in map.mapPawns.AllPawnsSpawned.FindAll(t => faction.HostileTo(t.Faction)))
                {
                    var temp = FindSightAndRangeAll(p, out temp_x);

                    if (temp < Min)
                    {
                        enemy = p;
                        Min   = temp;
                    }
                }

                if (enemy == null)
                {
                    return(null);
                }

                if (Math.Sqrt(
                        Math.Pow(pawn.Position.x - enemy.Position.x, 2)
                        +
                        Math.Pow(pawn.Position.y - enemy.Position.y, 2)
                        ) <= getWeaponRange(pawn))
                {
                    foreach (Pawn p in squadPawns)
                    {
                        var jobs = squadOrdersForPawns[pawn].jobs;

                        Job combat = new Job(JobDefOf.WaitCombat);

                        combat.expireRequiresEnemiesNearby = false;

                        jobs.Add(combat);
                    }
                }

                SquadPath path = pather.GetSquadPathFromTo(pawn.GetRegion(), enemy.GetRegion(), faction, 0f);

                if (path.nodes.Count > 0)
                {
                    path.nodes.RemoveAt(0);
                }
                else
                {
                    return(null);
                }


                foreach (Pawn p in squadPawns)
                {
                    var range = getWeaponRange(p);

                    int region_num = (int)(range / 10f) + 1;

                    squadOrdersForPawns[pawn].jobs.Clear();

                    var jobs = squadOrdersForPawns[pawn].jobs;

                    for (int i = 0; i < path.nodes.Count - region_num; i++)
                    {
                        Job job = new Job(JobDefOf.Goto, path.nodes[i].RandomCell);

                        job.expireRequiresEnemiesNearby = false;

                        jobs.Add(job);

                        job = new Job(JobDefOf.WaitCombat);

                        jobs.Add(job);
                    }

                    jobs.Add(new Job(CE_JobDefOf.RunForCover));

                    Job combat = new Job(JobDefOf.WaitCombat);

                    combat.expireRequiresEnemiesNearby = false;

                    jobs.Add(combat);
                }
            }

            if (squadOrdersForPawns[pawn].jobs.Count == 0)
            {
                this.Search(pawn);

                Job jb = new Job(JobDefOf.WaitCombat);

                jb.expiryInterval = 60 * 4;

                return(jb);
            }

            Job temp_job = squadOrdersForPawns[pawn].jobs[0];

            squadOrdersForPawns[pawn].jobs.RemoveAt(0);

            return(temp_job);
        }