public void RemoveTile(Vector3Int position, LayerType layerType)
{
if (metaTileMap.HasTile(position, layerType))
{
RpcRemoveTile(position, layerType, false);
}
}
private static Matrix4x4 FindObjectPosition(MetaTileMap metaTileMap, ref Vector3Int position, LayerTile tile)
{
bool onStructure = metaTileMap.HasTile(position, LayerType.Walls) ||
metaTileMap.HasTile(position, LayerType.Windows);
Quaternion rotation = Quaternion.identity;
for (int i = 0; i < 4; i++)
{
Vector3Int offset = Vector3Int.RoundToInt(rotation * Vector3.up);
bool hasStructure = metaTileMap.HasTile(position + offset, LayerType.Walls) ||
metaTileMap.HasTile(position, LayerType.Windows);
bool isOccupied = metaTileMap.HasTile(position + offset, onStructure ? LayerType.Base : LayerType.Objects);
if (onStructure != hasStructure && isOccupied == onStructure)
{
if (onStructure)
{
position += offset;
rotation *= Quaternion.Euler(0f, 0f, 180);
}
break;
}
rotation *= Quaternion.Euler(0, 0, 90);
}
return(Matrix4x4.TRS(Vector3.zero, rotation, Vector3.one));
}
void Awake()
{
tileChangeManager = transform.GetComponentInParent <TileChangeManager>();
metaDataLayer = transform.GetComponentInParent <MetaDataLayer>();
metaTileMap = transform.GetComponentInParent <MetaTileMap>();
Layer = GetComponent <Layer>();
matrix = GetComponentInParent <Matrix>();
tileChangeManager.OnFloorOrPlatingRemoved.RemoveAllListeners();
tileChangeManager.OnFloorOrPlatingRemoved.AddListener(cellPos =>
{ //Poke items when both floor and plating are gone
//As they might want to change matrix
if (!metaTileMap.HasTile(cellPos, LayerType.Floors, true) &&
!metaTileMap.HasTile(cellPos, LayerType.Base, true) &&
metaTileMap.HasTile(cellPos, LayerType.Objects, true)
)
{
foreach (var customNetTransform in matrix.Get <CustomNetTransform>(cellPos, true))
{
customNetTransform.CheckMatrixSwitch();
}
}
});
}
public void RemoveTile(Vector3Int cellPosition, LayerType layerType)
{
if (metaTileMap.HasTile(cellPosition, layerType, true))
{
RpcRemoveTile(cellPosition, layerType, false);
AddToChangeList(cellPosition, layerType);
}
}
//Poke items when both floor and plating are gone
//As they might want to change matrix
public void SwitchObjectsMatrixAt(Vector3Int cellPos)
{
if (!metaTileMap.HasTile(cellPos, LayerType.Floors) &&
!metaTileMap.HasTile(cellPos, LayerType.Base) &&
metaTileMap.HasObject(cellPos, CustomNetworkManager.Instance._isServer)
)
{
foreach (var customNetTransform in matrix.Get <CustomNetTransform>(cellPos, true))
{
customNetTransform.CheckMatrixSwitch();
}
}
}
public void UpdateOverlay(Vector3Int cellPosition, OverlayTile overlayTile)
{
cellPosition.z = 0;
if (!metaTileMap.HasTile(cellPosition, overlayTile.LayerType, true))
{
return;
}
cellPosition.z = -1;
if (IsDifferent(cellPosition, overlayTile))
{
InternalUpdateTile(cellPosition, overlayTile);
RpcUpdateTile(cellPosition, overlayTile.TileType, overlayTile.name);
AddToChangeList(cellPosition, overlayTile);
}
}
private void DoBulletDamage(BulletBehaviour bullet, Vector3 forceDir, Vector3 hitPos)
{
forceDir.z = 0;
Vector3 bulletHitTarget = hitPos + (forceDir * 0.2f);
Vector3Int cellPos = metaTileMap.WorldToCell(Vector3Int.RoundToInt(bulletHitTarget));
MetaDataNode data = metaDataLayer.Get(cellPos);
if (Layer.LayerType == LayerType.Windows)
{
LayerTile getTile = metaTileMap.GetTile(cellPos, LayerType.Windows);
if (getTile != null)
{
//TODO damage amt based off type of bullet
AddWindowDamage(bullet.damage, data, cellPos, bulletHitTarget);
return;
}
}
if (Layer.LayerType == LayerType.Grills)
{
//Make sure a window is not protecting it first:
if (!metaTileMap.HasTile(cellPos, LayerType.Windows, true))
{
if (metaTileMap.HasTile(cellPos, LayerType.Grills, true))
{
//TODO damage amt based off type of bullet
AddGrillDamage(bullet.damage, data, cellPos, bulletHitTarget);
}
}
}
}
public void UpdateOverlay(Vector3Int cellPosition, OverlayTile overlayTile, Matrix4x4?transformMatrix = null,
Color?color = null)
{
cellPosition.z = 0;
if (!metaTileMap.HasTile(cellPosition, overlayTile.LayerType))
{
return;
}
cellPosition.z = -1;
if (IsDifferent(cellPosition, overlayTile))
{
InternalUpdateTile(cellPosition, overlayTile, transformMatrix, color);
AlertClients(cellPosition, overlayTile.TileType, overlayTile.name, transformMatrix, color);
AddToChangeList(cellPosition, overlayTile, transformMatrix: transformMatrix, color: color);
}
}
/// <summary>
/// Checks if the grille's location has exposed floor plating,
/// that a cable overlap exists there,
/// and returns the highest voltage detected (for now).
/// </summary>
/// <returns>The voltage found on the cable</returns>
private float ServerGetGrilleVoltage()
{
Vector3Int targetCellPos = interaction.TargetCellPos;
MetaTileMap metaTileMap = interaction.TileChangeManager.MetaTileMap;
Matrix matrix = metaTileMap.Layers[LayerType.Underfloor].matrix;
// Check if the floor plating is exposed.
if (metaTileMap.HasTile(targetCellPos, LayerType.Floors))
{
return(0);
}
// Check for cables underneath the grille.
var eConns = matrix.GetElectricalConnections(targetCellPos);
if (eConns == null)
{
return(0);
}
// Get the highest voltage and whether there is a connection overlap.
// The current powernet implementation means the cable
// will only report a voltage if there is current flow, it seems.
// That's why we cannot simply the overlap connection's voltage,
// and both ends of the cable need to be connected to the powernet.
//
// One possible workaround is to allow a Connection.Overlap to draw
// a small amount of current, so that it registers a voltage.
// Then, we don't need to check for the highest voltage and not worry
// about whether the overlap is actually connected to a live cable.
bool overlapExists = false;
float voltage = 0;
foreach (var conn in eConns)
{
if (conn.WireEndA == Connection.Overlap || conn.WireEndB == Connection.Overlap)
{
overlapExists = true;
}
ElectricityFunctions.WorkOutActualNumbers(conn);
if (conn.Data.ActualVoltage > voltage)
{
voltage = conn.Data.ActualVoltage;
}
}
// Check that there is a cable overlap.
if (!overlapExists)
{
return(0);
}
// All checks passed, electrocute the performer!
return(voltage);
}
public bool RemoveTile(Vector3Int cellPosition, LayerType layerType)
{
if (metaTileMap.HasTile(cellPosition, layerType, true))
{
InternalRemoveTile(cellPosition, layerType, false);
RpcRemoveTile(cellPosition, layerType, false);
AddToChangeList(cellPosition, layerType);
if (layerType == LayerType.Floors || layerType == LayerType.Base)
{
OnFloorOrPlatingRemoved.Invoke(cellPosition);
}
return(true);
}
return(false);
}
public void RunOreGenerator()
{
metaTileMap = GetComponentInChildren <MetaTileMap>();
wallTilemap = metaTileMap.Layers[LayerType.Walls].GetComponent <Tilemap>();
tileChangeManager = GetComponent <TileChangeManager>();
if (CustomNetworkManager.IsServer)
{
List <OreProbability> weightedList = new List <OreProbability>();
foreach (var ores in config.OreProbabilities)
{
for (int i = 0; i < ores.SpawnChance; i++)
{
weightedList.Add(ores);
}
}
//TODO move BoundsInt bounds = wallTilemap.cellBounds to metaTileMap
BoundsInt bounds = wallTilemap.cellBounds;
List <Vector3Int> miningTiles = new List <Vector3Int>();
for (int n = bounds.xMin; n < bounds.xMax; n++)
{
for (int p = bounds.yMin; p < bounds.yMax; p++)
{
Vector3Int localPlace = (new Vector3Int(n, p, 0));
if (metaTileMap.HasTile(localPlace))
{
var tile = metaTileMap.GetTile(localPlace);
if (tile.name.Contains("rock_wall"))
{
miningTiles.Add(localPlace);
}
}
}
}
int numberOfTiles = (int)((miningTiles.Count / 100f) * config.Density);
for (int i = 0; i < numberOfTiles; i++)
{
var oreTile = miningTiles[RANDOM.Next(miningTiles.Count)];
var oreCategory = weightedList[RANDOM.Next(weightedList.Count)];
tileChangeManager.UpdateTile(oreTile, oreCategory.WallTile);
var intLocation = oreTile + Vector3Int.zero;
intLocation.z = -1;
tileChangeManager.AddOverlay(intLocation, oreCategory.OverlayTile as OverlayTile);
NodeScatter(oreTile, oreCategory);
}
}
}
public bool IsClearUnderfloorConstruction(Vector3Int position, bool isServer)
{
if (MetaTileMap.HasTile(position, LayerType.Floors, isServer))
{
return(false);
}
else if (MetaTileMap.HasTile(position, LayerType.Walls, isServer))
{
return(false);
}
else if (MetaTileMap.HasTile(position, LayerType.Windows, isServer))
{
return(false);
}
else if (MetaTileMap.HasTile(position, LayerType.Grills, isServer))
{
return(false);
}
return(true);
}
public LayerTile RemoveTile(Vector3Int cellPosition, LayerType layerType, bool removeAll = true)
{
var layerTile = metaTileMap.GetTile(cellPosition, layerType);
if (metaTileMap.HasTile(cellPosition, layerType))
{
InternalRemoveTile(cellPosition, layerType, removeAll);
RemoveTileMessage.Send(networkIdentity.netId, cellPosition, layerType, false);
AddToChangeList(cellPosition, layerType);
if (layerType == LayerType.Floors || layerType == LayerType.Base)
{
OnFloorOrPlatingRemoved.Invoke(cellPosition);
}
RemoveOverlaysOfType(cellPosition, LayerType.Effects, OverlayType.Damage);
return(layerTile);
}
return(layerTile);
}
public LayerTile RemoveTile(Vector3Int cellPosition, LayerType layerType)
{
var layerTile = metaTileMap.GetTile(cellPosition, layerType);
if (metaTileMap.HasTile(cellPosition, layerType))
{
InternalRemoveTile(cellPosition, layerType);
SpawnSafeThread.RemoveTileMessageSend(networkMatrix.MatrixSync.netId, cellPosition, layerType);
AddToChangeList(cellPosition, layerType);
if (layerType == LayerType.Floors || layerType == LayerType.Base)
{
OnFloorOrPlatingRemoved.Invoke(cellPosition);
}
RemoveOverlaysOfType(cellPosition, LayerType.Effects, OverlayType.Damage);
return(layerTile);
}
return(layerTile);
}
private static void DrawGizmo(MetaTileMap scr, GizmoType gizmoType)
{
if (!DrawGizmos)
{
return;
}
Vector3Int start = Vector3Int.RoundToInt(Camera.current.ScreenToWorldPoint(Vector3.one * -32) - scr.transform.position); // bottom left
Vector3Int end =
Vector3Int.RoundToInt(Camera.current.ScreenToWorldPoint(new Vector3(Camera.current.pixelWidth + 32, Camera.current.pixelHeight + 32)) -
scr.transform.position);
start.z = 0;
end.z = 1;
if (end.y - start.y > 100)
{
// avoid being zoomed out too much (creates too many objects)
return;
}
Gizmos.matrix = scr.transform.localToWorldMatrix;
Color blue = Color.blue;
blue.a = 0.5f;
Color red = Color.red;
red.a = 0.5f;
Color green = Color.green;
red.a = 0.5f;
if (room)
{
DrawRoom(scr);
}
else
{
foreach (Vector3Int position in new BoundsInt(start, end - start).allPositionsWithin)
{
if (space)
{
if (scr.IsSpaceAt(position))
{
Gizmos.color = red;
Gizmos.DrawCube(position + new Vector3(0.5f, 0.5f, 0), Vector3.one);
}
}
else
{
if (corners)
{
if (scr.HasTile(position, LayerType.Walls))
{
Gizmos.color = green;
int corner_count = 0;
foreach (Vector3Int pos in new[] { Vector3Int.up, Vector3Int.left, Vector3Int.down, Vector3Int.right, Vector3Int.up })
{
if (!scr.HasTile(position + pos, LayerType.Walls))
{
corner_count++;
}
else
{
corner_count = 0;
}
if (corner_count > 1)
{
Gizmos.DrawCube(position + new Vector3(0.5f, 0.5f, 0), Vector3.one);
break;
}
}
}
}
else
{
Gizmos.color = blue;
if (passable)
{
if (north)
{
if (!scr.IsPassableAt(position + Vector3Int.up, position))
{
Gizmos.DrawCube(position + new Vector3(0.5f, 0.5f, 0), Vector3.one);
}
}
else if (south)
{
if (!scr.IsPassableAt(position + Vector3Int.down, position))
{
Gizmos.DrawCube(position + new Vector3(0.5f, 0.5f, 0), Vector3.one);
}
}
else if (!scr.IsPassableAt(position))
{
Gizmos.DrawCube(position + new Vector3(0.5f, 0.5f, 0), Vector3.one);
}
}
else
{
if (!scr.IsAtmosPassableAt(position))
{
Gizmos.DrawCube(position + new Vector3(0.5f, 0.5f, 0), Vector3.one);
}
}
}
}
}
}
}
public bool HasTile(Vector3Int position, bool isServer)
{
return(MetaTileMap.HasTile(position, isServer));
}
public bool IsWallAt(Vector3Int position, bool isServer)
{
return(MetaTileMap.HasTile(position, LayerType.Walls, isServer));
}
public bool IsWindowAt(Vector3Int position, bool isServer)
{
return(MetaTileMap.HasTile(position, LayerType.Windows));
}
private void DoBulletDamage(BulletBehaviour bullet, Vector3 forceDir, Vector3 hitPos)
{
forceDir.z = 0;
Vector3 bulletHitTarget = hitPos + (forceDir * 0.2f);
Vector3Int cellPos = metaTileMap.WorldToCell(Vector3Int.RoundToInt(bulletHitTarget));
MetaDataNode data = metaDataLayer.Get(cellPos);
if (Layer.LayerType == LayerType.Windows)
{
LayerTile getTile = metaTileMap.GetTile(cellPos, LayerType.Windows);
if (getTile != null)
{
//TODO damage amt based off type of bullet
AddWindowDamage(bullet.damage, data, cellPos, bulletHitTarget, AttackType.Bullet);
return;
}
}
if (Layer.LayerType == LayerType.Grills)
{
//Make sure a window is not protecting it first:
if (!metaTileMap.HasTile(cellPos, LayerType.Windows, true))
{
if (metaTileMap.HasTile(cellPos, LayerType.Grills, true))
{
//TODO damage amt based off type of bullet
AddGrillDamage(bullet.damage, data, cellPos, bulletHitTarget, AttackType.Bullet);
}
}
}
if (bullet.isMiningBullet)
{
if (Layer.LayerType == LayerType.Walls)
{
LayerTile getTile = metaTileMap.GetTile(cellPos, LayerType.Walls);
if (getTile != null)
{
if (Validations.IsMineableAt(bulletHitTarget, metaTileMap))
{
SoundManager.PlayNetworkedAtPos("BreakStone", bulletHitTarget);
var tile = getTile as BasicTile;
Spawn.ServerPrefab(tile.SpawnOnDeconstruct, bulletHitTarget, count: tile.SpawnAmountOnDeconstruct);
tileChangeManager.RemoveTile(cellPos, LayerType.Walls);
}
}
}
}
}
public bool HasTile(Vector3Int position)
{
return(metaTileMap.HasTile(position));
}
