private static Box2 GetTileBox(this TileRef turf)
{
var map = IoCManager.Resolve <IMapManager>();
var tileGrid = map.GetGrid(turf.GridIndex);
return(Box2.UnitCentered.Scale(tileGrid.TileSize));
}
public PathfindingNode GetNode(TileRef tile)
{
var chunkX = tile.X - _indices.X;
var chunkY = tile.Y - _indices.Y;
return(_nodes[chunkX, chunkY]);
}
/// <summary>
/// Return the corresponding PathfindingNode for this tile
/// </summary>
/// <param name="tile"></param>
/// <returns></returns>
public PathfindingNode GetNode(TileRef tile)
{
var chunk = GetChunk(tile);
var node = chunk.GetNode(tile);
return(node);
}
public void AddTileRef(GameObject go, int x, int y)
{
TileRef tr = go.AddComponent <TileRef>();
tr.x = x;
tr.y = y;
}
/// <summary>
/// Gets the safe nieghbour.
/// </summary>
public TileRef GetSafeNieghbour(TileRef tr)
{
List <TileRef> stepToList = new List <TileRef>();
if ((tr.x - 1 >= 0) && (m_tiles[tr.x - 1, tr.y].m_isBlown == false))
{
stepToList.Add(m_tiles[tr.x - 1, tr.y].m_tile.GetComponent <TileRef>());
}
if ((tr.x + 1 < m_rowWidth) && (m_tiles[tr.x + 1, tr.y].m_isBlown == false))
{
stepToList.Add(m_tiles[tr.x + 1, tr.y].m_tile.GetComponent <TileRef>());
}
if ((tr.y - 1 >= 0) && (m_tiles[tr.x, tr.y - 1].m_isBlown == false))
{
stepToList.Add(m_tiles[tr.x, tr.y - 1].m_tile.GetComponent <TileRef>());
}
if ((tr.y + 1 < m_rowHeight) && (m_tiles[tr.x, tr.y + 1].m_isBlown == false))
{
stepToList.Add(m_tiles[tr.x, tr.y + 1].m_tile.GetComponent <TileRef>());
}
if (stepToList.Count <= 0)
{
return(null);
}
return(stepToList[Random.Range(0, stepToList.Count)]);
}
FixedPoint2 ITileReaction.TileReact(TileRef tile, ReagentPrototype reagent, FixedPoint2 reactVolume)
{
var entities = IoCManager.Resolve <IEntityLookup>().GetEntitiesIntersecting(tile).ToArray();
var amount = FixedPoint2.Zero;
var entMan = IoCManager.Resolve <IEntityManager>();
foreach (var entity in entities)
{
if (entMan.TryGetComponent(entity, out CleanableComponent? cleanable))
{
var next = amount + (cleanable.CleanAmount * CleanAmountMultiplier);
// Nothing left?
if (reactVolume < next)
{
break;
}
amount = next;
entMan.QueueDeleteEntity(entity);
}
}
var decalSystem = EntitySystem.Get <DecalSystem>();
foreach (var uid in decalSystem.GetDecalsInRange(tile.GridIndex, tile.GridIndices + new Vector2(0.5f, 0.5f), validDelegate: x => x.Cleanable))
{
decalSystem.RemoveDecal(tile.GridIndex, uid);
}
return(amount);
}
public static bool PryTile(this TileRef tileRef,
IMapManager?mapManager = null, ITileDefinitionManager?tileDefinitionManager = null, IEntityManager?entityManager = null)
{
var tile = tileRef.Tile;
var indices = tileRef.GridIndices;
// If the arguments are null, resolve the needed dependencies.
mapManager ??= IoCManager.Resolve <IMapManager>();
tileDefinitionManager ??= IoCManager.Resolve <ITileDefinitionManager>();
entityManager ??= IoCManager.Resolve <IEntityManager>();
if (tile.IsEmpty)
{
return(false);
}
var tileDef = (ContentTileDefinition)tileDefinitionManager[tile.TypeId];
if (!tileDef.CanCrowbar)
{
return(false);
}
var mapGrid = mapManager.GetGrid(tileRef.GridIndex);
var plating = tileDefinitionManager[tileDef.BaseTurfs[^ 1]];
public ReagentUnit ReactionTile(TileRef tile, ReagentUnit reactVolume)
{
var removed = ReagentUnit.Zero;
if (tile.Tile.IsEmpty)
{
return(removed);
}
foreach (var reaction in _tileReactions)
{
removed += reaction.TileReact(tile, this, reactVolume - removed);
if (removed > reactVolume)
{
throw new Exception("Removed more than we have!");
}
if (removed == reactVolume)
{
break;
}
}
return(removed);
}
public FixedPoint2 TileReact(TileRef tile, ReagentPrototype reagent, FixedPoint2 reactVolume)
{
if (reactVolume <= FixedPoint2.Zero || tile.Tile.IsEmpty)
{
return(FixedPoint2.Zero);
}
var atmosphereSystem = EntitySystem.Get <AtmosphereSystem>();
var environment = atmosphereSystem.GetTileMixture(tile.GridIndex, tile.GridIndices, true);
if (environment == null || !atmosphereSystem.IsHotspotActive(tile.GridIndex, tile.GridIndices))
{
return(FixedPoint2.Zero);
}
environment.Temperature =
MathF.Max(MathF.Min(environment.Temperature - (_coolingTemperature * 1000f),
environment.Temperature / _coolingTemperature), Atmospherics.TCMB);
atmosphereSystem.React(tile.GridIndex, tile.GridIndices);
atmosphereSystem.HotspotExtinguish(tile.GridIndex, tile.GridIndices);
return(FixedPoint2.Zero);
}
private static Box2 GetWorldTileBox(TileRef turf)
{
var map = IoCManager.Resolve <IMapManager>();
var tileGrid = map.GetGrid(turf.GridIndex);
var tileBox = Box2.UnitCentered.Scale(tileGrid.TileSize);
return(tileBox.Translated(tileGrid.GridTileToWorldPos(turf.GridIndices)));
}
public override void onPlayerOpenChest(PlayerChestOpenEvent Event)
{
TileRef tileRef = Server.tile.At((int)Server.chest[Event.ID].x, (int)Server.chest[Event.ID].y);
Program.tConsole.WriteLine("Chest Type: " + tileRef.Data.Type.ToString());
Event.Cancelled = CancelEvent(Event.Sender.Name);
base.onPlayerOpenChest(Event);
}
public Tile this[int x, int y]
{
get
{
Point chunkPos = new Point(
(int)Math.Floor((float)x / ChunkSize),
(int)Math.Floor((float)y / ChunkSize)
);
Chunk chunk;
if (mm.chunks.TryGetValue(chunkPos, out chunk))
{
return(chunk.Tiles[(y - chunkPos.Y * ChunkSize) * ChunkSize + (x - chunkPos.X * ChunkSize)]);
}
else
{
return(default(Tile)); // SPAAAAAAAAAAAAAACE!!!
}
}
set
{
Point chunkPos = new Point(
(int)Math.Floor((float)x / ChunkSize),
(int)Math.Floor((float)y / ChunkSize)
);
Chunk chunk;
if (!mm.chunks.TryGetValue(chunkPos, out chunk))
{
if (value.IsSpace)
{
return;
}
else
{
mm.chunks[chunkPos] = chunk = new Chunk();
}
}
int index = (y - chunkPos.Y * ChunkSize) * ChunkSize + (x - chunkPos.X * ChunkSize);
Tile oldTile = chunk.Tiles[index];
if (oldTile == value)
{
return;
}
chunk.Tiles[index] = value;
var tileRef = new TileRef(mm, x, y, chunk, index);
if (mm.TileChanged != null)
{
mm.TileChanged(tileRef, oldTile);
}
if (!mm.suppressNetworkUpdatesOnTileChanged)
{
mm.NetworkUpdateTile(tileRef);
}
}
}
public void AttachToTile(TileRef tilePos)
{
var transComp = Owner.GetComponent <TransformComponent>(ComponentFamily.Transform);
if (transComp != null)
{
transComp.Position = new Vector2f(tilePos.X + 0.5f, tilePos.Y + 0.5f);
}
}
public ReagentUnit TileReact(TileRef tile, ReagentPrototype reagent, ReagentUnit reactVolume)
{
if (reactVolume < 5 || !tile.TryGetPuddle(null, out _))
{
return(ReagentUnit.Zero);
}
return(tile.SpillAt(new Solution(reagent.ID, reactVolume), "PuddleSmear", true, false) != null ? reactVolume : ReagentUnit.Zero);
}
static void ErrorLogger(TileRef tile, Exception ex)
{
if (_output != null)
{
lock (_errorLoggerLock)
{
_output.WriteLine(tile.Serialize());
}
}
}
private void CreateNode(TileRef tile, PathfindingChunk?parent = null)
{
parent ??= this;
var node = new PathfindingNode(parent, tile);
var offsetX = tile.X - Indices.X;
var offsetY = tile.Y - Indices.Y;
_nodes[offsetX, offsetY] = node;
}
public static void writeTile(this IValueWriter writer, TileRef tile)
{
writer.WriteInt32((int)tile.ter);
writer.WriteInt32(tile.resources.Count);
foreach (var(resource, amount) in tile.resources)
{
writer.WriteInt32(resource);
writer.WriteInt64(amount);
}
}
/*
* private void HandleTurfClick(NetIncomingMessage message)
* {
* // Who clicked and on what tile.
* Atom.Atom clicker = SS13Server.Singleton.playerManager.GetSessionByConnection(message.SenderConnection).attachedAtom;
* short x = message.ReadInt16();
* short y = message.ReadInt16();
*
* if (Vector2.Distance(clicker.position, new Vector2(x * tileSpacing + (tileSpacing / 2), y * tileSpacing + (tileSpacing / 2))) > 96)
* {
* return; // They were too far away to click us!
* }
* bool Update = false;
* if (IsSaneArrayPosition(x, y))
* {
* Update = tileArray[x, y].ClickedBy(clicker);
* if (Update)
* {
* if (tileArray[x, y].tileState == TileState.Dead)
* {
* Tiles.Atmos.GasCell g = tileArray[x, y].gasCell;
* Tiles.Tile t = GenerateNewTile(x, y, tileArray[x, y].tileType);
* tileArray[x, y] = t;
* tileArray[x, y].gasCell = g;
* }
* NetworkUpdateTile(x, y);
* }
* }
* }*/// TODO HOOK ME BACK UP WITH ENTITY SYSTEM
public void NetworkUpdateTile(TileRef tile)
{
NetOutgoingMessage message = IoCManager.Resolve <ISS14NetServer>().CreateMessage();
message.Write((byte)NetMessage.MapMessage);
message.Write((byte)MapMessage.TurfUpdate);
message.Write((int)tile.X);
message.Write((int)tile.Y);
message.Write((uint)tile.Tile);
IoCManager.Resolve <ISS14NetServer>().SendToAll(message);
}
public bool InBounds(TileRef tile)
{
if (tile.X < _indices.X || tile.Y < _indices.Y)
{
return(false);
}
if (tile.X >= _indices.X + ChunkSize || tile.Y >= _indices.Y + ChunkSize)
{
return(false);
}
return(true);
}
public FixedPoint2 TileReact(TileRef tile, ReagentPrototype reagent, FixedPoint2 reactVolume)
{
var spillSystem = EntitySystem.Get <SpillableSystem>();
if (reactVolume < 5 || !spillSystem.TryGetPuddle(tile, out _))
{
return(FixedPoint2.Zero);
}
return(spillSystem.SpillAt(tile, new Solution(reagent.ID, reactVolume), "PuddleSmear", true, false, true) != null
? reactVolume
: FixedPoint2.Zero);
}
private void ReleaseToFloor(EntityCoordinates clickLocation, AbsorbentComponent absorbent, Solution?absorbedSolution)
{
if ((_mapManager.TryGetGrid(clickLocation.GetGridUid(EntityManager), out var mapGrid)) && // needs valid grid
absorbedSolution is not null) // needs a solution to place on the tile
{
TileRef tile = mapGrid.GetTileRef(clickLocation);
// Drop some of the absorbed liquid onto the ground
var releaseAmount = FixedPoint2.Min(absorbent.ResidueAmount, absorbedSolution.CurrentVolume); // The release amount specified on the absorbent component, or the amount currently absorbed (whichever is less).
var releasedSolution = _solutionSystem.SplitSolution(absorbent.Owner, absorbedSolution, releaseAmount); // Remove releaseAmount of solution from the absorbent component
_spillableSystem.SpillAt(tile, releasedSolution, puddlePrototypeId); // And spill it onto the tile.
}
}
public bool TryGetPuddle(TileRef tileRef, [NotNullWhen(true)] out PuddleComponent?puddle)
{
foreach (var entity in _entityLookup.GetEntitiesIntersecting(tileRef))
{
if (EntityManager.TryGetComponent(entity, out PuddleComponent? p))
{
puddle = p;
return(true);
}
}
puddle = null;
return(false);
}
public PathfindingNode(PathfindingChunk parent, TileRef tileRef, List <int> collisionLayers = null)
{
_parentChunk = parent;
TileRef = tileRef;
if (collisionLayers == null)
{
CollisionLayers = new List <int>();
}
else
{
CollisionLayers = collisionLayers;
}
GenerateMask();
}
public bool TryGetPuddle(TileRef tileRef, [NotNullWhen(true)] out PuddleComponent?puddle)
{
foreach (var entity in tileRef.GetEntitiesInTileFast(_gridTileLookupSystem))
{
if (EntityManager.TryGetComponent(entity, out PuddleComponent? p))
{
puddle = p;
return(true);
}
}
puddle = null;
return(false);
}
private void Awake()
{
health = GetComponent <Health>();
mc = GetComponent <MovementController>();
ic = GetComponent <InputController>();
itemController = GetComponent <ItemController>();
if (colliderGo == null)
{
colliderGo = GetComponentInChildren <Collider2D>().gameObject;
}
tileRef = GetComponent <TileRef>();
Initialize(this);
}
public static bool TryGetPuddle(this TileRef tileRef, GridTileLookupSystem?gridTileLookupSystem, [NotNullWhen(true)] out PuddleComponent?puddle)
{
foreach (var entity in tileRef.GetEntitiesInTileFast(gridTileLookupSystem))
{
if (entity.TryGetComponent(out PuddleComponent? p))
{
puddle = p;
return(true);
}
}
puddle = null;
return(false);
}
public static float OctileDistance(TileRef endTile, TileRef startTile)
{
// "Fast Euclidean" / octile.
// This implementation is written down in a few sources; it just saves doing sqrt.
int dstX = Math.Abs(startTile.X - endTile.X);
int dstY = Math.Abs(startTile.Y - endTile.Y);
if (dstX > dstY)
{
return(1.4f * dstY + (dstX - dstY));
}
return(1.4f * dstX + (dstY - dstX));
}
/*
* private void HandleTurfClick(NetIncomingMessage message)
* {
* // Who clicked and on what tile.
* Atom.Atom clicker = SS13Server.Singleton.playerManager.GetSessionByConnection(message.SenderConnection).attachedAtom;
* short x = message.ReadInt16();
* short y = message.ReadInt16();
*
* if (Vector2.Distance(clicker.position, new Vector2(x * tileSpacing + (tileSpacing / 2), y * tileSpacing + (tileSpacing / 2))) > 96)
* {
* return; // They were too far away to click us!
* }
* bool Update = false;
* if (IsSaneArrayPosition(x, y))
* {
* Update = tileArray[x, y].ClickedBy(clicker);
* if (Update)
* {
* if (tileArray[x, y].tileState == TileState.Dead)
* {
* Tiles.Atmos.GasCell g = tileArray[x, y].gasCell;
* Tiles.Tile t = GenerateNewTile(x, y, tileArray[x, y].tileType);
* tileArray[x, y] = t;
* tileArray[x, y].gasCell = g;
* }
* NetworkUpdateTile(x, y);
* }
* }
* }*/// TODO HOOK ME BACK UP WITH ENTITY SYSTEM
private static void NetworkUpdateTile(TileRef tile)
{
var net = IoCManager.Resolve <IServerNetManager>();
var message = net.CreateNetMessage <MsgMap>();
message.MessageType = MapMessage.TurfUpdate;
message.SingleTurf = new MsgMap.Turf
{
X = tile.X,
Y = tile.Y,
Tile = (uint)tile.Tile
};
net.ServerSendToAll(message);
}
public void Test_TileRef_Serialization()
{
var tr = new TileRef("abc", 1, 2, 3);
var str = tr.Serialize();
Assert.Equal("1/2/3/abc", str);
var tr2 = TileRef.Parse(str);
Assert.NotNull(tr2);
Assert.Equal(1, tr2.Value.Row);
Assert.Equal(2, tr2.Value.Col);
Assert.Equal(3, tr2.Value.Scale);
Assert.Equal("abc", tr2.Value.GroupName);
}
public static TileRef readTile(this IValueReader reader)
{
var tile = new TileRef();
tile.ter = (Map.Terrain)reader.ReadInt32();
var resourceCount = reader.ReadInt32();
tile.resources = new List <(int, long)>(resourceCount);
for (var i = 0; i < resourceCount; i++)
{
tile.resources.Add((reader.ReadInt32(), reader.ReadInt64()));
}
return(tile);
}
public static Boolean IsValidTreeRootTile(TileRef tile)
{
return (tile.Active && (tile.Type == 2 || tile.Type == 23 || tile.Type == 60));
}
