private void _updateTileMapOnUpdate(object sender, TileChangedEventArgs args)
{
var grid = _mapManager.GetGrid(args.NewTile.GridIndex);
var chunk = grid.GridTileToChunkIndices(new MapIndices(args.NewTile.X, args.NewTile.Y));
_setChunkDirty(grid, chunk);
}
private void MapManagerOnTileChanged(object?sender, TileChangedEventArgs e)
{
if (e.OldTile.IsEmpty)
{
return; // Nothing is anchored here anyways.
}
if (e.NewTile.Tile.IsEmpty)
{
return; // Anything that was here will be unanchored anyways.
}
UpdateTile(MapManager.GetGrid(e.NewTile.GridIndex), e.NewTile.GridIndices);
}
public void OnPointerDown(PointerEventData data)
{
SetPlayState(!_playState);
if (OnTileChanged != null)
{
TileChangedEventArgs args = new TileChangedEventArgs();
args.channel = channel;
args.slot = slot;
args.state = _playState;
OnTileChanged(this, args);
}
}
private void OnTileChanged(object?sender, TileChangedEventArgs eventArgs)
{
// When a tile changes, we want to update it only if it's gone from
// space -> not space or vice versa. So if the old tile is the
// same as the new tile in terms of space-ness, ignore the change
if (eventArgs.NewTile.IsSpace() == eventArgs.OldTile.IsSpace())
{
return;
}
GetGridAtmosphere(eventArgs.NewTile.GridIndex)?.Invalidate(eventArgs.NewTile.GridIndices);
}
private void HandleTileChanged(object sender, TileChangedEventArgs eventArgs)
{
// If this gets hammered you could probably queue up all the tile changes every tick but I doubt that would ever happen.
foreach (var(puddle, snapGrid) in ComponentManager.EntityQuery <PuddleComponent, SnapGridComponent>(true))
{
// If the tile becomes space then delete it (potentially change by design)
if (eventArgs.NewTile.GridIndex == puddle.Owner.Transform.GridID &&
snapGrid.Position == eventArgs.NewTile.GridIndices &&
eventArgs.NewTile.Tile.IsEmpty)
{
puddle.Owner.Delete();
break; // Currently it's one puddle per tile, if that changes remove this
}
}
}
private void FieldOnTileChanged(object sender, TileChangedEventArgs e)
{
if (e.IsMove() || e.IsAdd())
{
_tileDrawer.DrawTile(e.NewTile);
}
else if (e.IsDelete())
{
_tileDrawer.RemoveTile(e.OldTile.Tile);
}
else
{
_tileDrawer.RemoveTile(e.OldTile.Tile);
_tileDrawer.DrawTile(e.NewTile);
}
}
private void HandleTileChanged(object sender, TileChangedEventArgs eventArgs)
{
// If this gets hammered you could probably queue up all the tile changes every tick but I doubt that would ever happen.
var entities = EntityManager.GetEntities(EntityQuery);
foreach (var entity in entities)
{
// If the tile becomes space then delete it (potentially change by design)
if (eventArgs.NewTile.GridIndex == entity.Transform.GridID &&
entity.TryGetComponent(out SnapGridComponent snapGridComponent) &&
snapGridComponent.Position == eventArgs.NewTile.GridIndices &&
eventArgs.NewTile.Tile.IsEmpty)
{
entity.Delete();
break; // Currently it's one puddle per tile, if that changes remove this
}
}
}
/// <summary>
/// Handles tile changes. Sets their new colors.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Model_TileChanged(object sender, TileChangedEventArgs e)
{
switch (e.Type)
{
case TileType.Empty:
Fields[e.X * model.MapSize + e.Y].Color = Color.FromRgb(0, 0, 0);
break;
case TileType.Snake:
Fields[e.X * model.MapSize + e.Y].Color = Color.FromRgb(255, 0, 0);
break;
case TileType.Food:
Fields[e.X * model.MapSize + e.Y].Color = Color.FromRgb(0, 255, 0);
break;
case TileType.Wall:
Fields[e.X * model.MapSize + e.Y].Color = Color.FromRgb(0, 0, 255);
break;
}
}
//TODO: Replace all this with an Unanchored event that deletes the puddle
private void HandleTileChanged(object?sender, TileChangedEventArgs eventArgs)
{
// If this gets hammered you could probably queue up all the tile changes every tick but I doubt that would ever happen.
foreach (var puddle in ComponentManager.EntityQuery <PuddleComponent>(true))
{
// If the tile becomes space then delete it (potentially change by design)
var puddleTransform = puddle.Owner.Transform;
if (!puddleTransform.Anchored)
{
continue;
}
var grid = _mapManager.GetGrid(puddleTransform.GridID);
if (eventArgs.NewTile.GridIndex == puddle.Owner.Transform.GridID &&
grid.TileIndicesFor(puddleTransform.Coordinates) == eventArgs.NewTile.GridIndices &&
eventArgs.NewTile.Tile.IsEmpty)
{
puddle.Owner.QueueDelete();
break; // Currently it's one puddle per tile, if that changes remove this
}
}
}
private void QueueTileChange(object sender, TileChangedEventArgs eventArgs)
{
_tileUpdateQueue.Enqueue(eventArgs.NewTile);
}
private void MapManagerOnTileChanged(object sender, TileChangedEventArgs e)
{
UpdateTile(_mapManager.GetGrid(e.NewTile.GridIndex), e.NewTile.GridIndices);
}
private void HandleTileChanged(object?sender, TileChangedEventArgs eventArgs)
{
GetOrCreateNode(eventArgs.NewTile.GridIndex, eventArgs.NewTile.GridIndices);
}
private static bool OnTileChange(dynamic inst, int start, int length)
{
byte player = (byte)(int)inst.whoAmI;
int index = start + 1;
byte action = inst.readBuffer[index];
index++;
int x = BitConverter.ToInt32(inst.readBuffer, index);
index += 4;
int y = BitConverter.ToInt32(inst.readBuffer, index);
index += 4;
byte type = inst.readBuffer[index];
bool retval;
if (Session.Sessions[player].IsCheckingBlock)
{
Session.Sessions[player].IsCheckingBlock = false;
Database.Check(x, y, Session.Sessions[player]);
retval = false;
}
else
{
retval = CanPerformAction(player, x, y, action, action == 1 || action == 3 ? type : (action == 2 ? MainMod.Tile[x, y].wall : MainMod.Tile[x, y].type));
}
if (!retval)
{
NetMessageMod.SendTileSquare(player, x, y, 3);
return false;
}
if (TileChanged != null)
{
TileChangedEventArgs e = new TileChangedEventArgs(player, action, x, y, type);
TileChanged.Invoke(null, e);
if (e.Canceled)
{
return false;
}
}
Session.Sessions[player].MakeEdit(new Edit
{
X = x,
Y = y,
Type = action == 1 || action == 3 ? type : (MainMod.Tile[x, y] == null ? 0 : (action == 2 ? MainMod.Tile[x, y].wall : MainMod.Tile[x, y].type)),
Action = action,
});
return true;
}
private void ChangeTile(Object sender, TileChangedEventArgs args)
{
TileFactory tf = TileFactory.Instance;
this.Image = tf.getBitmapImproved(args.Tile);
}
private void HandleTileChanged(object sender, TileChangedEventArgs args)
{
var coords = args.NewTile.LocalPos;
_pendingTileChanges.RemoveAll(c => c.Item1 == coords);
}
private void UpdateTileMapOnUpdate(object sender, TileChangedEventArgs args)
{
var tilemap = RenderTileMaps[args.NewTile.GridIndex];
tilemap.SetCell(args.NewTile.X, args.NewTile.Y, args.NewTile.Tile.TileId);
}
private void QueueTileChange(object sender, TileChangedEventArgs eventArgs)
{
_queuedGraphUpdates.Enqueue(new TileUpdate(eventArgs.NewTile));
}
/// <summary>
/// Event handler for tile changes.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Model_TileChanged(object sender, TileChangedEventArgs e)
{
SetColor(e.X, e.Y, e.Type);
}
