protected override void OnEraseTile(Vector2Int tileXY)
{
// Add game coordinates
tileXY += Vector2Int.one;
// Find structure on tile
int playerIndex = 0;
int unitIndex = -1;
for (playerIndex = 0; playerIndex < UserData.current.selectedVariant.players.Count; ++playerIndex)
{
PlayerData.ResourceData resData = UserData.current.GetPlayerResourceData(playerIndex);
for (int i = 0; i < resData.units.Count; ++i)
{
UnitData unit = resData.units[i];
RectInt structureArea = StructureData.GetStructureArea(new Vector2Int(unit.position.x, unit.position.y), unit.typeID);
if (structureArea.Contains(tileXY))
{
unitIndex = i;
break;
}
}
if (unitIndex >= 0)
{
break;
}
}
if (unitIndex < 0)
{
return;
}
PlayerData.ResourceData playerResData = UserData.current.GetPlayerResourceData(playerIndex);
UnitData structureToRemove = playerResData.units[unitIndex];
// Remove structure from tile
playerResData.units.RemoveAt(unitIndex);
UserData.current.SetUnsaved();
m_UnitRenderer.RemoveUnit(structureToRemove);
m_MapRenderer.RefreshTiles(StructureData.GetBulldozedStructureArea(new Vector2Int(structureToRemove.position.x - 1, structureToRemove.position.y - 1), structureToRemove.typeID));
}
private bool AreUnitsInArea(RectInt area)
{
MissionVariant variant = UserData.current.GetCombinedVariant();
foreach (PlayerData player in variant.players)
{
foreach (UnitData unit in UserData.current.GetCombinedResourceData(player).units)
{
// Subtract game coordinates
RectInt otherArea = StructureData.GetStructureArea(new Vector2Int(unit.position.x - 1, unit.position.y - 1), unit.typeID);
if (RectIntersect(area, otherArea))
{
return(true);
}
}
}
return(false);
}
private bool AreUnitsOnTile(Vector2Int tileXY)
{
// Add game coordinates
tileXY += Vector2Int.one;
MissionVariant variant = UserData.current.GetCombinedVariant();
foreach (PlayerData player in variant.players)
{
foreach (UnitData unit in UserData.current.GetCombinedResourceData(player).units)
{
RectInt otherArea = StructureData.GetStructureArea(new Vector2Int(unit.position.x, unit.position.y), unit.typeID);
if (otherArea.Contains(tileXY))
{
return(true);
}
}
}
return(false);
}
protected override void OnPaintTile(Vector2Int tileXY)
{
UnitData structure = GetStructureData();
structure.position = new LOCATION(tileXY.x + 1, tileXY.y + 1); // Add game coordinates
RectInt structureArea = StructureData.GetStructureArea(tileXY, structure.typeID);
RectInt bulldozedArea = structureArea;
bulldozedArea.min -= Vector2Int.one;
bulldozedArea.max += Vector2Int.one;
// Check if area is not buildable
if (!TileMapData.IsAreaPassable(bulldozedArea))
{
return;
}
// Check if area is blocked by units or structures
if (AreUnitsInArea(structureArea))
{
return;
}
// Check if area is blocked by walls
if (AreWallsInArea(structureArea))
{
return;
}
// Add structure to tile
PlayerData player = UserData.current.selectedVariant.players[m_DropdownPlayer.value];
UserData.current.GetPlayerResourceData(player.id).units.Add(structure);
UserData.current.SetUnsaved();
m_UnitRenderer.AddUnit(player, structure);
m_MapRenderer.RefreshTiles(bulldozedArea);
}
/// <summary>
/// Generates a minimap texture and assigns it as an image.
/// </summary>
/// <param name="map">The map to to generate a minimap from.</param>
/// <param name="missionVariant">The mission variant to generate a minimap from. (optional)</param>
public void SetMap(Map map, MissionVariant missionVariant = null)
{
uint mapWidth = map.GetWidthInTiles();
uint mapHeight = map.GetHeightInTiles();
// Create minimap texture
Texture2D minimapTexture = new Texture2D((int)mapWidth * TextureManager.minimapScale, (int)mapHeight * TextureManager.minimapScale, TextureFormat.ARGB32, false);
CellTypeMap cellTypeMap = new CellTypeMap(map, missionVariant);
for (uint x = 0; x < mapWidth; ++x)
{
for (uint y = 0; y < mapHeight; ++y)
{
ulong tileMappingIndex = GetTileMappingIndex(map, cellTypeMap, new Vector2Int((int)x, (int)y));
TileMapping mapping = map.GetTileMapping(tileMappingIndex);
ulong tileSetIndex = mapping.tilesetIndex;
int tileImageIndex = mapping.tileGraphicIndex;
string tileSetPath = map.GetTilesetSourceFilename(tileSetIndex);
int tileSetNumTiles = (int)map.GetTilesetSourceNumTiles(tileSetIndex);
// Get image offset
int inverseTileIndex = tileSetNumTiles - tileImageIndex - 1;
Vector3Int cellPosition = new Vector3Int((int)x, (int)(mapHeight - y - 1), 0);
++cellPosition.y;
// Set minimap pixel
Texture2D mTexture = TextureManager.LoadMinimapTileset(tileSetPath, tileSetNumTiles);
for (int my = 0; my < TextureManager.minimapScale; ++my)
{
for (int mx = 0; mx < TextureManager.minimapScale; ++mx)
{
Color color = mTexture.GetPixel(mx, inverseTileIndex * TextureManager.minimapScale + my);
minimapTexture.SetPixel(cellPosition.x * TextureManager.minimapScale + mx, cellPosition.y * TextureManager.minimapScale + my - 1, color);
}
}
}
}
// Apply mission units to minimap
if (missionVariant != null)
{
foreach (GameData.Beacon beacon in missionVariant.tethysGame.beacons)
{
SetMinimapTile(minimapTexture, new Vector2Int(beacon.position.x, beacon.position.y) - Vector2Int.one, Color.white);
}
foreach (GameData.Marker marker in missionVariant.tethysGame.markers)
{
SetMinimapTile(minimapTexture, new Vector2Int(marker.position.x, marker.position.y) - Vector2Int.one, Color.white);
}
foreach (GameData.Wreckage wreckage in missionVariant.tethysGame.wreckage)
{
SetMinimapTile(minimapTexture, new Vector2Int(wreckage.position.x, wreckage.position.y) - Vector2Int.one, Color.white);
}
foreach (PlayerData player in missionVariant.players)
{
foreach (UnitData unit in player.resources.units)
{
RectInt unitArea = StructureData.GetStructureArea(new Vector2Int(unit.position.x, unit.position.y) - Vector2Int.one, unit.typeID);
for (int x = unitArea.xMin; x < unitArea.xMax; ++x)
{
for (int y = unitArea.yMin; y < unitArea.yMax; ++y)
{
SetMinimapTile(minimapTexture, new Vector2Int(x, y), GetPlayerColor(player));
}
}
}
}
}
// Apply minimap texture
minimapTexture.Apply();
// Update image
RefreshImage(map, minimapTexture);
}
