public override void Update(float deltaTime)
{
if (deltaTime > MAX_DELTA_TIME)
deltaTime = MAX_DELTA_TIME;
Vector3 vectorToPlayer = item.position - (item.world.avatarManager.player.position + new Vector3(0, Player.HEAD_POSITION * 0.5f, 0));
float distanceToPlayer = vectorToPlayer.magnitude;
if (distanceToPlayer < PLAYER_CATCH_DISTANCE)
{
CWObject objectToAdd = this.item;
if (objectToAdd.definition.type == CWDefinition.DefinitionType.ItemTile)
objectToAdd = new DynamicTile(item.world, ((ItemTileDefinition) item.definition).tileDefinition, -1);
if (item.world.avatarManager.player.inventory.Add(objectToAdd))
item.world.itemManager.RemoveItem(item);
}
else if (distanceToPlayer < PLAYER_ATTRACT_DISTANCE)
{
Vector3 dirToPlayer = vectorToPlayer.normalized;
item.position -= dirToPlayer * MOVE_SPEED * deltaTime;
}
}
public void SetTileDynamicTimeout(TilePosition pos, int timeout)
{
if (tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].Dynamic)
{
DynamicTile dynamicTile = dynamicTiles[pos];
if (dynamicTile.timeout > 0)
{
//Dynamic tile already in the dynamicTilesTimeout dictionary, update timeout value or remove
if (timeout <= 0)
{
dynamicTile.timeout = 0;
dynamicTilesTimeout.Remove(pos);
}
else
{
dynamicTile.timeout = timeout;
}
}
else if (timeout > 0)
{
//Dynamic tile not in the dynamicTilesTimeout dictionary, add it
dynamicTile.timeout = timeout;
dynamicTilesTimeout[pos] = dynamicTile;
}
}
}
public void SetTileDynamic(TilePosition pos, bool dynamic, bool useGravity, int timeout)
{
if (tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].Dynamic != dynamic)
{
if (tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].Dynamic)
{
DynamicTile dynamicTile = dynamicTiles[pos];
dynamicTiles.Remove(pos);
if (dynamicTile.timeout > 0)
{
dynamicTilesTimeout.Remove(pos);
}
world.cwListener.DestroyObject(dynamicTile);
dynamicTile.Clear();
}
tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].Dynamic = dynamic;
if (dynamic)
{
DynamicTile dynamicTile = new DynamicTile(world, pos, true, world.gameplay.NextObjectId());
if (useGravity)
{
dynamicTile.AddComponent(new TileComponentGravity());
}
dynamicTiles[pos] = dynamicTile;
if (timeout > 0)
{
dynamicTile.timeout = timeout;
dynamicTilesTimeout[pos] = dynamicTile;
}
world.cwListener.CreateObject(dynamicTile);
}
if (reportTileInvalidated)
{
ReportTileInvalidated(pos);
}
}
else
{
if (dynamic && timeout >= 0)
{
SetTileDynamicTimeout(pos, timeout);
}
}
}
public virtual void FillPlayerInventory(Inventory inventory)
{
foreach (ItemDefinition itemDefinition in world.itemManager.itemDefinitions)
{
if (itemDefinition.type != CubeWorld.World.Objects.CWDefinition.DefinitionType.ItemTile)
{
Item item = new Item(world, itemDefinition, -1);
InventoryEntry ie = new InventoryEntry();
ie.position = 0;
ie.quantity = 1;
ie.cwobject = item;
inventory.entries.Add(ie);
}
}
foreach (TileDefinition tileDefinition in world.tileManager.tileDefinitions)
{
if (tileDefinition.tileType != TileDefinition.EMPTY_TILE_TYPE)
{
DynamicTile dynamicTile = new DynamicTile(world, tileDefinition, -1);
InventoryEntry ie = new InventoryEntry();
ie.position = 0;
ie.quantity = 10;
ie.cwobject = dynamicTile;
inventory.entries.Add(ie);
}
}
}
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 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 Load(System.IO.BinaryReader br)
{
entries.Clear();
int n = br.ReadInt32();
for (int i = 0; i < n; i++)
{
string id = br.ReadString();
int position = br.ReadInt32();
int quantity = br.ReadInt32();
TileDefinition tileDefinition = owner.world.tileManager.GetTileDefinitionById(id);
CWObject cwobject = null;
if (tileDefinition != null)
{
//It's a tile
DynamicTile dynamicTile = new DynamicTile(owner.world, tileDefinition, -1);
cwobject = dynamicTile;
}
else
{
ItemDefinition itemDefinition = owner.world.itemManager.GetItemDefinitionById(id);
if (itemDefinition != null)
{
//It's an item
Item item;
if (itemDefinition.type == CubeWorld.World.Objects.CWDefinition.DefinitionType.ItemTile)
item = new ItemTile(owner.world, (ItemTileDefinition)itemDefinition, -1);
else
item = new Item(owner.world, itemDefinition, -1);
cwobject = item;
}
}
cwobject.Load(br);
InventoryEntry ie = new InventoryEntry();
ie.position = position;
ie.quantity = quantity;
ie.cwobject = cwobject;
entries.Add(ie);
}
}
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 void SetTileDynamic(TilePosition pos, bool dynamic, bool useGravity, int timeout)
{
if (tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].Dynamic != dynamic)
{
if (tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].Dynamic)
{
DynamicTile dynamicTile = dynamicTiles[pos];
dynamicTiles.Remove(pos);
if (dynamicTile.timeout > 0)
dynamicTilesTimeout.Remove(pos);
world.cwListener.DestroyObject(dynamicTile);
dynamicTile.Clear();
}
tiles[pos.x | (pos.y << sizeXbits) | (pos.z << sizeXBitsYBits)].Dynamic = dynamic;
if (dynamic)
{
DynamicTile dynamicTile = new DynamicTile(world, pos, true, world.gameplay.NextObjectId());
if (useGravity)
dynamicTile.AddComponent(new TileComponentGravity());
dynamicTiles[pos] = dynamicTile;
if (timeout > 0)
{
dynamicTile.timeout = timeout;
dynamicTilesTimeout[pos] = dynamicTile;
}
world.cwListener.CreateObject(dynamicTile);
}
if (reportTileInvalidated)
ReportTileInvalidated(pos);
}
else
{
if (dynamic && timeout >= 0)
SetTileDynamicTimeout(pos, timeout);
}
}
