public bool HasVisibleCell(VisibleCell cell)
{
lock (cells)
{
return(cells.Contains(cell));
}
}
public void Add(VisibleCell cell)
{
lock (cells)
{
cells.Add(cell);
}
}
VisibleCell IVisibleCellManager.getNewCell(Character character, int x, int y, RLColor color, int layer)
{
VisibleCell cell = new VisibleCell(x, y, character, color, layer);
_visibleCells.Add(cell);
return(cell);
}
public void Remove(VisibleCell cell)
{
lock (cells)
{
cells.Remove(cell);
}
}
public bool HasCellLoaded(VisibleCell cell)
{
lock (visibleCells)
{
return(visibleCells.Contains(cell));
}
}
public void CellUnloaded(Int3 batchId, Int3 cellId, int level)
{
VisibleCell cell = new VisibleCell(batchId, cellId, level);
if (visibleCells.Contains(cell))
{
visibleCells.Remove(cell);
removed.Add(cell);
markCellsReadyForSync(0);
}
}
private void item_CellChanged(Item item, Index2 newValue)
{
// Environment Information aktualisieren
VisibleEnvironment env = viewers[item.Id].Environment;
// Element außerhalb des Spielfeldes
Index2 limit = Engine.Map.GetCellCount();
if (newValue.X < 0 || newValue.X >= limit.X ||
newValue.Y < 0 || newValue.Y >= limit.Y)
{
env.Center = null;
env.North = null;
env.South = null;
env.West = null;
env.East = null;
env.NorthWest = null;
env.NorthEast = null;
env.SouthWest = null;
env.SouthEast = null;
return;
}
// Umgebungszellen durchlaufen
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
var offset = new Index2(x, y);
Index2 cell = newValue + offset;
if (cell.X < 0 || cell.X >= limit.X ||
cell.Y < 0 || cell.Y >= limit.Y)
{
// Es existiert keine Zelle mehr
env[offset] = null;
}
else
{
// Zelleninfos ermitteln
float speed = Engine.Map.Tiles[cell.X, cell.Y].GetSpeedMultiplicator();
TileHeight height = Engine.Map.Tiles[cell.X, cell.Y].Height;
env[offset] = new VisibleCell
{
Speed = speed,
Height = height
};
}
}
}
// Inform user
viewers[item.Id].RefreshEnvironment();
}
public void TestInitialize()
{
packetReceiver = new DeferringPacketReceiver(visibleCells);
Int3 loadedBatchId = LargeWorldStreamer.main.GetContainingBatch(loadedActionPosition);
Int3 unloadedBatchId = LargeWorldStreamer.main.GetContainingBatch(unloadedActionPosition);
loadedCell = new VisibleCell(loadedBatchId, cellId, 3);
unloadedCell = new VisibleCell(unloadedBatchId, cellId, 3);
visibleCells.Add(loadedCell);
}
private IEnumerator WaitAndAddCell(Int3 batchId, Int3 cellId, int level)
{
yield return(new WaitForSeconds(0.5f));
VisibleCell cell = new VisibleCell(batchId, cellId, level);
if (!visibleCells.Contains(cell))
{
visibleCells.Add(cell);
added.Add(cell);
packetReceiver.CellLoaded(cell);
}
}
private void ReassignRemovedCellEntitySimulation(Player sendingPlayer, VisibleCell[] removedCells, List <OwnedGuid> ownershipChanges)
{
List <Entity> revokedEntities = entityManager.RevokeEntitySimulationFor(sendingPlayer, removedCells);
foreach (Entity entity in revokedEntities)
{
VisibleCell entityCell = new VisibleCell(entity.Position, entity.Level);
foreach (Player player in playerManager.GetPlayers())
{
if (player != sendingPlayer && player.HasCellLoaded(entityCell))
{
Log.Info("player " + player.Id + " can take over " + entity.Guid);
ownershipChanges.Add(new OwnedGuid(entity.Guid, player.Id, true));
}
}
}
}
private void AssignVisibleUpdatesToPlayers(List <EntityTransformUpdate> updates, Dictionary <Player, List <EntityTransformUpdate> > visibleUpdatesByPlayer)
{
foreach (EntityTransformUpdate update in updates)
{
Entity entity = entityManager.UpdateEntityPosition(update.Guid, update.Position, update.Rotation);
VisibleCell visibleCell = new VisibleCell(entity.Position, entity.Level);
foreach (KeyValuePair <Player, List <EntityTransformUpdate> > playerUpdates in visibleUpdatesByPlayer)
{
Player player = playerUpdates.Key;
List <EntityTransformUpdate> visibleUpdates = playerUpdates.Value;
if (player.HasCellLoaded(visibleCell))
{
visibleUpdates.Add(update);
}
}
}
}
public void setTerrain(TerrainType terrainType)
{
Terrain = terrainType;
switch (Terrain)
{
case TerrainType.Land:
VisibleCell.SetCharacter(SpecialCharacter.LandSparse);
VisibleCell.Color = RLNET.RLColor.Green;
break;
case TerrainType.Sea:
VisibleCell.SetCharacter(SpecialCharacter.Tilde);
VisibleCell.Color = RLNET.RLColor.Blue;
break;
default:
throw new System.ArgumentException(terrainType.ToString());
}
}
public void CellLoaded(VisibleCell visibleCell)
{
if (visibleCell.Level > DESIRED_CELL_MIN_LOD_FOR_ACTIONS)
{
return;
}
lock (deferredPacketsByAbsoluteCell)
{
Queue <Packet> deferredPackets;
if (deferredPacketsByAbsoluteCell.TryGetValue(visibleCell.AbsoluteCellEntity, out deferredPackets))
{
while (deferredPackets.Count > 0)
{
Log.Debug("Found deferred packet... adding it back with high priority.");
Packet packet = deferredPackets.Dequeue();
receivedPackets.Enqueue(EXPIDITED_PACKET_PRIORITY, packet);
}
}
}
}
private bool PacketWasDeferred(Packet packet)
{
if (packet is PlayerActionPacket)
{
PlayerActionPacket playerAction = (PlayerActionPacket)packet;
if (!playerAction.PlayerMustBeInRangeToReceive)
{
return(false);
}
AbsoluteEntityCell cell = new AbsoluteEntityCell(playerAction.ActionPosition);
bool cellLoaded = false;
for (int level = 0; level <= DESIRED_CELL_MIN_LOD_FOR_ACTIONS; level++)
{
VisibleCell visibleCell = new VisibleCell(cell, level);
if (visibleCells.HasVisibleCell(visibleCell))
{
cellLoaded = true;
break;
}
}
if (!cellLoaded)
{
Log.Debug("Action was deferred, cell not loaded (with required lod): " + cell);
AddPacketToDeferredMap(playerAction, cell);
return(true);
}
}
return(false);
}
private void item_CellChanged(Item item, Index2 newValue)
{
// Environment Information aktualisieren
VisibleEnvironment env = viewers[item.Id].Environment;
// Element außerhalb des Spielfeldes
Index2 limit = Engine.Map.GetCellCount();
if (newValue.X < 0 || newValue.X >= limit.X ||
newValue.Y < 0 || newValue.Y >= limit.Y)
{
env.Center = null;
env.North = null;
env.South = null;
env.West = null;
env.East = null;
env.NorthWest = null;
env.NorthEast = null;
env.SouthWest = null;
env.SouthEast = null;
return;
}
// Umgebungszellen durchlaufen
for (int x = -1; x <= 1; x++)
for (int y = -1; y <= 1; y++)
{
var offset = new Index2(x, y);
Index2 cell = newValue + offset;
if (cell.X < 0 || cell.X >= limit.X ||
cell.Y < 0 || cell.Y >= limit.Y)
{
// Es existiert keine Zelle mehr
env[offset] = null;
}
else
{
// Zelleninfos ermitteln
float speed = Engine.Map.Tiles[cell.X, cell.Y].GetSpeedMultiplicator();
TileHeight height = Engine.Map.Tiles[cell.X, cell.Y].Height;
env[offset] = new VisibleCell
{
Speed = speed,
Height = height
};
}
}
// Inform user
viewers[item.Id].RefreshEnvironment();
}
public void Delete(VisibleCell cell)
{
_visibleCells.Remove(cell);
}
