public static Vector3Int GetClosestPositionWithinY(this Vector3Int goalPosition, Vector3Int currentPosition, int minMaxY)
{
var pos = currentPosition;
if (PathingManager.TryCanStandNear(goalPosition, out var canStand, out pos) && !canStand)
{
var y = -1;
var negY = minMaxY * -1;
while (PathingManager.TryCanStandNear(goalPosition.Add(0, y, 0), out var canStandNow, out pos) && !canStandNow)
{
if (y > 0)
{
y++;
if (y > minMaxY)
{
break;
}
}
else
{
y--;
if (y < negY)
{
y = 1;
}
}
}
}
return(pos);
}
static void Prefix(Pathfinder __instance, ref Vector3 startPos, ref Vector3 endPos, int teamId)
{
bool flagStart = false;
bool flagEnd = false;
Cell start = World.inst.GetCellData(startPos);
Cell end = World.inst.GetCellData(endPos);
Pathfinder.Node newStart = null;
Pathfinder.Node newEnd = null;
if (start != null)
{
if (PathingManager.BlockedCompletely(start))
{
newStart = typeof(Pathfinder).GetMethod("SearchForClosestUnblockedCell", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, new object[]
{
(int)startPos.x,
(int)startPos.z,
startPos,
endPos,
teamId
}) as Pathfinder.Node;
if (newStart != null)
{
flagStart = true;
}
}
}
if (end != null)
{
if (PathingManager.BlockedCompletely(end))
{
newEnd = typeof(Pathfinder).GetMethod("SearchForClosestUnblockedCell", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, new object[]
{
(int)endPos.x,
(int)endPos.z,
endPos,
startPos,
teamId
}) as Pathfinder.Node;
if (newEnd != null)
{
flagEnd = true;
}
}
}
if (flagStart)
{
startPos = newStart.cell.Center;
}
if (flagEnd)
{
endPos = newEnd.cell.Center;
}
}
public Vector3Int GetJobLocation()
{
var currentPos = NPC.Position;
if (_colonyState.CallToArmsEnabled && _weapon != null)
{
_target = MonsterTracker.Find(currentPos, _weapon.Range, _weapon.Damage);
if (_target != null)
{
return(currentPos);
}
_target = MonsterTracker.Find(currentPos, CALL_RAD, _weapon.Damage);
if (_target != null)
{
var ranged = _weapon.Range - 5;
if (ranged < 0)
{
ranged = 1;
}
Position = new Vector3Int(_target.Position).Add(ranged, 0, ranged);
PathingManager.TryCanStandNear(Position, out var canStandNear, out var newPosition);
if (!canStandNear || (!PathingManager.TryCanStandAt(newPosition, out var canStand) && canStand))
{
_tmpVals.SetAs(COOLDOWN_KEY, _weapon.CooldownMissingItem);
_waitingFor++;
}
else
{
return(Position);
}
}
else
{
_tmpVals.SetAs(COOLDOWN_KEY, _weapon.CooldownMissingItem);
_waitingFor++;
}
}
if (_waitingFor > 10)
{
var banner = NPC.Colony.GetClosestBanner(currentPos);
if (banner != null)
{
return(banner.Position);
}
}
return(currentPos);
}
public void Path()
{
Debug.Log($"Start Platform {_startPlatform.name} End Platform: {this.name}");
var path = PathingManager.GetPath(_startPlatform, this);
while (path.Count > 0)
{
Debug.Log(path.Pop().name);
}
}
public static void DoElevationBlock(Cell cell, ref bool result)
{
CellMark mark = ElevationManager.GetCellMark(cell);
if (mark != null)
{
if (PathingManager.BlockedCompletely(cell))
{
result = true;
}
}
}
public TargetingController()
{
Service.Set <TargetingController>(this);
this.pathingManager = Service.Get <PathingManager>();
this.shooterController = Service.Get <ShooterController>();
this.spatialIndexController = Service.Get <SpatialIndexController>();
EntityController entityController = Service.Get <EntityController>();
this.defensiveTroopNodeList = entityController.GetNodeList <DefensiveTroopNode>();
this.offensiveTroopNodeList = entityController.GetNodeList <OffensiveTroopNode>();
this.offensiveHealerNodeList = entityController.GetNodeList <OffensiveHealerNode>();
this.defensiveHealerNodeList = entityController.GetNodeList <DefensiveHealerNode>();
}
public override void OnNPCUpdate(NPCBase npc)
{
Assert.IsFalse(pathingThreadIsQueued);
if (pathingThreadResult != EPathResult.None)
{
var resultRead = pathingThreadResult;
pathingThreadResult = EPathResult.None;
switch (resultRead)
{
case EPathResult.AdjustPosition:
npc.SetPosition(pathingThreadPathStart);
npc.state.SetCooldown(npc.oneOverSpeed);
return;
case EPathResult.NotFoundPath:
OnFailGoal(npc);
return;
case EPathResult.NotFoundViaNavMesh:
{
// try to find it via the direct method instead
if (StorageFactory.CrateTracker.TryGetClosestInColony(npc.Colony, npc.Position, out var directGoal))
{
CrateLocation = directGoal;
if (PathingManager.TryGetClosestPositionWorldNotAt(directGoal, npc.Position, out bool result, out var directGoalStanding) && result)
{
crateLocationStanding = directGoalStanding;
QueuePathThreadActionWithGoal(npc);
}
else
{
OnFailGoal(npc, false);
}
}
else
{
if (ServerManager.BlockEntityTracker.BannerTracker.TryGetClosest(npc.Position, out var banner))
{
CrateLocation = banner.Position;
crateLocationStanding = banner.Position;
QueuePathThreadActionWithGoal(npc);
}
else
{
OnFailGoal(npc);
}
}
return;
}
public TargetingController()
{
Service.TargetingController = this;
this.pathingManager = Service.PathingManager;
this.shooterController = Service.ShooterController;
this.spatialIndexController = Service.SpatialIndexController;
EntityController entityController = Service.EntityController;
this.defensiveTroopNodeList = entityController.GetNodeList <DefensiveTroopNode>();
this.offensiveTroopNodeList = entityController.GetNodeList <OffensiveTroopNode>();
this.offensiveHealerNodeList = entityController.GetNodeList <OffensiveHealerNode>();
this.defensiveHealerNodeList = entityController.GetNodeList <DefensiveHealerNode>();
EventManager eventManager = Service.EventManager;
eventManager.RegisterObserver(this, EventId.ProcBuff);
eventManager.RegisterObserver(this, EventId.RemovingBuff);
}
void Start()
{
Ball = GameObject.FindGameObjectWithTag("Ball");
_machine = FindObjectOfType <StateMachine>();
_scorer = GameObject.FindGameObjectWithTag("Player");
_ballMachine = Ball.GetComponent <BallStateMachine>();
_gameState = GameState.Drawing;
_playerMachine = _scorer.GetComponent <VelocityScript>();
_pather = GetComponent <PathingManager>();
_grid = Grid.GetInstance();
_grid.HideGrid(true);
}
static void Postfix(Building PendingObj, ref PlacementValidationResult __result)
{
if (__result == PlacementValidationResult.Valid)
{
if (BuildingPlacePatch.UnevenTerrain(PendingObj))
{
__result = PlacementValidationResult.MustBeOnFlatLand;
}
if (PathingManager.BlockedCompletely(World.inst.GetCellData(PendingObj.transform.position)))
{
__result = PlacementValidationResult.OutsideOfTerritory;
CurrentPlacementOnBlockedCell = true;
}
else
{
CurrentPlacementOnBlockedCell = false;
}
}
}
static void Postfix(Pathfinder __instance, ref Pathfinder.Node __result, int sx, int sz, Vector3 start, Vector3 end, int teamId)
{
try
{
Cell cell = null;
float num = float.MaxValue;
int num2 = 1;
int num3 = Mathf.Clamp(sx - num2, 0, World.inst.GridWidth - 1);
int num4 = Mathf.Clamp(sx + num2, 0, World.inst.GridWidth - 1);
int num5 = Mathf.Clamp(sz - num2, 0, World.inst.GridHeight - 1);
int num6 = Mathf.Clamp(sz + num2, 0, World.inst.GridHeight - 1);
for (int i = num3; i <= num4; i++)
{
for (int j = num5; j <= num6; j++)
{
Cell cellDataUnsafe = World.inst.GetCellDataUnsafe(i, j);
if (cellDataUnsafe != null)
{
if (!__instance.blocksPath(cellDataUnsafe, teamId) && !PathingManager.BlockedCompletely(cellDataUnsafe))
{
float num7 = Mathff.DistSqrdXZ(cellDataUnsafe.Center, start);
if (num7 < num)
{
num = num7;
cell = cellDataUnsafe;
}
}
}
}
}
if (cell != null)
{
__result = __instance.GetFieldValue <Pathfinder.Node[, ]>("pathGrid")[cell.x, cell.z];
return;
}
__result = null;
}
catch (Exception ex)
{
DebugExt.HandleException(ex);
}
}
private void OnCollisionEnter2D(Collision2D p_other)
{
var collidedCollider = p_other.collider;
if (m_currentPlatform != null)
{
return;
}
if (collidedCollider.CompareTag("Ground") || collidedCollider.CompareTag("Platform"))
{
m_currentPlatform = collidedCollider.GetComponent <Platform>();
}
if (m_path == null || m_path.Count == 0)
{
m_path = PathingManager.GetPath(m_currentPlatform, m_destinationPlatform);
}
UpdateNextNode();
}
// Update is called once per frame
void FixedUpdate()
{
if ((position.x != gameObject.transform.position.x) || (position.z != gameObject.transform.position.z))
{
PathingManager pman = GameState.getInstance().pathMan;
pman.turnOnShadow(position.x, position.z);
validPlacement = GameState.getInstance().pathMan.isPlaceable(gameObject.transform.position.x, gameObject.transform.position.z);
if (!validPlacement)
{
position = gameObject.transform.position;
valid = false;
markInvalid();
return;
}
pman.turnOffShadow(gameObject.transform.position.x, gameObject.transform.position.z);
refreshBlockingValidity();
position = gameObject.transform.position;
man.updatePath();
}
valid = validCollision && validPath && validPlacement;
if (valid)
{
markValid();
}
else
{
markInvalid();
}
}
private void Awake()
{
Instance = this;
}
private Node[,,] grid; // another grid of the nodes
void Start()
{
manager = PathingManager.GetInstance();
}
private void Start()
{
m_destinationPlatform = PathingManager.RandomPlatform();
}
private static PathingManager instance; // gets an instance of pathmanager
void Start()
{
instance = gameObject.GetComponent <PathingManager>(); // setting the instance
Setup(); // calling setup function
}
private void SpawnInfantry(ContractEventData contractData)
{
SmartEntity smartEntity = this.FindIdleStarport(contractData);
if (smartEntity == null)
{
return;
}
Entity entity = contractData.Entity;
TransformComponent transformComponent = entity.Get <TransformComponent>();
BoardCell boardCell = null;
IntPosition boardPosition = new IntPosition(transformComponent.X, transformComponent.Z);
TroopTypeVO troopTypeVO = this.sdc.Get <TroopTypeVO>(contractData.Contract.ProductUid);
Service.TroopController.FinalizeSafeBoardPosition(troopTypeVO, ref entity, ref boardPosition, ref boardCell, TeamType.Defender, TroopSpawnMode.Unleashed, true);
SmartEntity smartEntity2 = Service.EntityFactory.CreateTroopEntity(troopTypeVO, TeamType.Defender, boardPosition, entity, TroopSpawnMode.Unleashed, false, true);
BoardItemComponent boardItemComp = smartEntity2.BoardItemComp;
Service.BoardController.Board.AddChild(boardItemComp.BoardItem, boardCell.X, boardCell.Z, null, false);
Service.EntityController.AddEntity(smartEntity2);
TroopComponent troopComp = smartEntity2.TroopComp;
TeamComponent teamComp = smartEntity2.TeamComp;
bool flag = false;
PathingManager pathingManager = Service.PathingManager;
pathingManager.StartPathing(smartEntity2, smartEntity, smartEntity2.TransformComp, false, out flag, 0, new PathTroopParams
{
TroopWidth = smartEntity2.SizeComp.Width,
DPS = 0,
MinRange = 0u,
MaxRange = 2u,
MaxSpeed = troopComp.SpeedVO.MaxSpeed,
PathSearchWidth = troopComp.TroopType.PathSearchWidth,
IsMelee = true,
IsOverWall = false,
IsHealer = false,
CrushesWalls = false,
IsTargetShield = false,
TargetInRangeModifier = troopComp.TroopType.TargetInRangeModifier
}, new PathBoardParams
{
IgnoreWall = teamComp != null && teamComp.IsDefender(),
Destructible = false
}, false, true);
if (!flag)
{
pathingManager.StartPathing(smartEntity2, smartEntity, smartEntity2.TransformComp, false, out flag, 0, new PathTroopParams
{
TroopWidth = smartEntity2.SizeComp.Width,
DPS = 0,
MinRange = 0u,
MaxRange = 2u,
MaxSpeed = troopComp.SpeedVO.MaxSpeed,
PathSearchWidth = troopComp.TroopType.PathSearchWidth,
IsMelee = true,
IsOverWall = false,
IsHealer = false,
CrushesWalls = false,
IsTargetShield = false,
TargetInRangeModifier = troopComp.TroopType.TargetInRangeModifier
}, new PathBoardParams
{
IgnoreWall = true,
Destructible = false
}, false, true);
}
smartEntity2.StateComp.CurState = EntityState.Moving;
bool showFullEffect = true;
if (this.numTroopEffectsByStarport == null)
{
this.numTroopEffectsByStarport = new Dictionary <Entity, int>();
}
if (this.numTroopEffectsByStarport.ContainsKey(smartEntity))
{
Dictionary <Entity, int> dictionary;
SmartEntity key;
int num;
(dictionary = this.numTroopEffectsByStarport)[key = smartEntity] = (num = dictionary[key]) + 1;
if (num >= 10)
{
showFullEffect = false;
}
}
else
{
this.numTroopEffectsByStarport.Add(smartEntity, 1);
}
if (this.troopEffectsByEntity == null)
{
this.troopEffectsByEntity = new Dictionary <Entity, TransportTroopEffect>();
}
this.troopEffectsByEntity.Add(smartEntity2, new TransportTroopEffect(smartEntity2, troopTypeVO, smartEntity, this.entityFader, new TransportTroopEffect.OnEffectFinished(this.OnTroopEffectFinished), showFullEffect));
}
