public MapObject(MapObjectData data) { MoveRange = data.MoveRange; Cost = data.Cost; Prefab = GameObject.Instantiate(data.gameobject, GameObject.Find("Map").transform); }
void ObjectPostConfig(GameObject target, ObjectFacing inputFacing) { MapObjectData tempData = target.GetComponent <MapObjectData> (); switch (tempData.type) { case ObjectType.Player: // add to list MainGameManager._Instance.PlayerList.Add(target); break; case ObjectType.Enemy: // add to list MainGameManager._Instance.enemyList.Add(target); break; case ObjectType.Wall: // add to list MainGameManager._Instance.wallList.Add(target); break; case ObjectType.DirectionalMove: target.GetComponent <ObjectMovement> ().facingConfig = inputFacing; MainGameManager._Instance.enemyList.Add(target); break; case ObjectType.Goal: print("Goal Established"); break; default: Debug.LogError("ERROR: GENERATED OBJECT DOESN'T HAVE A COMPATIBLE TYPE!"); break; } }
public static TerrainCellType GetTerrainCellType(this MapObjectData mapObjectData, Dictionary <UnitType, int> myArmy = null) { if (mapObjectData.Wall != null) { return(TerrainCellType.Block); } if (mapObjectData.NeutralArmy != null) { if (myArmy == null || Combat.Resolve(new ArmiesPair(myArmy, mapObjectData.NeutralArmy.Army)).IsDefenderWin) { return(TerrainCellType.Block); } } switch (mapObjectData.Terrain) { case Terrain.Road: return(TerrainCellType.Road); case Terrain.Grass: return(TerrainCellType.Grass); case Terrain.Snow: return(TerrainCellType.Snow); case Terrain.Marsh: return(TerrainCellType.Marsh); //value of desert mb equals value of snow`s case Terrain.Desert: return(TerrainCellType.Snow); } return(TerrainCellType.Block); }
public PlaceInfo(MapObjectData data) { pos = new Vector2(data.x, data.y); team = (eCombatTeam)Enum.Parse(typeof(eCombatTeam), data.team); no = data.no; type = (eObjType)Enum.Parse(typeof(eObjType), data.type); }
protected MapObjectData <TUnitsCount> BuildMapInfo(Tile tile, Player player) { var mapObjectData = new MapObjectData <TUnitsCount> { Location = tile.Location.ToLocationInfo(), Terrain = TerrainConverter[tile.Terrain] }; if (player != null) { mapObjectData.Hero = new Hero <TUnitsCount>(player.Name, ConvertArmy(player.Army)); } foreach (var obj in tile.Objects) { string owner = null; if (obj is CapturableObject) { var capt = (CapturableObject)obj; owner = capt.Owner?.Name; } if (obj is Wall) { mapObjectData.Wall = new ClientClasses.Wall(); } if (obj is Garrison) { var army = ((Garrison)obj).Army; mapObjectData.Garrison = new Garrison <TUnitsCount>(owner, ConvertArmy(army)); } if (obj is NeutralArmy) { var army = ((NeutralArmy)obj).Army; mapObjectData.NeutralArmy = new NeutralArmy <TUnitsCount>(ConvertArmy(army)); } if (obj is Mine) { mapObjectData.Mine = new ClientClasses.Mine(((Mine)obj).Resource, owner); } if (obj is Dwelling) { var dw = (Dwelling)obj; mapObjectData.Dwelling = new ClientClasses.Dwelling(dw.Recruit.UnitType, dw.AvailableUnits, owner); } if (obj is ResourcePile) { var rp = (ResourcePile)obj; mapObjectData.ResourcePile = new ClientClasses.ResourcePile(rp.Resource, rp.Quantity); } } return(mapObjectData); }
public void LoadMap() { string path = MapSetting.MAP_DATA_FOLDER_NAME + MapFileName; MapData mapData = new MapData(path); MapObjectData mapObject = new MapObjectData(path + "_Object"); DrawingMap.DrawMap(mapData, mapObject, CenterPosition, Quaternion.identity); }
public void TestParseMapObjectData(string mapObjectDataFilePath) { using var original = FileProvider.GetFile(mapObjectDataFilePath); using var recreated = new MemoryStream(); MapObjectData.Parse(original, true).SerializeTo(recreated, true); StreamAssert.AreEqual(original, recreated, true); }
static public GameObject DrawMap(MapData map, MapObjectData mapObject, Vector3 pos, Quaternion rot) { if (map == null || mapObject == null) { return(null); } return(DrawCells(mapObject.GetObjectEnumerator(), map.MapSizeX, map.MapSizeZ, pos)); }
private void CreateObject(MapObjectData mapObj) { if (mapObj == null) { return; } var curObj = Instantiate(mapObj.Prefab, mapObj.Location, Quaternion.identity); curObj.transform.SetParent(mapObj.Parrent.transform, true); }
static void GenerateObject(MapObjectData objectData, Vector3 position) { GameObject prefab = objectData.mapObjects[Random.Range(0, objectData.mapObjects.Count)]; if (prefab != null) { GameObject go = Object.Instantiate(prefab, position, Quaternion.identity, objectData.parent); go.name = string.Format("{0}-{1}", objectData.parent.name, objectData.parent.childCount); GameObjectUtility.SetStaticEditorFlags(go, StaticEditorFlags.NavigationStatic); } }
public MapObject addMapObjectToStage(string mapObjectId, IVector3 position) { MapObjectData mobjData = GameManager.info.mapObjectData[mapObjectId]; MapObject mobj = getMapObject(); mobj.init(mobjData, position); currentMapObjects.Add(mobj); return(mobj); }
private void CreateObject(MapObjectData mapObj) { if (mapObj == null) { return; } var curObj = mapObj.Prefab == player? // тут переделать под сеть (сетевой/отслеживаемый объект или нет?) PhotonNetwork.Instantiate(mapObj.Prefab.name, mapObj.Location, Quaternion.identity) : Instantiate(mapObj.Prefab, mapObj.Location, Quaternion.identity); curObj.transform.SetParent(mapObj.Parrent.transform, true); }
// makes the tile belonging to player if he can occupy it // this overload is for map initialization, it places a simple unit to this tile public bool OccupyTile(int i, int j, Player player, MapObjectData unitData = null) { HexTile h = map[i, j]; h.Owner = player; if (unitData != null) { MapObject unit = new MapObject(unitData); h.mapObject = unit; } return(true); }
// Проверка видим ли мы врага private Cell FindEnemy() { var heroes = sensorData.Map.Objects.Where(o => o.Hero != null).Select(o => o); MapObjectData enemy = null; if (heroes.Count() == 1) { return(new Cell()); } enemy = heroes.Where(o => o.Hero.Name != sensorData.MyRespawnSide). Select(o => o).FirstOrDefault(); // Если врага нет, переходим к следующему действию if (enemy == null) { return(new Cell()); } int enemyArmy = 0; // Для каждого типа юнита записываем его потери foreach (var item in enemy.Hero.Army) { enemyArmy += item.Value; } if ((Cell)enemy.Location == new Cell(0, 0) && enemyArmy == 0) { return(new Cell()); } // Оцениваем исход боя в случае нападения на врага var attack = Combat.Resolve(new ArmiesPair(sensorData.MyArmy, enemy.Hero.Army)); // Если мы проигрываем в нападении if (attack.IsDefenderWin) { FindSecurityDwelling(); } // Оцениваем исход боя в случае нападения врага var defend = Combat.Resolve(new ArmiesPair(enemy.Hero.Army, sensorData.MyArmy)); // Если мы выигрываем в обороне if (defend.IsDefenderWin) { // Возвращаем координату врага return((Cell)enemy.Location); } return(FindSecurityDwelling()); }
public MapObjectData GetData() { MapObjectData data = new MapObjectData(); data.data = new int[2]; data.objType = GetType().ToString(); data.data[0] = fuelAmount; data.data[1] = isActive ? 1 : 0; return(data); }
// ReSharper disable once InconsistentNaming private static Direction?BFS(MapObjectData currentObject, MapObjectData desiredObject, Dictionary <MapObjectData, HashSet <Neighbour> > adjacencyList) { var used = new HashSet <MapObjectData>(); var path = new Dictionary <MapObjectData, MapObjectData>(); var queue = new Queue <MapObjectData>(); queue.Enqueue(currentObject); // Traverse graph while (queue.Count != 0) { var next = queue.Dequeue(); foreach (var adjacentObject in adjacencyList[next]) { var neighbor = adjacentObject.Vertex; if (used.Contains(neighbor)) { continue; } if (neighbor.Wall != null || neighbor.NeutralArmy != null) { continue; } queue.Enqueue(neighbor); used.Add(neighbor); path[neighbor] = next; } } if (!path.ContainsKey(desiredObject)) { return(null); } // Restore path // Find next object var nextObject = desiredObject; while (path[nextObject] != currentObject) { nextObject = path[nextObject]; } // Get direction foreach (var neighbor in adjacencyList[currentObject]) { if (neighbor.Vertex.Equals(nextObject)) { return(neighbor.OffsetDirection); } } return(Direction.Down); }
public void NewMap(string fileName, int mapSizeX, int mapSizeZ) { if (mapObjectParent != null) { Destroy(mapObjectParent); } MapSizeX = mapSizeX; MapSizeZ = mapSizeZ; MapFileName = fileName; MapDataCollection = new MapData(MapSizeX, MapSizeZ, CenterPosition); MapObjectDataCollection = new MapObjectData(); DrawMap(); }
public Move(HommClient client, Pathfinder pathfinder, HommSensorData sensorData, MapObjectData target) { Client = client; Pathfinder = pathfinder; Target = target; SensorData = sensorData; EnemyArmy = Target.NeutralArmy?.Army ?? (Target.Hero?.Name != sensorData.MyRespawnSide ? Target.Hero?.Army : null) ?? (Target.Garrison?.Owner != sensorData.MyRespawnSide ? Target.Garrison?.Army : null); if (EnemyArmy != null) { CombatResult = Combat.Resolve(new ArmiesPair(SensorData.MyArmy, EnemyArmy)); } }
public void SetData(MapObjectData data) { inventorySize = data.data[0]; inventory = new int[inventorySize]; if (inventorySize > 0) { for (int i = 0; i < inventorySize; i++) { inventory[i] = data.data[i + 1]; } } durability = (float)(data.data[inventorySize + 1] * 0.001); }
/// <summary> /// Init layer /// </summary> /// <param name="mapObjectData"></param> public void InitLayer(MapObjectData mapObjectData) { IEnumerator mapObjectItr = mapObjectData.GetObjectEnumerator(); while (mapObjectItr.MoveNext()) { MapObject mapObject = mapObjectItr.Current as MapObject; int len = mapObject.ObjectDataList.Count; for (int i = 0; i < len; i++) { MapObject.ObjectData obj = mapObject.ObjectDataList[i]; string layerName = obj.LayerName; AddObjectToLayer(layerName, obj); } } }
public void TestCreateNewObjectData() { var objectData = new MapObjectData( new MapUnitObjectData(Array.Empty <ObjectModification>()), new MapItemObjectData(Array.Empty <ObjectModification>()), new MapDestructableObjectData(Array.Empty <ObjectModification>()), new MapDoodadObjectData(Array.Empty <ObjectModification>()), new MapAbilityObjectData(Array.Empty <ObjectModification>()), new MapBuffObjectData(Array.Empty <ObjectModification>()), new MapUpgradeObjectData(Array.Empty <ObjectModification>())); using var memoryStream = new MemoryStream(); objectData.SerializeTo(memoryStream, true); memoryStream.Position = 0; MapObjectData.Parse(memoryStream); }
/// <summary> /// Load /// </summary> /// <param name="fileName"></param> /// <param name="mapObjectData"></param> public void Load(string fileName, MapObjectData mapObjectData) { mapLayers.Clear(); TextAsset textAsset = Resources.Load(fileName) as TextAsset; if (textAsset != null) { StringReader sr = new StringReader(textAsset.text); string s = ""; while ((s = sr.ReadLine()) != null) { loadLayer(s); } InitLayer(mapObjectData); } }
public static Cell ToCell(this MapObjectData mapObjectData, Dictionary <UnitType, int> myArmy = null) { var x = mapObjectData.Location.X; var y = mapObjectData.Location.Y; int resourcesValue = 0; if (mapObjectData.Dwelling != null) { resourcesValue = mapObjectData.Dwelling.AvailableToBuyCount; } if (mapObjectData.ResourcePile != null) { resourcesValue = mapObjectData.ResourcePile.Amount; } return(new Cell(x, y, mapObjectData.GetTerrainCellType(myArmy), mapObjectData.GetObjectCellType(), resourcesValue)); }
public void ImportPattern(string fileName) { string path = MapSetting.MAP_PATTERN_FOLDER_NAME + fileName; mapData = new MapData(path); mapObjectData = new MapObjectData(path + "_Object"); float heightest = 0f; IEnumerator mapItr = mapData.GetMapEnumerator(); while (mapItr.MoveNext()) { CellData cell = mapItr.Current as CellData; heightest = heightest < cell.GetHeightest() ? cell.GetHeightest() : heightest; } assetSize = new Vector3(mapData.MapSizeX, heightest, mapData.MapSizeZ); FileName = fileName; }
public void LoadMap(string fileName) { MapFileName = fileName; string path = MapSetting.MAP_DATA_FOLDER_NAME + MapFileName; MapDataCollection = new MapData(path); MapSizeX = MapDataCollection.MapSizeX; MapSizeZ = MapDataCollection.MapSizeZ; CenterPosition = MapDataCollection.MapCenterPosition; if (IsUsedByEditor) { MapObjectDataCollection = new MapObjectData(path + "_Object"); DrawMap(); } else { Application.LoadLevelAdditive(fileName); } }
public override void GenerateObjects() { _map.MapObjects = new List <MapObjectData>(); var obstacles = _mapParams.MapObjectPrefabs .Where(o => o.ObjectType == ObjectTypeEnum.UndestructableObstacle) .ToArray(); for (int i = 0; i < 100; i++) { var objData = new MapObjectData(); objData.Prefab = obstacles[Random.Range(0, obstacles.Length)]; objData.InstantiatePosition = new Vector3( Random.Range(0, _mapParams.MapWidth + 2) * _mapParams.TileSize, Random.Range(5, _mapParams.MapLength) * _mapParams.TileSize, 0); objData.InstantiateRotation = Quaternion.Euler(0, 0, Random.Range(0, 359)); _map.MapObjects.Add(objData); } }
public MapObjectData GetData() { MapObjectData data = new MapObjectData(); data.objType = GetType().ToString(); inventorySize = inventory.Length; data.data = new int[inventorySize + 2]; data.data[0] = inventorySize; for (int i = 0; i < inventorySize; i++) { data.data[i + 1] = inventory[i]; } data.data[inventorySize + 1] = Mathf.RoundToInt(durability * 1000); return(data); }
private void CategorizeObject(MapObjectData mapObject) { var isHostileArmy = mapObject.Garrison != null && mapObject.Garrison.Owner != SensorData.MyRespawnSide || mapObject.Hero != null && mapObject.Hero.Name != SensorData.MyRespawnSide || mapObject.NeutralArmy != null; var isResourcePile = mapObject.ResourcePile != null; var isNonFriendlyMine = mapObject.Mine != null && mapObject.Mine.Owner != SensorData.MyRespawnSide; var isFriendlyMine = mapObject.Mine != null && mapObject.Mine.Owner == SensorData.MyRespawnSide; var isDwelling = mapObject.Dwelling != null; if (isHostileArmy || isResourcePile || isNonFriendlyMine) { ReachableObjects.MoveTargets.Add(mapObject); } else if (isDwelling) { ReachableObjects.MoveAndHireTargets.Add(mapObject); } if (isFriendlyMine) { OwnedMines[mapObject.Mine.Resource]++; } }
public ActionManager(HommClient client, HommSensorData sensorData) { Client = client; SensorData = sensorData; var startCell = sensorData.Location.CreateCell(); EnemyRespawn = startCell.SameLocation(new Cell(0, 0)) ? sensorData.Map.Objects.SingleOrDefault(o => o.Location.X == 13 && o.Location.Y == 13) : sensorData.Map.Objects.SingleOrDefault(o => o.Location.X == 0 && o.Location.Y == 0); MapType = MapType.Single; if (sensorData.Map.Objects.Count < sensorData.Map.Height * sensorData.Map.Width) { MapType = MapType.DualHard; } else if (EnemyRespawn.Hero != null) { MapType = MapType.Dual; } Map = new List <Cell>(); }
void spawnObjects() { WorldMapData data = WorldMapData.instance; foreach(Hexagon tile in data.tiles){ if(tile.traversable && Random.Range(0f, 1f) <= 0.025){ MapObjectData obj = new MapObjectData(); obj.appearanceID = Random.Range(0f, 1f) >= 0.5 ? 0 : 1; tile.mapObjects.Add(obj); } } }
public Neighbour(MapObjectData vertex, Direction offsetDirection) { Vertex = vertex; OffsetDirection = offsetDirection; }
public MapObjectMovedMessage(MapObjectData objData, Vec2int lastTile) { super("MapObjectMoved"); this.objData = objData; this.lastTile = lastTile; }