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;
}
