public TileDefinition.DrawMode GetTileDrawMode(TilePosition pos)
{
return(GetTileDefinition(tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].tileType).drawMode);
}
public bool GetTileCastShadow(TilePosition pos)
{
return(tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].CastShadow);
}
public byte GetTileType(TilePosition pos)
{
return(tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].tileType);
}
public bool GetTileBurns(TilePosition pos)
{
return(GetTileDefinition(tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].tileType).burns);
}
public void TileClicked(TilePosition pos)
{
ExecuteTileActions(pos, TileActionRule.ActionType.CLICKED);
}
private void ReportTileInvalidated(TilePosition pos)
{
ReportTileInvalidated(pos, false);
}
public byte GetTileEnergy(TilePosition pos)
{
return(tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].Energy);
}
public bool IsValidTile(TilePosition pos)
{
return(pos.x >= 0 && pos.x < sizeX && pos.y >= 0 && pos.y < sizeY && pos.z >= 0 && pos.z < sizeZ);
}
public bool HasTileActions(TilePosition pos, TileActionRule.ActionType actionType)
{
TileDefinition tileDefinition = GetTileDefinition(GetTileType(pos));
return(tileDefinition.tileActionRules != null && tileDefinition.tileActionRules.GetRulesForAction(actionType) != null);
}
public bool GetTileOnFire(TilePosition pos)
{
return(tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].OnFire);
}
public void SetTileOnFire(TilePosition pos, bool onFire)
{
if (GetTileType(pos) != TileDefinition.EMPTY_TILE_TYPE)
{
if (tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].OnFire != onFire)
{
tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].OnFire = onFire;
if (onFire)
{
ExecuteTileActions(pos, TileActionRule.ActionType.ONFIRE);
if (tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].LightSource == false)
{
tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].LightSource = true;
if (tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].CastShadow)
{
tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].CastShadow = false;
if (updateLighting)
{
LightModelAmbient.UpdateLuminanceDark(this, pos);
}
}
if (updateLighting)
{
LightModelLightSource.UpdateLuminanceLight(this, pos, (byte)(Tile.MAX_LUMINANCE - 1));
}
else
{
SetTileLightSourceLuminance(pos, (byte)(Tile.MAX_LUMINANCE - 1));
}
}
}
else
{
TileDefinition def = GetTileDefinition(GetTileType(pos));
if (tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].LightSource != (def.lightSourceIntensity > 0))
{
if (updateLighting)
{
LightModelLightSource.UpdateLuminanceDark(this, pos);
}
tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].LightSource = false;
if (def.castShadow != tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].CastShadow != def.castShadow)
{
tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].CastShadow = false;
if (updateLighting)
{
LightModelAmbient.UpdateLuminanceLight(this, pos, GetTileAmbientLuminance(pos));
}
}
}
}
if (enqueueTileUpdates)
{
EnqueueInvalidatedTileAndNearTiles(pos);
}
if (reportTileInvalidated)
{
ReportTileInvalidated(pos);
}
}
}
}
public void MoveTile(TilePosition oldTilePos, TilePosition newTilePos)
{
Tile oldTile = tiles[oldTilePos.x | (oldTilePos.y << sizeXbits) | (oldTilePos.z << sizeXBitsYBits)];
Tile oldTileUpdated = oldTile;
if (oldTile.LightSource)
{
if (updateLighting)
{
LightModelLightSource.UpdateLuminanceDark(this, oldTilePos);
oldTileUpdated.LightSourceLuminance = GetTileLightSourceLuminance(oldTilePos);
}
else
{
oldTile.LightSourceLuminance = 0;
}
}
oldTileUpdated.tileType = TileDefinition.EMPTY_TILE_TYPE;
oldTileUpdated.Energy = 0;
oldTileUpdated.Destroyed = false;
oldTileUpdated.OnFire = false;
oldTileUpdated.CastShadow = false;
oldTileUpdated.LightSource = false;
oldTileUpdated.Dynamic = false;
oldTileUpdated.ExtraData = 0;
tiles[oldTilePos.x | (oldTilePos.y << sizeXbits) | (oldTilePos.z << sizeXBitsYBits)] = oldTileUpdated;
if (updateLighting)
{
if (oldTileUpdated.CastShadow != oldTile.CastShadow)
{
LightModelAmbient.UpdateLuminanceLight(this, oldTilePos, oldTileUpdated.AmbientLuminance);
LightModelLightSource.UpdateLuminanceLight(this, oldTilePos, oldTileUpdated.LightSourceLuminance);
}
}
UpdateTopPosition(oldTilePos, TileDefinition.EMPTY_TILE_TYPE);
Tile newTileOriginal = GetTile(newTilePos);
Tile newTile = oldTile;
if (newTile.LightSource == false)
{
newTile.LightSourceLuminance = newTileOriginal.LightSourceLuminance;
}
newTile.AmbientLuminance = newTileOriginal.AmbientLuminance;
tiles[newTilePos.x | (newTilePos.y << sizeXbits) | (newTilePos.z << sizeXBitsYBits)] = newTile;
if (newTile.Dynamic)
{
DynamicTile dynamicTile = dynamicTiles[oldTilePos];
dynamicTiles.Remove(oldTilePos);
dynamicTiles[newTilePos] = dynamicTile;
dynamicTile.tilePosition = newTilePos;
if (dynamicTilesTimeout.ContainsKey(oldTilePos))
{
dynamicTilesTimeout.Remove(oldTilePos);
dynamicTilesTimeout[newTilePos] = dynamicTile;
}
}
if (updateLighting)
{
if (newTile.CastShadow)
{
LightModelAmbient.UpdateLuminanceDark(this, newTilePos);
LightModelLightSource.UpdateLuminanceDark(this, newTilePos);
}
if (newTile.LightSource)
{
LightModelLightSource.UpdateLuminanceLight(this, newTilePos, newTile.LightSourceLuminance);
}
}
else
{
if (newTile.LightSource)
{
SetTileLightSourceLuminance(newTilePos, newTile.LightSourceLuminance);
}
}
UpdateTopPosition(newTilePos, newTile.tileType);
if (enqueueTileUpdates)
{
EnqueueInvalidatedTileAndNearTiles(oldTilePos);
EnqueueInvalidatedTileAndNearTiles(newTilePos);
}
if (reportTileInvalidated)
{
ReportTileInvalidated(oldTilePos);
ReportTileInvalidated(newTilePos);
}
}
public void SetTileType(TilePosition pos, byte type)
{
Tile oldTile = tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)];
if (oldTile.Dynamic)
{
SetTileDynamic(pos, false, false, 0);
oldTile.Dynamic = false;
}
if (oldTile.LightSource)
{
if (updateLighting)
{
LightModelLightSource.UpdateLuminanceDark(this, pos);
oldTile.LightSourceLuminance = GetTileLightSourceLuminance(pos);
}
else
{
oldTile.LightSourceLuminance = 0;
}
}
Tile newTile = oldTile;
TileDefinition tileDefinition = GetTileDefinition(type);
newTile.tileType = type;
newTile.Energy = (byte)tileDefinition.energy;
newTile.Destroyed = false;
newTile.OnFire = false;
newTile.CastShadow = tileDefinition.castShadow;
newTile.LightSource = (tileDefinition.lightSourceIntensity > 0);
newTile.ExtraData = 0;
tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)] = newTile;
if (updateLighting)
{
if (newTile.CastShadow != oldTile.CastShadow)
{
if (newTile.CastShadow)
{
LightModelAmbient.UpdateLuminanceDark(this, pos);
LightModelLightSource.UpdateLuminanceDark(this, pos);
}
else
{
LightModelAmbient.UpdateLuminanceLight(this, pos, newTile.AmbientLuminance);
LightModelLightSource.UpdateLuminanceLight(this, pos, newTile.LightSourceLuminance);
}
}
if (tileDefinition.lightSourceIntensity > 0)
{
LightModelLightSource.UpdateLuminanceLight(this, pos, tileDefinition.lightSourceIntensity);
}
}
else
{
if (newTile.LightSource)
{
SetTileLightSourceLuminance(pos, tileDefinition.lightSourceIntensity);
}
}
ExecuteTileActions(pos, TileActionRule.ActionType.CREATED);
if (enqueueTileUpdates)
{
EnqueueInvalidatedTileAndNearTiles(pos);
}
UpdateTopPosition(pos, type);
if (reportTileInvalidated)
{
ReportTileInvalidated(pos);
}
}
public byte GetTileAmbientLuminance(TilePosition pos)
{
return(tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].AmbientLuminance);
}
public DynamicTile GetDynamicTile(TilePosition pos)
{
return(dynamicTiles[pos]);
}
public byte GetTileLightSourceLuminance(TilePosition pos)
{
return(tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].LightSourceLuminance);
}
public bool GetTileDynamic(TilePosition pos)
{
return(tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].Dynamic);
}
public void TileHitFloor(TilePosition pos)
{
ExecuteTileActions(pos, TileActionRule.ActionType.HIT_FLOOR);
}
public byte GetTileExtraData(TilePosition pos)
{
return(tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].ExtraData);
}
public void TileDamaged(TilePosition pos)
{
ExecuteTileActions(pos, TileActionRule.ActionType.DAMAGED);
}
public bool GetTileLiquid(TilePosition pos)
{
return(GetTileDefinition(tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].tileType).liquid);
}
public void Load(System.IO.BinaryReader br)
{
//Read tile definition mapper (oldId -> newId)
byte[] mapTileDefinitionMapper = new byte[byte.MaxValue];
int definitions = br.ReadInt32();
for (int i = 0; i < definitions; i++)
{
byte oldType = br.ReadByte();
string id = br.ReadString();
byte newType = 0;
foreach (TileDefinition td in tileDefinitions)
{
if (td.id == id)
{
newType = td.tileType;
break;
}
}
mapTileDefinitionMapper[oldType] = newType;
}
//Read map size
//This is read in CubeWorld.Load()
//int sizeXbits = br.ReadInt32();
//int sizeYbits = br.ReadInt32();
//int sizeZbits = br.ReadInt32();
//Create empty world
//The world is already created in CubeLoad.Load()
//Create(tileDefinitions, sizeXbits, sizeYbits, sizeZbits);
//Read tiles
byte[] tileBytes = br.ReadBytes(sizeX * sizeY * sizeZ * 4);
Tile tile = new Tile();
for (int n = tiles.Length - 1; n >= 0; n--)
{
tile.tileType = mapTileDefinitionMapper[tileBytes[(n << 2) | 0]];
tile.luminance = tileBytes[(n << 2) | 1];
tile.extra = tileBytes[(n << 2) | 2];
tile.extra2 = tileBytes[(n << 2) | 3];
tiles[n] = tile;
}
//Read dynamic tiles
int nDyanamicTiles = br.ReadInt32();
for (int n = 0; n < nDyanamicTiles; n++)
{
int objectId = br.ReadInt32();
TilePosition pos = SerializationUtils.ReadTilePosition(br);
int timeout = br.ReadInt32();
DynamicTile dynamicTile = new DynamicTile(world, pos, true, objectId);
//TODO: Get gravity attribute from somewhere
if (true)
{
dynamicTile.AddComponent(new TileComponentGravity());
}
dynamicTiles[pos] = dynamicTile;
if (timeout > 0)
{
dynamicTile.timeout = timeout;
dynamicTilesTimeout[pos] = dynamicTile;
}
world.cwListener.CreateObject(dynamicTile);
}
//Read top positions
topPositions = br.ReadBytes(sizeX * sizeZ);
if (world.gameplay.useEnqueueTileUpdates)
{
EnqueueTilesWithRules();
}
enqueueTileUpdates = world.gameplay.useEnqueueTileUpdates;
updateLighting = true;
reportTileInvalidated = true;
if (world.gameplay.useEnqueueTileUpdates)
{
UpdateTiles();
}
//The read tiles already have the light information updated
//LightModelAmbient.InitLuminance(this);
//LightModelLightSource.InitLuminance(this);
}
public Tile GetTile(TilePosition pos)
{
return(tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)]);
}
