Example #1
0
        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);
            }
        }
Example #2
0
        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);
            }
        }
Example #3
0
        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);
                    }
                }
            }
        }
Example #4
0
        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);
                        }
                    }
                }
            }
        }
Example #5
0
        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);
                        }
                    }
                }
            }
        }
Example #6
0
        public void RegisterClient(IClient client)
        {
            if (playerManager == null)
            {
                playerManager = PluginManager.GetPluginByType <UMPlayerManager>();
            }

            if (worldManager == null)
            {
                worldManager = PluginManager.GetPluginByType <UMWorldManager>();
            }


            Console.WriteLine("Weaponmanager registered player");
            client.MessageReceived += Client_MessageReceived;

            WorldData World = worldManager.clients[client].World;

            foreach (Player p in World.players.Values)
            {
                if (p.WeaponEntityID != ushort.MaxValue)
                {
                    using (DarkRiftWriter weaponSwitchWriter = DarkRiftWriter.Create())
                    {
                        WeaponSwitchServerDTO switchData = new WeaponSwitchServerDTO();
                        switchData.playerId       = client.ID;
                        switchData.weaponEntityId = p.WeaponEntityID;
                        switchData.weaponSlot     = 0;

                        weaponSwitchWriter.Write(switchData);
                        using (Message fireStartMessage = Message.Create(Tags.WeaponSwitchTag, weaponSwitchWriter)) //Repeat the incoming tagname as all message bodies are the same
                        {
                            client.SendMessage(fireStartMessage, SendMode.Reliable);
                        }
                    }
                }
            }
        }
Example #7
0
        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);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Example #8
0
        public void RegisterClient(IClient client, WorldData World)
        {
            if (WorldManager == null)
            {
                WorldManager = PluginManager.GetPluginByType <UMWorldManager>();
            }
            if (WeaponManager == null)
            {
                WeaponManager = PluginManager.GetPluginByType <UMWeaponManager>();
            }

            WorldManager.clients[client].World = World;

            client.MessageReceived += Client_MessageReceived;

            //Send exsisting players
            using (DarkRiftWriter playerWriter = DarkRiftWriter.Create())
            {
                //PlayerSpawnServerDTO spawnData = new PlayerSpawnServerDTO();
                foreach (Player player in World.players.Values)
                {
                    this.WritePlayerSpawnData(playerWriter, player);
                }


                foreach (Player player in World.AIPlayers.Values)
                {
                    this.WritePlayerSpawnData(playerWriter, player);
                }

                using (Message playerMessage = Message.Create(Tags.SpawnPlayerTag, playerWriter))
                    client.SendMessage(playerMessage, SendMode.Reliable);
            }

            //Register WeaponManager
            WeaponManager.RegisterClient(client);
        }
Example #9
0
        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);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Example #10
0
        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);
            }
        }
Example #11
0
        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);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Example #12
0
        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);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Example #13
0
        private void Client_MessageReceived(object sender, MessageReceivedEventArgs e)
        {
            using (Message message = e.GetMessage() as Message)
            {
                WorldData World = WorldManager.clients[e.Client].World;
                if (message.Tag == Tags.SpawnEntityTag)
                {
                    using (DarkRiftReader reader = message.GetReader())
                    {
                        while (reader.Position < reader.Length)
                        {
                            SpawnEntityClientDTO data = reader.ReadSerializable <SpawnEntityClientDTO>();

                            this.SpawnEntity(World, data);
                        }
                    }
                }
                else
                if (message.Tag == Tags.SpawnProceduralShapeEntityTag)
                {
                    using (DarkRiftReader reader = message.GetReader())
                    {
                        while (reader.Position < reader.Length)
                        {
                            SpawnProceduralShapeEntityClientDTO data = reader.ReadSerializable <SpawnProceduralShapeEntityClientDTO>();
                            Console.WriteLine("Got spawn procedural message");
                            this.SpawnProceduralShapeEntity(World, data);
                        }
                    }
                }
                else
                if (message.Tag == Tags.DespawnEntityTag)
                {
                    using (DarkRiftReader reader = message.GetReader())
                    {
                        while (reader.Position < reader.Length)
                        {
                            uint id = reader.ReadUInt32();
                            this.DespawnEntity(World, id);
                        }
                    }
                }
                else
                if (message.Tag == Tags.SetEntityParentTag)
                {
                    using (DarkRiftReader reader = message.GetReader())
                    {
                        while (reader.Position < reader.Length)
                        {
                            SetParentDTO data = reader.ReadSerializable <SetParentDTO>();

                            SetParent(World, data);
                        }
                    }
                }
                else
                if (message.Tag == Tags.SetStateEntityTag)
                {
                    using (DarkRiftReader reader = message.GetReader())
                    {
                        while (reader.Position < reader.Length)
                        {
                            uint   id       = reader.ReadUInt32();
                            ushort newState = reader.ReadUInt16();

                            SetState(World, id, newState);
                        }
                    }
                }
                else
                if (message.Tag == Tags.TransformEntityTag)
                {
                    using (DarkRiftReader reader = message.GetReader())
                    {
                        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 sx = reader.ReadSingle();
                            float sy = reader.ReadSingle();
                            float sz = reader.ReadSingle();

                            SetTransform(World, id, x, y, z, rx, ry, rz, sx, sy, sz);
                        }
                    }
                }
                else
                if (message.Tag == Tags.PhysicsUpdateEntityTag)
                {
                    if (e.Client == WorldManager.clients[e.Client].World.PhysicsHost)
                    {
                        PhysicsUpdate(sender, e, WorldManager.clients[e.Client].World);
                    }
                }
                else
                if (message.Tag == Tags.SetPhysicsEntityTag)
                {
                    using (DarkRiftReader reader = message.GetReader())
                    {
                        while (reader.Position < reader.Length)
                        {
                            //Console.WriteLine("recieved physmessage");
                            SetPhysicsDTO data = reader.ReadSerializable <SetPhysicsDTO>();
                            setPhysics(World, data);
                        }
                    }
                }
                else
                if (message.Tag == Tags.AddComponentTag)
                {
                    using (DarkRiftReader reader = message.GetReader())
                    {
                        while (reader.Position < reader.Length)
                        {
                            //Console.WriteLine("recieved physmessage");
                            AddComponentClientDTO data = reader.ReadSerializable <AddComponentClientDTO>();
                            addComponent(World, data);
                        }
                    }
                }
                else
                if (message.Tag == Tags.RemoveComponentTag)
                {
                    using (DarkRiftReader reader = message.GetReader())
                    {
                        while (reader.Position < reader.Length)
                        {
                            //Console.WriteLine("recieved physmessage");
                            RemoveComponentDTO data = reader.ReadSerializable <RemoveComponentDTO>();
                            removeComponent(World, data);
                        }
                    }
                }
                else
                if (message.Tag == Tags.SetComponentPropertyTag)
                {
                    using (DarkRiftReader reader = message.GetReader())
                    {
                        //while (reader.Position < reader.Length)
                        //{

                        ComponentPropertyDTO data = reader.ReadSerializable <ComponentPropertyDTO>();

                        setComponentProperty(World, data);
                        //}
                    }
                }
            }
        }