public static void CalculatePoint(Vector3Int pos) { if (!_preCalculated) { return; } var groundPos = ChunkUtil.GetDovvner(pos); var neighbourPoints = new Vector3Int[4]; neighbourPoints[0] = new Vector3Int(pos.x + 1, pos.y, pos.z - 1); neighbourPoints[1] = new Vector3Int(pos.x - 1, pos.y, pos.z - 1); neighbourPoints[2] = new Vector3Int(pos.x, pos.y + 1, pos.z - 1); neighbourPoints[3] = new Vector3Int(pos.x, pos.y - 1, pos.z - 1); var chunk = ChunkManager.CurrentChunk; foreach (var point in neighbourPoints) { if (!chunk.IsMapPos(point)) { continue; } OnElementCalculate(point.x, point.y, point.z); var ent = chunk.GetGameObjectByIndex(point); if (ent != null) { ent.PathInt = ReachMasInts[point.z][point.x][point.y]; } } OnElementCalculate(groundPos.x, groundPos.y, groundPos.z); }
public static bool IsInvalidPoint(int chunkNumber, Vector3Int point) { return((point.z + 1 < ChunkManager.MaxGroundsLvls && ChunkUtil.IsAnyEntity(chunkNumber, ChunkUtil.GetUpper(point))) || ChunkUtil.IsGround(chunkNumber, point) || ChunkUtil.IsEntity(chunkNumber, point)); }
public static bool AttackToIndex(GameUnit unit, Vector3Int posTarget) { var goodNeighbour = AI_Calculation.GetNearestNeighbour(unit.ChunkNumber, unit.CurrentPos, posTarget); if (goodNeighbour == Vector3Int.zero || !PathCalcManager.IsReaching(ChunkUtil.GetDovvner(unit.CurrentPos), goodNeighbour)) { return(false); } var path = PresetPath(unit, goodNeighbour); if (path == null) { return(false); } path.Add(new TilePosition( Util.Get3DPosByIndex(posTarget.x, posTarget.y, posTarget.z + 1) , posTarget)); // Debug.Log("Attack order from: " + ent); GameOrderManager.DoOrder(unit, path, OrderTypes.AttackOrder); return(true); }
public static GameItem SpawnItem(string itemName, Vector3Int pos, Player owner) { if (owner == null) { owner = PlayersManager.Empty; } GameEntity ent = null; var chunk = ChunkManager.CurrentChunk; if (ChunkUtil.IsAnyEntity(chunk.ChunkNumber, pos)) { ent = chunk.GetGameObjectByIndex(pos); } if (!SecondaryGroundLvL.IsEmptyPos(chunk.ChunkNumber, pos)) { SecondaryGroundLvL.GetGroundEnt(chunk.ChunkNumber, pos).KillSelf(); } var item = chunk.SetupItem(itemName, pos, owner); SecondaryGroundLvL.SetGroundEnt(chunk.ChunkNumber, pos, item); chunk.SetIndex(pos, -1); chunk.SetObjectAtPos(pos, null); if (ent != null) { chunk.SetIndex(pos, ent.PrefabIndex); chunk.SetObjectAtPos(pos, ent); } return(item); }
public static void CastAbility(GameUnit unit, Vector3Int posTarget, Ability ability) { if (unit == null) { return; } if (posTarget == Vector3Int.zero) { return; } var goodNeighbour = AI_Calculation.FindFreePosNearPos(unit.ChunkNumber, ChunkUtil.GetUpper(posTarget), false); if (goodNeighbour == Vector3Int.zero) { Debug.Log("Neighbour is zero"); return; } var neighDist = Util.GetDistanceFromTo(goodNeighbour, posTarget); var dist = Util.GetDistanceFromTo(unit.CurrentPos, posTarget); if (dist > 1) { if (neighDist > 1) { Debug.Log("Error. Cant reach target"); return; } MoveToIndex(unit, ChunkUtil.GetDovvner(goodNeighbour)); } GameOrderManager.AddCastAbilityOrder(unit, new TilePosition(ChunkUtil.GetUpper(posTarget)), ability); }
public static bool Execute(UnitOrder order) { //Debug.Log("Executing to pos - " + order.GetTo().Index); var index = ChunkUtil.GetUpper(order.GetTo().Index); var chunkNumber = order.GetUnit().ChunkNumber; var chunk = ChunkManager.GetChunkByNum(chunkNumber); if (order.GetUnit().CurrentPos != index && ChunkUtil.IsAnyEntity(chunkNumber, index)) { var obj = chunk.GetGameObjectByIndex(index); if (obj == null) { return(GameMoveManager.CancelPathVVay(order.GetUnit())); //return false; } var underEnt = obj.GetComponent <GameEntity>(); if (underEnt.Owner != order.GetUnit().Owner) { return(AttackTo(order)); } //Debug.Log("Cancel attacking"); return(GameMoveManager.CancelPathVVay(order.GetUnit())); //return false; } //Debug.Log("Moving to: " + order.GetTo().Index); return(MoveExecutor.Execute(order)); }
public static Vector3Int GetNearestNeighbour(int chunkNumber, Vector3Int myPos, Vector3Int pos) { var list = GetGoodNeighbors(chunkNumber, pos); var minDist = -1; var p = new Vector3Int(); foreach (var point in list) { var dist = GetDistTo(myPos, point, true); if (minDist != -1 && dist > minDist) { continue; } if ((ChunkUtil.IsAnyEntity(chunkNumber, ChunkUtil.GetUpper(point)) && myPos != ChunkUtil.GetUpper(point)) || !ChunkUtil.IsCanStayHere(chunkNumber, ChunkUtil.GetDovvner(point)) || !PathCalcManager.IsReaching(ChunkUtil.GetDovvner(myPos), ChunkUtil.GetDovvner(point)) ) { continue; } minDist = dist; p = point; } return(p); }
public virtual void KillSelf() { if (Destroyed) { return; } var chunk = ChunkManager.GetChunkByNum(ChunkNumber); chunk.SetIndex(CurrentPos, -1); chunk.RemoveObject(CurrentPos); var ent = chunk.GetGameObjectByIndex(ChunkUtil.GetDovvner(CurrentPos)); if (ent != null) { Coloring.RecolorObject(ent.CurrentPos); } Destroy(gameObject); if (SecondaryGroundLvL.isSecondaryGroup(Group)) { SecondaryGroundLvL.RemovePos(ChunkNumber, CurrentPos); } Destroyed = true; }
public Vector3Int GetFreePosAnyLvl() { var emptySlots = new List <Vector3Int>(); for (var i = 0; i < IndexMas[1].Length; i++) { for (var j = 0; j < IndexMas[1][i].Length; j++) { for (int z = 1; z < ChunkManager.MaxGroundsLvls; z++) { if (IndexMas[1][i][j] != -1 || !ChunkUtil.IsGround(ChunkNumber, ChunkUtil.GetDovvner(new Vector3Int(i, j, z)))) { continue; } emptySlots.Add(new Vector3Int(i, j, z)); } } } if (emptySlots.Count == 0) { return(new Vector3Int(0, 0, 0)); } var range = Random.Range(0, emptySlots.Count); return(emptySlots[range]); }
public static void CancelOrders(GameUnit unit) { if (OrderList.ContainsKey(unit)) { //OrderList[ent].Clear(); var unitOrders = OrderList[unit]; var cancList = CanceledOrderList.ContainsKey(unit) ? CanceledOrderList[unit] : new List <UnitOrder>(); cancList.AddRange(unitOrders); CanceledOrderList[unit] = cancList; } if (!unit.IsMoving) { return; } var tilePos = unit.CurrentTilePosition; tilePos.Index = ChunkUtil.GetDovvner(tilePos.Index); AddOrder(unit, new List <UnitOrder> { new UnitOrder(unit, tilePos, OrderTypes.MoveOrder) }); unit.CanceledOrders = true; }
public virtual bool IsTimeForReproduction(GameUnit unit) { var lairPos = ChunkUtil.GetUpper(unit.GroupObj.GetLairPos()); return(IsSetUpedLairPos(unit) && !SecondaryGroundLvL.IsEmptyPos(unit.ChunkNumber, lairPos) && SecondaryGroundLvL.GetGroundEnt(unit.ChunkNumber, lairPos).OriginalName == "building_lair"); }
public static bool IsInvalidPath(Vector3Int point) { var chunkNumber = ChunkManager.CurrentChunk.ChunkNumber; return((point.z + 1 < ChunkManager.MaxGroundsLvls && ChunkUtil.IsAnyEntity(chunkNumber, ChunkUtil.GetUpper(point))) || ChunkUtil.IsMarkedIndex(chunkNumber, point) || ChunkUtil.IsEntity(chunkNumber, point)); }
public GameItem SetupItem(GameEntity ent, string name, Vector3Int pos, Player owner) { var index = Loader.GetIndexByName(name); var npc = LuaNpcGetter.GetNpcById(index); ent.Owner = owner; ent.OriginalName = name; ent.name = name; var item = ent as GameItem; var evoTo = LuaNpcGetter.GetEvolutionTo(npc); if (evoTo.Length > 0) { if (!UnitEvolution.IsHasSoloEvolution(name)) { UnitEvolution.AddToSoloDict(name, evoTo); } if (item != null) { item.SoloEvolution = true; } } var evoCross = LuaNpcGetter.GetNpcEvoCrossing(npc); if (evoCross.Keys.Count > 0) { foreach (var pair in evoCross) { UnitEvolution.AddToStackDict(name, pair.Key, pair.Value); if (!string.Equals(pair.Key, name, StringComparison.OrdinalIgnoreCase)) { UnitEvolution.AddToStackDict(pair.Key, name, pair.Value); } } } if (GroupUtil.IsItem(ent.Group)) { SecondaryGroundLvL.SetGroundEnt(ChunkNumber, pos, item); } if (GroupUtil.isBuilding(ent.Group)) { ChunkManager.AddVision(ent); } ItemEvents.OnCreateItem(item, firstCreate); Coloring.RecolorObject(ChunkUtil.GetDovvner(ent.CurrentPos)); return(item); }
public static bool MoveTo(GameUnit unit, Vector3Int vecTo) { var indexPos = ChunkUtil.GetDovvner(vecTo); var pos3D = Util.Get3DPosByIndex(vecTo); return(MoveExecutor.Execute(new UnitOrder ( unit, new TilePosition(pos3D, indexPos), OrderTypes.MoveOrder ))); }
public static bool IsAttackUnitInMemoryPos(GameUnit unit, GameUnit attackTarget) { if (!unit.IsMoving) { return(false); } var pos = unit.MovingPath.LastOrDefault(); if (pos == null) { return(false); } return(ChunkUtil.GetDovvner(attackTarget.CurrentPos) == pos.Index); }
static void OnGroundEntity(GameEntity ent) { var eUP = ChunkManager.CurrentChunk.GetGameObjectByIndex (ChunkUtil.GetUpper(ent.CurrentPos)); if (eUP != null && IsIgnored(eUP) && IsVisionBefore(eUP)) { SemiColor(ent, eUP); } else { HidingColor(ent, eUP); } }
public static void Update(GameUnit unit) { if (unit == null || unit.gameObject == null) { return; } if (!timeDict.ContainsKey(unit)) { timeDict[unit] = 0; } timeDict[unit] += Time.deltaTime; if (timeDict[unit] < TIME_AI) { return; } timeDict[unit] = 0; var _ai_state = ""; if (AI_Calculation.IsNearEnemy(unit, enemyRadiusCheck)) { var p = new Vector3Int(-1, -1, -1); var path = unit.MovingPath.ToArray().LastOrDefault(); if (path != null) { p = path.Index; } var enemy = AI_Calculation.GetNearEnemy(unit, enemyRadiusCheck); if (!unit.IsMoving || (p != new Vector3Int(-1, -1, -1) && p != ChunkUtil.GetDovvner(enemy.CurrentPos))) { SimpleOrderManager.AttackTarget(unit, enemy as GameUnit); } _ai_state = "AttackEnemy"; } // ReSharper disable once ConditionIsAlwaysTrueOrFalse if (AI_DEBUG && _ai_state != "") { Debug.LogError(unit + " State: " + _ai_state); } }
int[][] MarkGroundUpper(int[][] map, int[][] upperMap) { for (int i = 0; i < map.Length; i++) { for (int j = 0; j < map[i].Length; j++) { if (!ChunkUtil.IsGroundIndex(map[i][j])) { upperMap[i][j] = -1; } } } return(upperMap); }
public GameUnit SetupUnit(GameEntity ent, string name, Vector3Int pos, Player owner) { var index = Loader.GetIndexByName(name); var npc = LuaNpcGetter.GetNpcById(index); ent.Owner = owner; ent.OriginalName = name; ent.name = name; var unit = ent as GameUnit; var evoTo = LuaNpcGetter.GetEvolutionTo(npc); if (evoTo.Length > 0) { if (!UnitEvolution.IsHasSoloEvolution(name)) { UnitEvolution.AddToSoloDict(name, evoTo); } if (unit != null) { unit.SoloEvolution = true; } } var evoCross = LuaNpcGetter.GetNpcEvoCrossing(npc); if (evoCross.Keys.Count > 0) { foreach (var pair in evoCross) { UnitEvolution.AddToStackDict(name, pair.Key, pair.Value); if (!string.Equals(pair.Key, name, StringComparison.OrdinalIgnoreCase)) { UnitEvolution.AddToStackDict(pair.Key, name, pair.Value); } } } ChunkManager.AddVision(ent); UnitEvents.OnUnitSpawned(unit); Coloring.RecolorObject(ChunkUtil.GetDovvner(ent.CurrentPos)); return(unit); }
public virtual bool IsTimeForDeliverItem(GameUnit unit) { var lairPos = ChunkUtil.GetUpper(unit.GroupObj.GetLairPos()); if (unit.pickUped == null || !unit.GroupObj.IsSetUpedLairPos(unit) || (ChunkUtil.IsAnyEntity(unit.ChunkNumber, lairPos) && unit.CurrentPos != lairPos)) { return(false); } if (!SecondaryGroundLvL.IsEmptyPos(unit.ChunkNumber, lairPos)) { return(ItemGroup.IsCanBeStacked(unit.pickUped.OriginalName, SecondaryGroundLvL.GetGroundEnt(unit.ChunkNumber, lairPos).OriginalName)); } return(true); }
public virtual bool IsTimeForPickupItem(GameUnit unit) { if (SecondaryGroundLvL.IsEmptyPos(unit.ChunkNumber, unit.CurrentPos)) { return(false); } var item = SecondaryGroundLvL.GetGroundEnt(unit.ChunkNumber, unit.CurrentPos); return(item != null && item.CanBePickuped && !item.SoloEvolution && item.Group == "item" && unit.pickUped == null && TreeGroup.IsPickableTreeLog(item) && unit.GroupObj.GetLairPos() != ChunkUtil.GetDovvner(unit.CurrentPos)); }
public static bool IsNearEnt(int chunkNumber, Vector3Int pos) { var neighbourPoints = new Vector3Int[8]; neighbourPoints[0] = new Vector3Int(pos.x + 1, pos.y, pos.z); neighbourPoints[1] = new Vector3Int(pos.x - 1, pos.y, pos.z); neighbourPoints[2] = new Vector3Int(pos.x, pos.y + 1, pos.z); neighbourPoints[3] = new Vector3Int(pos.x, pos.y - 1, pos.z); var chunk = ChunkManager.GetChunkByNum(chunkNumber); return((from point in neighbourPoints where chunk.IsMapPos(point) && ChunkUtil.IsEntity(chunkNumber, point) select ChunkUtil.GetIndex(chunkNumber, point)).Any( index => index > 0)); }
/** * Reads whole (including chunk type) string block from stream. * Stream must be at the chunk type. */ public static StringBlock read(IntReader reader) { ChunkUtil.readCheckType(reader, CHUNK_TYPE); int chunkSize = reader.readInt(); int stringCount = reader.readInt(); int styleOffsetCount = reader.readInt(); /*?*/ reader.readInt(); int stringsOffset = reader.readInt(); int stylesOffset = reader.readInt(); StringBlock block = new StringBlock(); block.m_stringOffsets = reader.readIntArray(stringCount); if (styleOffsetCount != 0) { block.m_styleOffsets = reader.readIntArray(styleOffsetCount); } { int size = ((stylesOffset == 0) ? chunkSize : stylesOffset) - stringsOffset; if ((size % 4) != 0) { throw new IOException("String data size is not multiple of 4 (" + size + ")."); } block.m_strings = reader.readIntArray(size / 4); } if (stylesOffset != 0) { int size = (chunkSize - stylesOffset); if ((size % 4) != 0) { throw new IOException("Style data size is not multiple of 4 (" + size + ")."); } block.m_styles = reader.readIntArray(size / 4); } return(block); }
public static List <GameUnit> GetNearUnits(int chunkNumber, GameEntity ent, Vector3Int pos) { var neighbourPoints = new Vector3Int[4]; neighbourPoints[0] = new Vector3Int(pos.x + 1, pos.y, pos.z); neighbourPoints[1] = new Vector3Int(pos.x - 1, pos.y, pos.z); neighbourPoints[2] = new Vector3Int(pos.x, pos.y + 1, pos.z); neighbourPoints[3] = new Vector3Int(pos.x, pos.y - 1, pos.z); var chunk = ChunkManager.GetChunkByNum(chunkNumber); return((from point in neighbourPoints where chunk.IsMapPos(point) let index = ChunkUtil.GetIndex(chunkNumber, point) where index > 0 && ChunkUtil.IsEntity(chunkNumber, point) select chunk.GetGameObjectByIndex(point) as GameUnit into obj where obj != null select obj).ToList()); }
public static GameEntity GetNearFriendUnit(int chunkNumber, GameEntity ent, Vector3Int pos) { var neighbourPoints = new Vector3Int[4]; neighbourPoints[0] = new Vector3Int(pos.x + 1, pos.y, pos.z); neighbourPoints[1] = new Vector3Int(pos.x - 1, pos.y, pos.z); neighbourPoints[2] = new Vector3Int(pos.x, pos.y + 1, pos.z); neighbourPoints[3] = new Vector3Int(pos.x, pos.y - 1, pos.z); var chunk = ChunkManager.GetChunkByNum(chunkNumber); return((from point in neighbourPoints where chunk.IsMapPos(point) let index = ChunkUtil.GetIndex(chunkNumber, point) where index > 0 && ChunkUtil.IsEntity(chunkNumber, point) select chunk.GetGameObjectByIndex(point) into obj where obj != null select obj.GetComponent <GameEntity>()).FirstOrDefault(entEnemy => Equals(entEnemy.Owner, ent.Owner))); }
static List <TilePosition> PresetPath(GameUnit unit, Vector3Int posTarget) { var indexes = unit.PathFindObj.FindPath(ChunkUtil.GetDovvner(unit.CurrentPos), posTarget); // Debug.Log("Path = " + indexes); if (indexes == null) { var chunk = ChunkManager.GetChunkByNum(unit.ChunkNumber); chunk.ReindexTiles(); return(null); } var lastOrDefault = unit.MovingPath.LastOrDefault(); if (lastOrDefault != null && lastOrDefault.Index == posTarget) { return(null); } //Removing first point in some case if (unit.MovingPath.Count > 0 && unit.MovingPath[0].Index != unit.CurrentPos && indexes.Contains(unit.MovingPath[0].Index)) { indexes = indexes.Where(t => t != ChunkUtil.GetDovvner(unit.CurrentPos)).ToList(); } CancelOrders(unit); var path = (from ind in indexes let pos3D = Util.Get3DPosByIndex(ind.x, ind.y, ind.z + 1) select new TilePosition(pos3D, ind)).ToList(); unit.IsMoving = true; unit.MovingPath = path; return(path); }
public static void MoveToIndex(GameUnit unit, Vector3Int posTarget) { if (posTarget == Vector3Int.zero) { return; } var ent = ChunkManager.CurrentChunk.GetGameObjectByIndex(posTarget); var pos = posTarget; if (ent == null || !GroupUtil.IsGround(ent.Group)) { pos = ChunkUtil.GetDovvner(pos); } var path = PresetPath(unit, pos); if (path == null) { return; } GameOrderManager.DoOrder(unit, path, OrderTypes.MoveOrder); }
static void HidingColor(GameEntity ent, GameEntity eUP) { var check = false; if (eUP == null) { var friends = AI_Calculation.GetGoodNeighbors (ChunkManager.CurrentChunk.ChunkNumber, ent.CurrentPos); foreach (var friend in friends) { var fUP = ChunkManager.CurrentChunk.GetGameObjectByIndex (ChunkUtil.GetUpper(friend)); if (fUP != null && !IsHided(fUP)) { check = true; } } } else { check = !IsHided(eUP); } if (!check) { var spD = ent.GetComponent <SpriteRenderer>(); spD.color = static_nonVisionColor; } else { Coloring.RecolorObject(ent, true); Coloring.RecolorObject(ChunkUtil.GetUpper(ent.CurrentPos), true); Coloring.RecolorObject(ChunkUtil.GetDovvner(ent.CurrentPos), true); } }
public static GameEntity GetNearEnemy(GameEntity ent, int radius) { var chunkNumber = ent.ChunkNumber; var chunk = ChunkManager.GetChunkByNum(chunkNumber); var pos = ent.CurrentPos; var neighbourPoints = new Vector3Int[8]; for (var i = 0; i < radius; i++) { neighbourPoints[0] = new Vector3Int(pos.x + i, pos.y, pos.z); neighbourPoints[1] = new Vector3Int(pos.x - i, pos.y, pos.z); neighbourPoints[2] = new Vector3Int(pos.x, pos.y + i, pos.z); neighbourPoints[3] = new Vector3Int(pos.x, pos.y - i, pos.z); neighbourPoints[4] = new Vector3Int(pos.x + i, pos.y + i, pos.z); neighbourPoints[5] = new Vector3Int(pos.x - i, pos.y - i, pos.z); neighbourPoints[6] = new Vector3Int(pos.x - i, pos.y + i, pos.z); neighbourPoints[7] = new Vector3Int(pos.x + i, pos.y - i, pos.z); var enemy = (from point in neighbourPoints where chunk.IsMapPos(point) let index = ChunkUtil.GetIndex(chunkNumber, point) where index > 0 && ChunkUtil.IsEntity(chunkNumber, point) select chunk.GetGameObjectByIndex(point) into obj where obj != null select obj.GetComponent <GameEntity>()).FirstOrDefault(entEnemy => !Equals(entEnemy.Owner, ent.Owner)); if (enemy != null) { return(enemy); } } return(null); }
public bool TryCacheInMemory(bool shouldCacheNextChunk) { lock (_cacheSyncObj) { if (!_chunkConfig.EnableCache || _isMemoryChunk || !_isCompleted || _memoryChunk != null) { _cachingChunk = 0; return(false); } try { var chunkSize = (ulong)GetChunkSize(_chunkHeader); if (!ChunkUtil.IsMemoryEnoughToCacheChunk(chunkSize, (uint)_chunkConfig.ChunkCacheMaxPercent)) { return(false); } _memoryChunk = FromCompletedFile(_filename, _chunkManager, _chunkConfig, true); if (shouldCacheNextChunk) { Task.Factory.StartNew(() => _chunkManager.TryCacheNextChunk(this)); } return(true); } catch (OutOfMemoryException) { return(false); } catch (Exception ex) { Log.Error(string.Format("Failed to cache completed chunk {0}", this), ex); return(false); } finally { _cachingChunk = 0; } } }