//Gets called before the clients are removed from the world's client list
public void UnregisterClient(IClient client)
{
if (WorldManager.clients.ContainsKey(client))
{
WorldData World = WorldManager.clients[client].World;
if (World != null && client == World.PhysicsHost)
{
World.PhysicsHost = null;
if (World.GetClients().Count() > 1)
{
this.SetPhysicsHost(World.GetClients().Where(x => x != client).First());
}
}
}
}
public void SetParent(WorldData World, SetParentDTO data)
{
if (World.Entities.ContainsKey(data.ID) && (data.parentID == 0 || World.Entities.ContainsKey(data.parentID)))
{
World.Entities[data.ID].parentID = data.parentID;
World.Entities[data.ID].X = data.localPosition.x;
World.Entities[data.ID].Y = data.localPosition.y;
World.Entities[data.ID].Z = data.localPosition.z;
World.Entities[data.ID].rotX = data.localRotation.x;
World.Entities[data.ID].rotY = data.localRotation.y;
World.Entities[data.ID].rotZ = data.localRotation.z;
World.Entities[data.ID].scaleX = data.localScale.x;
World.Entities[data.ID].scaleY = data.localScale.y;
World.Entities[data.ID].scaleZ = data.localScale.z;
using (DarkRiftWriter entityParentWriter = DarkRiftWriter.Create())
{
entityParentWriter.Write(data);
using (Message setParentMessage = Message.Create(Tags.SetEntityParentTag, entityParentWriter))
{
foreach (IClient c in World.GetClients())
{
c.SendMessage(setParentMessage, SendMode.Reliable);
}
}
}
}
else
{
Console.WriteLine($"Setting parent failed, non exsistant child or parent. Child: {data.ID} Parent {data.parentID}");
}
}
public uint SpawnProceduralShapeEntity(WorldData World, SpawnProceduralShapeEntityClientDTO data)
{
World.entityIdCounter++;
uint newID = World.entityIdCounter;
UMProceduralShapeEntity newProceduralEntity = new UMProceduralShapeEntity(newID, data);
newProceduralEntity.spawnData = data;
newProceduralEntity.isProceduralShape = true;
World.Entities.Add(newID, newProceduralEntity);
using (DarkRiftWriter proceduralEntityWriter = DarkRiftWriter.Create())
{
proceduralEntityWriter.Write(newProceduralEntity.getServerSpawnDTO(newID));
using (Message spawnEntityMsg = Message.Create(Tags.SpawnProceduralShapeEntityTag, proceduralEntityWriter))
{
foreach (IClient c in World.GetClients())
{
c.SendMessage(spawnEntityMsg, SendMode.Reliable);
}
}
}
return(newID);
}
public void PhysicsUpdate(object sender, MessageReceivedEventArgs e, WorldData World)
{
using (DarkRiftReader reader = e.GetMessage().GetReader())
{
using (DarkRiftWriter entityPhysWriter = DarkRiftWriter.Create())
{
while (reader.Position < reader.Length)
{
uint id = reader.ReadUInt32();
float x = reader.ReadSingle();
float y = reader.ReadSingle();
float z = reader.ReadSingle();
float rx = reader.ReadSingle();
float ry = reader.ReadSingle();
float rz = reader.ReadSingle();
float vx = reader.ReadSingle();
float vy = reader.ReadSingle();
float vz = reader.ReadSingle();
if (World.Entities.ContainsKey(id))
{
World.Entities[id].X = x;
World.Entities[id].Y = y;
World.Entities[id].Z = z;
World.Entities[id].rotX = rx;
World.Entities[id].rotY = ry;
World.Entities[id].rotZ = rz;
World.Entities[id].velocityX = vx;
World.Entities[id].velocityY = vy;
World.Entities[id].velocityZ = vz;
entityPhysWriter.Write(id);
entityPhysWriter.Write(x);
entityPhysWriter.Write(y);
entityPhysWriter.Write(z);
entityPhysWriter.Write(rx);
entityPhysWriter.Write(ry);
entityPhysWriter.Write(rz);
entityPhysWriter.Write(vx);
entityPhysWriter.Write(vy);
entityPhysWriter.Write(vz);
}
}
using (Message physUpdateMessage = Message.Create(Tags.PhysicsUpdateEntityTag, entityPhysWriter))
{
foreach (IClient c in World.GetClients().Where(cl => cl != World.PhysicsHost))
{
c.SendMessage(physUpdateMessage, SendMode.Unreliable);
}
}
}
}
}
private void removeComponent(WorldData world, RemoveComponentDTO data)
{
if (world.EntityComponents.ContainsKey(data.ComponentID))
{
uint owner = world.EntityComponents[data.ComponentID].TargetID;
world.EntityComponents.Remove(data.ComponentID);
world.Entities[owner].RemoveComponentByID(data.ComponentID);
using (DarkRiftWriter entityWriter = DarkRiftWriter.Create())
{
RemoveComponentDTO outData = new RemoveComponentDTO();
outData.ComponentID = data.ComponentID;
entityWriter.Write(outData);
using (Message addcompMessage = Message.Create(Tags.RemoveComponentTag, entityWriter))
{
foreach (IClient c in world.GetClients())
{
c.SendMessage(addcompMessage, SendMode.Reliable);
}
}
}
}
}
public bool SetState(WorldData World, uint id, ushort state)
{
if (World.Entities.ContainsKey(id))
{
World.Entities[id].state = state;
using (DarkRiftWriter entityStateWriter = DarkRiftWriter.Create())
{
entityStateWriter.Write(id);
entityStateWriter.Write(state);
using (Message setStateMessage = Message.Create(Tags.SetStateEntityTag, entityStateWriter))
{
foreach (IClient c in World.GetClients())
{
c.SendMessage(setStateMessage, SendMode.Reliable);
}
}
}
}
else
{
Console.WriteLine("Setting state on non exsistant entity: " + id);
}
return(false);
}
public uint SpawnEntity(WorldData World, ushort entityId, ushort state, bool hasPhysics, float x, float y, float z,
float rotX = 0, float rotY = 0, float rotZ = 0,
float scaleX = 1, float scaleY = 1, float scaleZ = 1, UMComponentDTO[] components = null)
{
UMEntity newEntity = new UMEntity();
newEntity.world = World;
newEntity.entityId = entityId;
newEntity.state = state;
newEntity.hasPhysics = hasPhysics;
newEntity.X = x;
newEntity.Y = y;
newEntity.Z = z;
newEntity.rotX = rotX;
newEntity.rotY = rotY;
newEntity.rotZ = rotZ;
newEntity.scaleX = scaleX;
newEntity.scaleY = scaleY;
newEntity.scaleZ = scaleZ;
World.entityIdCounter++;
newEntity.id = World.entityIdCounter;
Console.WriteLine("COUNTER = " + World.entityIdCounter);
World.Entities.Add(newEntity.id, newEntity);
if (components != null)
{
foreach (UMComponentDTO comp in components)
{
comp.TargetID = newEntity.id;
comp.ID = World.componentIdCounter; //Assign new ComponentID
World.componentIdCounter++;
newEntity.Components.Add(comp);
World.EntityComponents.Add(comp.ID, comp);
}
}
using (DarkRiftWriter entityWriter = DarkRiftWriter.Create())
{
newEntity.WriteSpawn(entityWriter);
using (Message spawnEntityMsg = Message.Create(Tags.SpawnEntityTag, entityWriter))
{
foreach (IClient c in World.GetClients())
{
c.SendMessage(spawnEntityMsg, SendMode.Reliable);
}
}
}
return(newEntity.id);
}
private void addComponent(WorldData World, AddComponentClientDTO data)
{
if (World.Entities.ContainsKey(data.TargetID))
{
UMComponentDTO exsisting = World.Entities[data.TargetID].Components.Where((x) => { return(x.EntityID == data.EntityID); }).FirstOrDefault();
if (exsisting != null)
{
Console.WriteLine($"Component of type {data.EntityID} already exsists on entity {data.TargetID}");
return;
}
UMComponentDTO nComponent = new UMComponentDTO();
nComponent.EntityID = data.EntityID;
nComponent.TargetID = data.TargetID;
nComponent.ID = World.componentIdCounter;
World.componentIdCounter++;
World.Entities[data.TargetID].Components.Add(nComponent);
World.EntityComponents.Add(nComponent.ID, nComponent);
using (DarkRiftWriter entityWriter = DarkRiftWriter.Create())
{
AddComponentServerDTO outData = new AddComponentServerDTO();
outData.ID = nComponent.ID;
outData.EntityID = nComponent.EntityID;
outData.TargetID = nComponent.TargetID;
entityWriter.Write(outData);
using (Message addcompMessage = Message.Create(Tags.AddComponentTag, entityWriter))
{
foreach (IClient c in World.GetClients())
{
c.SendMessage(addcompMessage, SendMode.Reliable);
}
}
}
}
else
{
Console.WriteLine("Trying to add component to non exsistant entity: " + data.TargetID);
}
}
public void SetTransform(WorldData World, uint id, float x = 0, float y = 0, float z = 0, float rx = 0, float ry = 0, float rz = 0, float sx = 1, float sy = 1, float sz = 1)
{
if (World.Entities.ContainsKey(id))
{
World.Entities[id].X = x;
World.Entities[id].Y = y;
World.Entities[id].Z = z;
World.Entities[id].rotX = rx;
World.Entities[id].rotY = ry;
World.Entities[id].rotZ = rz;
World.Entities[id].scaleX = sx;
World.Entities[id].scaleY = sy;
World.Entities[id].scaleZ = sz;
using (DarkRiftWriter entityTransformWriter = DarkRiftWriter.Create())
{
entityTransformWriter.Write(id);
entityTransformWriter.Write(x);
entityTransformWriter.Write(y);
entityTransformWriter.Write(z);
entityTransformWriter.Write(rx);
entityTransformWriter.Write(ry);
entityTransformWriter.Write(rz);
entityTransformWriter.Write(sx);
entityTransformWriter.Write(sy);
entityTransformWriter.Write(sz);
using (Message setStateMessage = Message.Create(Tags.TransformEntityTag, entityTransformWriter))
{
foreach (IClient c in World.GetClients())
{
c.SendMessage(setStateMessage, SendMode.Unreliable);
}
}
}
}
else
{
Console.WriteLine("Setting transform on non exsistant entity: " + id);
}
}
public void DespawnPlayer(WorldData world, ushort id)
{
if (world.AIPlayers.ContainsKey(id))
{
world.AIPlayers.Remove(id);
}
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
writer.Write(id);
using (Message message = Message.Create(Tags.DespawnPlayerTag, writer))
{
foreach (IClient _client in world.GetClients())
{
_client.SendMessage(message, SendMode.Reliable);
}
}
}
}
private void setComponentProperty(WorldData World, ComponentPropertyDTO data)
{
if (World.EntityComponents.ContainsKey(data.ComponentID))
{
World.EntityComponents[data.ComponentID].AddOrUpdateProperty(data);
using (DarkRiftWriter entityWriter = DarkRiftWriter.Create())
{
entityWriter.Write(data);
using (Message addcompMessage = Message.Create(Tags.SetComponentPropertyTag, entityWriter))
{
foreach (IClient c in World.GetClients())
{
c.SendMessage(addcompMessage, SendMode.Reliable);
}
}
}
}
}
public void setPhysics(WorldData World, SetPhysicsDTO inData)
{
if (World.Entities.ContainsKey(inData.Id))
{
World.Entities[inData.Id].hasPhysics = inData.HasPhysics;
using (DarkRiftWriter physSettingsWriter = DarkRiftWriter.Create())
{
// TODO: Anti cheat goes here..
physSettingsWriter.Write(inData);
using (Message setPhysMessage = Message.Create(Tags.SetPhysicsEntityTag, physSettingsWriter))
{
Console.WriteLine("setphysics relayed");
foreach (IClient c in World.GetClients())
{
c.SendMessage(setPhysMessage, SendMode.Reliable);
}
}
}
}
}
public void WeaponSwitchMessageRecieved(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
if (message.Tag == Tags.WeaponSwitchTag)
{
using (DarkRiftReader reader = message.GetReader())
{
while (reader.Position < reader.Length)
{
WorldData World = worldManager.clients[e.Client].World;
WeaponSwitchClientDTO data = reader.ReadSerializable <WeaponSwitchClientDTO>();
Player cPlayer = World.players[e.Client];
cPlayer.WeaponEntityID = data.weaponEntityId;
using (DarkRiftWriter weaponSwitchWriter = DarkRiftWriter.Create())
{
WeaponSwitchServerDTO switchData = new WeaponSwitchServerDTO();
switchData.playerId = e.Client.ID;
switchData.weaponEntityId = data.weaponEntityId;
switchData.weaponSlot = data.weaponSlot;
weaponSwitchWriter.Write(switchData);
using (Message fireStartMessage = Message.Create(Tags.WeaponSwitchTag, weaponSwitchWriter)) //Repeat the incoming tagname as all message bodies are the same
{
foreach (IClient client in World.GetClients().Where(x => x != e.Client))
{
client.SendMessage(fireStartMessage, SendMode.Reliable);
}
}
}
}
}
}
}
}
public void DespawnEntity(WorldData World, uint id)
{
if (World.Entities.ContainsKey(id))
{
World.Entities.Remove(id);
using (DarkRiftWriter entityWriter = DarkRiftWriter.Create())
{
entityWriter.Write(id);
using (Message despawnEntityMsg = Message.Create(Tags.DespawnEntityTag, entityWriter))
{
foreach (IClient c in World.GetClients())
{
c.SendMessage(despawnEntityMsg, SendMode.Reliable);
}
}
}
}
else
{
Console.WriteLine("Trying to despawn non exsistant entity: " + id);
}
}
public void DamageHurtableRecieved(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
if (message.Tag == Tags.DamageHurtableTag)
{
using (DarkRiftReader reader = message.GetReader())
{
while (reader.Position < reader.Length)
{
WorldData World = worldManager.clients[e.Client].World;
DamageHurtableClientDTO data = reader.ReadSerializable <DamageHurtableClientDTO>();
using (DarkRiftWriter damageHurtableWriter = DarkRiftWriter.Create())
{
DamageHurtableServerDTO damageHurtableData = new DamageHurtableServerDTO();
damageHurtableData.InstagatorID = e.Client.ID;
damageHurtableData.VictimID = data.VictimID;
damageHurtableData.damage = data.damage;
Console.WriteLine($"{damageHurtableData.InstagatorID} damaging {damageHurtableData.VictimID} for {damageHurtableData.damage} hp");
damageHurtableWriter.Write(damageHurtableData);
using (Message damageHurtableMessage = Message.Create(Tags.DamageHurtableTag, damageHurtableWriter))
{
foreach (IClient client in World.GetClients())
{
client.SendMessage(damageHurtableMessage, SendMode.Reliable);
}
}
}
}
}
}
}
}
private void PlayerUpdateMessageRecieved(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
if (message.Tag == Tags.PlayerUpdateTag)
{
using (DarkRiftReader reader = message.GetReader())
{
while (reader.Position < reader.Length)
{
WorldData World = WorldManager.clients[e.Client].World;
PlayerUpdateClientDTO playerUpdateData = reader.ReadSerializable <PlayerUpdateClientDTO>();
Player player;
if (playerUpdateData.PlayerID < 128)
{
player = World.players[e.Client];
}
else
{
player = World.AIPlayers[playerUpdateData.PlayerID];
}
player.X = playerUpdateData.x;
player.Y = playerUpdateData.y;
player.Z = playerUpdateData.z;
player.RX = playerUpdateData.rx;
player.RY = playerUpdateData.ry;
player.RZ = playerUpdateData.rz;
player.VX = playerUpdateData.vx;
player.VY = playerUpdateData.vy;
player.VZ = playerUpdateData.vz;
using (DarkRiftWriter writer = DarkRiftWriter.Create())
{
PlayerUpdateServerDTO playerUpdateOutData = new PlayerUpdateServerDTO();
playerUpdateOutData.ID = player.ID;
playerUpdateOutData.x = player.X;
playerUpdateOutData.y = player.Y;
playerUpdateOutData.z = player.Z;
playerUpdateOutData.rx = player.RX;
playerUpdateOutData.ry = player.RY;
playerUpdateOutData.rz = player.RZ;
playerUpdateOutData.vx = player.VX;
playerUpdateOutData.vy = player.VY;
playerUpdateOutData.vz = player.VZ;
playerUpdateOutData.triggerQueue = playerUpdateData.triggerQueue;
writer.Write(playerUpdateOutData);
using (Message playerUpdateMessage = Message.Create(Tags.PlayerUpdateTag, writer))
{
foreach (IClient c in World.GetClients().Where(x => x != e.Client))
{
c.SendMessage(playerUpdateMessage, e.SendMode);
}
}
}
}
}
}
}
}
private void SpawnMessageReceived(object sender, MessageReceivedEventArgs e)
{
using (Message message = e.GetMessage() as Message)
{
if (message.Tag == Tags.SpawnPlayerTag)
{
using (DarkRiftReader reader = message.GetReader())
{
while (reader.Position < reader.Length)
{
PlayerSpawnClientDTO clientSpawnData = reader.ReadSerializable <PlayerSpawnClientDTO>();
WorldData World = WorldManager.clients[e.Client].World;
ushort entityId = clientSpawnData.entityID;
bool isNewPlayer = clientSpawnData.isAI ? !World.AIPlayers.ContainsKey(clientSpawnData.PlayerID) : !World.players.ContainsKey(e.Client);
Player player;
//TODO: use spawn rotation and health
if (isNewPlayer)
{
player = new Player(
clientSpawnData.isAI ? World.aiIDCounter : e.Client.ID, //Player id
clientSpawnData.position.x, clientSpawnData.position.y, clientSpawnData.position.z, //Position x,y,z TODO: make this a UMVector3
entityId,
100f, // MaxHealth
clientSpawnData.isAI
);
if (clientSpawnData.isAI)
{
World.AIPlayers.Add(World.aiIDCounter, player);
World.aiIDCounter++;
}
else
{
World.players.Add(e.Client, player);
}
}
else
{
player = clientSpawnData.isAI ? World.AIPlayers[clientSpawnData.PlayerID] : World.players[e.Client];
player.entityId = clientSpawnData.entityID;
player.X = clientSpawnData.position.x;
player.Y = clientSpawnData.position.y;
player.Z = clientSpawnData.position.z;
}
Console.WriteLine($"{player.ID} ({e.Client.ID}) requested spawn. isNewPlayer {isNewPlayer}, entityID { player.entityId }");
using (DarkRiftWriter newPlayerWriter = DarkRiftWriter.Create())
{
this.WritePlayerSpawnData(newPlayerWriter, player);
using (Message newPlayerMessage = Message.Create(Tags.SpawnPlayerTag, newPlayerWriter))
{
foreach (IClient client in World.GetClients())
{
client.SendMessage(newPlayerMessage, SendMode.Reliable);
}
}
}
}
}
}
}
}
