Esempio n. 1
0
        private static void ProcessClientPacket(int packetID)
        {
            switch ((PacketID)packetID)
            {
            case PacketID.EntityUpdate:
                #region entityUpdate
                var entityUpdate = new EntityUpdate(creader);
                if (dynamicEntities.ContainsKey(entityUpdate.guid))
                {
                    entityUpdate.Filter(dynamicEntities[entityUpdate.guid]);
                    entityUpdate.Merge(dynamicEntities[entityUpdate.guid]);
                }
                else
                {
                    dynamicEntities.Add(entityUpdate.guid, entityUpdate);
                }
                if (entityUpdate.name != null)
                {
                    RefreshPlayerlist();
                }
                if (!entityUpdate.IsEmpty)
                {
                    SendUDP(entityUpdate.CreateDatagram());
                }
                break;

                #endregion
            case PacketID.EntityAction:
                #region entity action
                EntityAction entityAction = new EntityAction(creader);
                switch (entityAction.type)
                {
                case ActionType.Talk:
                    #region Talk
                    break;

                    #endregion
                case ActionType.StaticInteraction:
                    #region StaticInteraction
                    ChatMessage x = new ChatMessage()
                    {
                        message = "You can't use this, your hands are too small.",
                        sender  = 0
                    };
                    SendToClient(x);
                    break;

                    #endregion
                case ActionType.PickUp:
                    #region PickUp
                    break;

                    #endregion
                case ActionType.Drop:         //send item back to dropper because dropping is disabled to prevent chatspam
                    #region Drop
                    if (form.radioButtonDestroy.Checked)
                    {
                        SendToClient(new ChatMessage()
                        {
                            message = "item destroyed",
                            sender  = 0,
                        });
                    }
                    else
                    {
                        var serverUpdate = new ServerUpdate();
                        var pickup       = new ServerUpdate.Pickup()
                        {
                            guid = guid,
                            item = entityAction.item
                        };
                        serverUpdate.pickups.Add(pickup);
                        if (form.radioButtonDuplicate.Checked)
                        {
                            serverUpdate.pickups.Add(pickup);
                        }
                        SendToClient(serverUpdate);
                    }
                    break;

                    #endregion
                case ActionType.CallPet:
                    #region CallPet
                    break;

                    #endregion
                default:
                    //unknown type
                    break;
                }
                break;

                #endregion
            case PacketID.Hit:
                #region hit
                var hit    = new Hit(creader);
                var attack = new Attack()
                {
                    Target    = (ushort)hit.target,
                    Damage    = hit.damage,
                    Direction = hit.direction,
                    Stuntime  = hit.stuntime,
                    Skill     = hit.isYellow,
                    Type      = hit.type,
                    ShowLight = hit.showlight,
                    Critical  = hit.critical
                };
                SendUDP(attack.data);
                lastTarget = attack.Target;
                break;

                #endregion
            case PacketID.PassiveProc:
                #region passiveProc
                var passiveProc = new PassiveProc(creader);
                switch (passiveProc.type)
                {
                case ProcType.Bulwalk:
                    SendToClient(new ChatMessage()
                    {
                        message = string.Format("bulwalk: {0}% dmg reduction", 1.0f - passiveProc.modifier),
                        sender  = 0,
                    });
                    break;

                case ProcType.WarFrenzy:
                    break;

                case ProcType.Camouflage:
                    break;

                case ProcType.Poison:
                    break;

                case ProcType.UnknownA:
                    break;

                case ProcType.ManaShield:
                    SendToClient(new ChatMessage()
                    {
                        message = string.Format("manashield: {0}", passiveProc.modifier),
                        sender  = 0,
                    });
                    break;

                case ProcType.UnknownB:
                    break;

                case ProcType.UnknownC:
                    break;

                case ProcType.FireSpark:
                    break;

                case ProcType.Intuition:
                    break;

                case ProcType.Elusiveness:
                    break;

                case ProcType.Swiftness:
                    break;

                default:
                    break;
                }
                var proc = new Proc()
                {
                    Target   = (ushort)passiveProc.target,
                    Type     = passiveProc.type,
                    Modifier = passiveProc.modifier,
                    Duration = passiveProc.duration
                };
                SendUDP(proc.data);
                break;

                #endregion
            case PacketID.Shoot:
                #region shoot
                var shoot      = new Shoot(creader);
                var projectile = new Projectile()
                {
                    Position  = shoot.position,
                    Velocity  = shoot.velocity,
                    Scale     = shoot.scale,
                    Particles = shoot.particles,
                    Type      = shoot.projectile,
                    Source    = (ushort)shoot.attacker,
                };
                SendUDP(projectile.data);
                break;

                #endregion
            case PacketID.Chat:
                #region chat
                var chatMessage = new ChatMessage(creader);
                if (chatMessage.message.ToLower() == @"/plane")
                {
                    Console.Beep();
                    var serverUpdate = new ServerUpdate()
                    {
                        blockDeltas = new Vox("model.vox").Parse(),
                    };
                    foreach (var block in serverUpdate.blockDeltas)
                    {
                        block.position.x += 0x802080; //(int)(dynamicEntities[guid].position.x / 0x10000);//8286946;
                        block.position.y += 0x802080; //(int)(dynamicEntities[guid].position.y / 0x10000);//8344456;
                        block.position.z += 150;      // (int)(dynamicEntities[guid].position.z / 0x10000);//220;
                    }
                    SendToClient(serverUpdate);
                }
                if (chatMessage.message.ToLower() == @"/spawn")
                {
                    CwRam.Teleport(new LongVector()
                    {
                        x = 0x8020800000,
                        y = 0x8020800000,
                        z = 0,
                    });
                    break;
                }
                var chat = new Chat()
                {
                    Sender = guid,    //client doesn't send this
                    Text   = chatMessage.message
                };
                SendUDP(chat.data);
                break;

                #endregion
            case PacketID.Chunk:
                #region chunk
                var chunk = new Chunk(creader);
                break;

                #endregion
            case PacketID.Sector:
                #region sector
                var sector = new Sector(creader);
                break;

                #endregion
            case PacketID.Version:
                #region version
                var version = new ProtocolVersion(creader);
                if (version.version != 3)
                {
                    version.version = 3;
                    SendToClient(version);
                }
                else
                {
                    SendToClient(new Join()
                    {
                        guid = guid,
                        junk = new byte[0x1168]
                    });
                    SendToClient(new MapSeed()
                    {
                        seed = mapseed
                    });
                    foreach (var dynamicEntity in dynamicEntities.Values.ToList())
                    {
                        SendToClient(dynamicEntity);
                    }
                }
                break;

                #endregion
            default:
                form.Log("unknown client packet\n", Color.Magenta);
                break;
            }
        }