Esempio n. 1
0
        public Task <Unit> Handle(HandAnimationCommand request, CancellationToken cancellationToken)
        {
            var             agent         = _agentHub[request.AgentId];
            AnimationPacket playerDigging = new AnimationPacket()
            {
                Hand = request.Hand
            };

            return(agent.Send(playerDigging).ContinueWith((e) => Unit.Value));
        }
Esempio n. 2
0
        public static void ReadAnimation(Client client, PacketReader reader)
        {
            AnimationPacket ap = new AnimationPacket();

            ap.Read(reader);

            if (!reader.Failed)
            {
                Client.HandlePacketAnimation(client, ap);
            }
        }
    private void ApplyAnimationState(ulong clientId, Stream stream)
    {
        if (!enabled)
        {
            return;
        }
        AnimationPacket received_animation = AnimationPacket.FromStream(stream);

        lastGroundState = received_animation.ground_state;
        lastHangState   = received_animation.hang_state;
    }
    private void SubmitAnimationState(ulong clientId, Stream stream)
    {
        if (!enabled)
        {
            return;
        }
        AnimationPacket received_animation = AnimationPacket.FromStream(stream);

        using (PooledBitStream writeStream = PooledBitStream.Get()) {
            using (PooledBitWriter writer = PooledBitWriter.Get(writeStream)) {
                received_animation.Write(writer);
                InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimationState, OwnerClientId, writeStream, channel: ANIM_CHANNEL);
            }
        }
    }
Esempio n. 5
0
        public async void SwingHand(IAgent agent, CancellationToken jobCancellationToken, CancellationToken swingCancellationToken)
        {
            var playerDigging = new AnimationPacket()
            {
                Hand = Proto.Enum.HandType.Main
            };

            while (!jobCancellationToken.IsCancellationRequested && !swingCancellationToken.IsCancellationRequested)
            {
                await agent.Send(playerDigging);

                await Task.Delay(_swingDelay);
            }
            OnComplete(this);
        }
Esempio n. 6
0
        /// <inheritdoc />
        public override void PlayerAnimate(PlayerAnimations animation)
        {
            AnimationPacket packet = new AnimationPacket();

            switch (animation)
            {
            case PlayerAnimations.SwingLeftArm:
                packet.Hand = 1;
                break;

            case PlayerAnimations.SwingRightArm:
                packet.Hand = 0;
                break;
            }

            Client.SendPacket(packet);
        }
        public void AnimationFalse()
        {
            AnimationPacket _data = new AnimationPacket();

            // Tick to the edge spinning and fading
            _data.ToPosition1 = this._pTrueTopEdge;
            _data.DirectionY  = G__NumberDisplayPositionY.Top;
            _data.Layer1      = slTickBGLayer;
            _data.Layer2      = slTickPathLayer;
            this._iOSDrawingFactory.LayersToEdge(_data);

            // Cross to the center
            _data.ToPosition1 = this._pTrueCenter;
            _data.ToPosition2 = this._pTrueBottomEdge;
            _data.Layer1      = slCrossBGLayer;
            _data.Layer2      = slCrossPathLayer;
            this._iOSDrawingFactory.LayersToCenter(_data);
        }
Esempio n. 8
0
        public static void HandlePacketAnimation(Client client, AnimationPacket packet)
        {
            Player p = client.Owner;

            UniversalCoords coords = UniversalCoords.FromAbsWorld(p.Position);

            foreach (Client c in p.Server.GetNearbyPlayersInternal(p.World, coords))
            {
                if (c == client)
                {
                    continue;
                }
                c.SendPacket(new AnimationPacket
                {
                    Animation = packet.Animation,
                    PlayerId  = p.EntityId
                });
            }
        }
    private void TransmitAnimationStates()
    {
        lastSentGroundState = lastGroundState;
        lastSentHangState   = lastHangState;

        using (PooledBitStream stream = PooledBitStream.Get()) {
            using (PooledBitWriter writer = PooledBitWriter.Get(stream)) {
                AnimationPacket.WritePacket(lastGroundState, lastHangState, writer);

                if (IsServer)
                {
                    InvokeClientRpcOnEveryoneExceptPerformance(ApplyAnimationState, OwnerClientId, stream, channel: ANIM_CHANNEL);
                }
                else
                {
                    InvokeServerRpcPerformance(SubmitAnimationState, stream, channel: ANIM_CHANNEL);
                }
            }
        }
    }
Esempio n. 10
0
        public static void doMyPlayerUpdates(byte id)
        {
            MovingStatePacket currMoving = new MovingStatePacket(id, Game1.player);

            if (prevMoving == null || prevMoving.flags != currMoving.flags)
            {
                sendFunc(currMoving);
            }
            prevMoving = currMoving;

            int currSingleAnim = (int)Util.GetInstanceField(typeof(FarmerSprite), Game1.player.FarmerSprite, "currentSingleAnimation");

            if (prevAnim != currSingleAnim || prevInterval != Game1.player.FarmerSprite.currentSingleAnimationInterval)
            {
                AnimationPacket anim = new AnimationPacket(id, Game1.player);
                if (anim.anim != -1 &&
                    anim.anim != FarmerSprite.walkLeft && anim.anim != FarmerSprite.walkDown &&
                    anim.anim != FarmerSprite.walkRight && anim.anim != FarmerSprite.walkUp &&
                    anim.anim != FarmerSprite.runLeft && anim.anim != FarmerSprite.runDown &&
                    anim.anim != FarmerSprite.runRight && anim.anim != FarmerSprite.runUp &&
                    anim.anim != FarmerSprite.carryWalkLeft && anim.anim != FarmerSprite.carryWalkDown &&
                    anim.anim != FarmerSprite.carryWalkRight && anim.anim != FarmerSprite.carryWalkUp &&
                    anim.anim != FarmerSprite.carryRunLeft && anim.anim != FarmerSprite.carryRunDown &&
                    anim.anim != FarmerSprite.carryRunRight && anim.anim != FarmerSprite.carryRunUp &&
                    anim.anim != FarmerSprite.showHoldingEdible /*&& anim.anim != FarmerSprite.eat*/)
                {
                    sendFunc(anim);
                }
            }
            prevAnim     = currSingleAnim;
            prevInterval = Game1.player.FarmerSprite.currentSingleAnimationInterval;

            if (prevActive != Game1.player.ActiveObject || prevTool != Game1.player.CurrentToolIndex)
            {
                HeldItemPacket held = new HeldItemPacket(id, Game1.player);
                sendFunc(held);
            }
            prevActive = Game1.player.ActiveObject;
            prevTool   = Game1.player.CurrentToolIndex;

            CoopUpdatePacket currCoopState = new CoopUpdatePacket();

            if (prevCoopState == null)
            {
                prevCoopState = currCoopState;
            }
            if (!prevCoopState.Equals(currCoopState))
            {
                sendFunc(currCoopState);
            }
            prevCoopState = currCoopState;

            if (Game1.player.dancePartner != null && !hadDancePartner)
            {
                sendFunc(new FestivalDancePartnerPacket(( byte )(mode == Mode.Host ? 0 : client.id), Game1.player.dancePartner.name));
                hadDancePartner = true;
            }

            if (Game1.player.spouse != prevSpouse)
            {
                sendFunc(new SpousePacket((byte)(mode == Mode.Host ? 0 : client.id), prevSpouse));
            }
            prevSpouse = Game1.player.spouse;
        }
Esempio n. 11
0
        /// <summary>
        /// Gets a packet from the server and returns it.
        /// </summary>
        /// <returns>The received packet.</returns>
        public Packet GetPacket()
        {
            var packetID = (byte)_stream.ReadByte();

            //_log.Debug("Got packet ID: " + packetID); // Spammy debug message
            if (!Enum.IsDefined(typeof(PacketType), (int)packetID))
            {
                return(null);
            }
            var    type = (PacketType)packetID;
            Packet pack = null;

            switch (type)
            {
            case PacketType.KeepAlive:
                pack = new KeepAlivePacket(_tools.ReadInt32());
                break;

            case PacketType.LoginRequest:
                pack = new LoginRequestPacketSC
                {
                    EntityID    = _tools.ReadInt32(),
                    NotUsed     = _tools.ReadString(),
                    LevelType   = _tools.ReadString(),
                    Gamemode    = _tools.ReadInt32(),
                    Dimension   = _tools.ReadInt32(),
                    Difficulty  = _tools.ReadSignedByte(),
                    WorldHeight = _tools.ReadByte(),                             // Not Used
                    MaxPlayers  = _tools.ReadByte()
                };
                break;

            case PacketType.Handshake:
                pack = new HandshakePacketSC(_tools.ReadString());
                break;

            case PacketType.ChatMessage:
                pack = new ChatMessagePacket(_tools.ReadString());
                break;

            case PacketType.TimeUpdate:
                pack = new TimeUpdatePacket(_tools.ReadInt32());
                break;

            case PacketType.EntityEquipment:
                pack = new EntityEquipmentPacket(_tools.ReadInt32(), _tools.ReadInt16(), _tools.ReadInt16(), _tools.ReadInt16());
                break;

            case PacketType.SpawnPosition:
                pack = new SpawnPositionPacket(_tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadInt32());
                break;

            case PacketType.UseEntity:
                pack = new UseEntityPacket(_tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadBoolean());
                break;

            case PacketType.UpdateHealth:
                pack = new UpdateHealthPacket(_tools.ReadInt16(), _tools.ReadInt16(), _tools.ReadSingle());
                break;

            case PacketType.Respawn:
                pack = new RespawnPacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                         _tools.ReadInt16(), _tools.ReadString());
                break;

            case PacketType.Player:
                pack = new PlayerPacket(_tools.ReadBoolean());
                break;

            case PacketType.PlayerPosition:
                pack = new PlayerPositionPacket(_tools.ReadDouble(), _tools.ReadDouble(), _tools.ReadDouble(), _tools.ReadDouble(),
                                                _tools.ReadBoolean());
                break;

            case PacketType.PlayerLook:
                pack = new PlayerLookPacket(_tools.ReadSingle(), _tools.ReadSingle(), _tools.ReadBoolean());
                break;

            case PacketType.PlayerPositionAndLook:
                pack = new PlayerPositionAndLookPacket(_tools.ReadDouble(), _tools.ReadDouble(), _tools.ReadDouble(),
                                                       _tools.ReadDouble(), _tools.ReadSingle(), _tools.ReadSingle(),
                                                       _tools.ReadBoolean());
                break;

            case PacketType.PlayerDigging:
                pack = new PlayerDiggingPacket(_tools.ReadSignedByte(), _tools.ReadInt32(), _tools.ReadSignedByte(),
                                               _tools.ReadInt32(), _tools.ReadSignedByte());
                break;

            case PacketType.PlayerBlockPlacement:
                pack = new PlayerBlockPlacementPacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadInt32(),
                                                      _tools.ReadSignedByte(), _tools.ReadSlotData());
                break;

            case PacketType.UseBed:
                pack = new UseBedPacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadInt32(), _tools.ReadSignedByte(),
                                        _tools.ReadInt32());
                break;

            case PacketType.Animation:
                pack = new AnimationPacket(_tools.ReadInt32(), _tools.ReadSignedByte());
                break;

            case PacketType.NamedEntitySpawn:
                pack = new NamedEntitySpawnPacket(_tools.ReadInt32(), _tools.ReadString(), _tools.ReadInt32(), _tools.ReadInt32(),
                                                  _tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                                  _tools.ReadInt16());
                break;

            case PacketType.PickupSpawn:
                pack = new PickupSpawnPacket(_tools.ReadInt32(), _tools.ReadInt16(), _tools.ReadSignedByte(), _tools.ReadInt16(),
                                             _tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadSignedByte(),
                                             _tools.ReadSignedByte(), _tools.ReadSignedByte());
                break;

            case PacketType.CollectItem:
                pack = new CollectItemPacket(_tools.ReadInt32(), _tools.ReadInt32());
                break;

            case PacketType.AddObjectVehicle:
                pack = new AddObjectVehiclePacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadInt32(),
                                                  _tools.ReadInt32(), _tools.ReadInt32());
                var ftEid = _tools.ReadInt32(); ((AddObjectVehiclePacket)pack).FireballThrowerID = ftEid;
                if (ftEid > 0)
                {
                    var aovpPack = (AddObjectVehiclePacket)pack;
                    aovpPack.SpeedX = _tools.ReadInt16();
                    aovpPack.SpeedY = _tools.ReadInt16();
                    aovpPack.SpeedZ = _tools.ReadInt16();
                    pack            = aovpPack;
                }
                break;

            case PacketType.HoldingChange:
                pack = new HoldingChangePacket(_tools.ReadInt16());
                break;

            case PacketType.MobSpawn:
                pack = new MobSpawnPacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadInt32(), _tools.ReadInt32(),
                                          _tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                          _tools.ReadSignedByte(), _tools.ReadEntityMetadata());
                break;

            case PacketType.EntityPainting:
                pack = new EntityPaintingPacket(_tools.ReadInt32(), _tools.ReadString(), _tools.ReadInt32(),
                                                _tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadInt32());
                break;

            case PacketType.ExperienceOrb:
                pack = new ExperienceOrbPacket(_tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadInt32(),
                                               _tools.ReadInt32(), _tools.ReadInt16());
                break;

            case PacketType.EntityVelocity:
                pack = new EntityVelocityPacket(_tools.ReadInt32(), _tools.ReadInt16(), _tools.ReadInt16(), _tools.ReadInt16());
                break;

            case PacketType.DestroyEntity:
                pack = new DestroyEntityPacket(_tools.ReadInt32());
                break;

            case PacketType.Entity:
                pack = new EntityPacket(_tools.ReadInt32());
                break;

            case PacketType.EntityRelativeMove:
                pack = new EntityRelativeMovePacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                                    _tools.ReadSignedByte());
                break;

            case PacketType.EntityLook:
                pack = new EntityLookPacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte());
                break;

            case PacketType.EntityLookAndRelativeMove:
                pack = new EntityLookAndRelativeMovePacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                                           _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                                           _tools.ReadSignedByte());
                break;

            case PacketType.EntityTeleport:
                pack = new EntityTeleportPacket(_tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadInt32(),
                                                _tools.ReadSignedByte(), _tools.ReadSignedByte());
                break;

            case PacketType.EntityHeadLook:
                pack = new EntityHeadLookPacket(_tools.ReadInt32(), _tools.ReadSignedByte());
                break;

            case PacketType.EntityStatus:
                pack = new EntityStatusPacket(_tools.ReadInt32(), _tools.ReadSignedByte());
                break;

            case PacketType.AttachEntity:
                pack = new AttachEntityPacket(_tools.ReadInt32(), _tools.ReadInt32());
                break;

            case PacketType.EntityMetadata:
                var entityMetadataPacket = new EntityMetadataPacket(_tools.ReadInt32());

                var metaData = new List <sbyte>();
                var b        = true;
                while (b)
                {
                    var value = _tools.ReadSignedByte();
                    if (value == 127)
                    {
                        b = false;
                    }
                    metaData.Add(value);
                }
                entityMetadataPacket.Metadata = metaData.ToArray();

                break;

            case PacketType.EntityEffect:
                pack = new EntityEffectPacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                              _tools.ReadInt16());
                break;

            case PacketType.RemoveEntityEffect:
                pack = new RemoveEntityEffectPacket(_tools.ReadInt32(), _tools.ReadSignedByte());
                break;

            case PacketType.Experience:
                pack = new ExperiencePacket(_tools.ReadSingle(), _tools.ReadInt16(), _tools.ReadInt16());
                break;

            case PacketType.PreChunk:
                pack = new PreChunkPacket(_tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadBoolean());
                break;

            case PacketType.MapChunk:
                var mapChunkPacket = new MapChunkPacket(_tools.ReadInt32(), _tools.ReadInt16(), _tools.ReadInt32(),
                                                        _tools.ReadSignedByte(), _tools.ReadSignedByte(), _tools.ReadSignedByte());

                mapChunkPacket.CompressedSize = _tools.ReadInt32();
                mapChunkPacket.CompressedData = _tools.ReadSignedBytes(mapChunkPacket.CompressedSize);

                pack = mapChunkPacket;
                break;

            case PacketType.MultiBlockChange:
                var multiBlockChangePacket = new MultiBlockChangePacket(_tools.ReadInt32(), _tools.ReadInt32());

                var arraySize = _tools.ReadInt16();
                multiBlockChangePacket.ArraySize = arraySize;

                var coordinates = new short[arraySize, 3];
                for (short i = 0; i < arraySize; i++)
                {
                    coordinates[i, 0] = _tools.ReadInt16();
                    coordinates[i, 1] = _tools.ReadInt16();
                    coordinates[i, 2] = _tools.ReadInt16();
                }
                multiBlockChangePacket.Coordinates = coordinates;

                var types = new sbyte[arraySize];
                for (short i = 0; i < arraySize; i++)
                {
                    types[i] = _tools.ReadSignedByte();
                }
                multiBlockChangePacket.Types = types;

                var metadata = new sbyte[arraySize];
                for (short i = 0; i < arraySize; i++)
                {
                    metadata[i] = _tools.ReadSignedByte();
                }
                multiBlockChangePacket.Metadata = metadata;

                pack = multiBlockChangePacket;
                break;

            case PacketType.BlockChange:
                pack = new BlockChangePacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadInt32(),
                                             _tools.ReadSignedByte(), _tools.ReadSignedByte());
                break;

            case PacketType.BlockAction:
                pack = new BlockActionPacket(_tools.ReadInt32(), _tools.ReadInt16(), _tools.ReadInt32(), _tools.ReadSignedByte(),
                                             _tools.ReadSignedByte());
                break;

            case PacketType.Explosion:
                var explosionPacket = new ExplosionPacket(_tools.ReadDouble(), _tools.ReadDouble(), _tools.ReadDouble(), _tools.ReadSingle());

                var recordCount = _tools.ReadInt32();
                explosionPacket.Count = recordCount;

                var records = new sbyte[recordCount, 3];
                for (var i = 0; i < recordCount; i++)
                {
                    records[i, 0] = _tools.ReadSignedByte();
                    records[i, 1] = _tools.ReadSignedByte();
                    records[i, 2] = _tools.ReadSignedByte();
                }
                explosionPacket.Records = records;

                pack = explosionPacket;
                break;

            case PacketType.SoundParticleEffect:
                pack = new SoundParticleEffectPacket(_tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadSignedByte(),
                                                     _tools.ReadInt32(), _tools.ReadInt32());
                break;

            case PacketType.NewInvalidState:
                pack = new NewInvalidStatePacket(_tools.ReadSignedByte(), _tools.ReadSignedByte());
                break;

            case PacketType.Thunderbolt:
                pack = new ThunderboltPacket(_tools.ReadInt32(), _tools.ReadBoolean(), _tools.ReadInt32(), _tools.ReadInt32(),
                                             _tools.ReadInt32());
                break;

            case PacketType.OpenWindow:
                pack = new OpenWindowPacket(_tools.ReadSignedByte(), _tools.ReadSignedByte(), _tools.ReadString(),
                                            _tools.ReadSignedByte());
                break;

            case PacketType.CloseWindow:
                pack = new CloseWindowPacket(_tools.ReadSignedByte());
                break;

            case PacketType.SetSlot:
                pack = new SetSlotPacket(_tools.ReadSignedByte(), _tools.ReadInt16(), _tools.ReadSlotData());
                break;

            case PacketType.WindowItems:
                var windowItemsPacket = new WindowItemsPacket(_tools.ReadSignedByte());

                var count = _tools.ReadInt16();
                windowItemsPacket.Count = count;

                var slotData = new SlotData[count];
                for (short i = 0; i < count; i++)
                {
                    slotData[i] = _tools.ReadSlotData();
                }
                windowItemsPacket.SlotData = slotData;

                pack = windowItemsPacket;
                break;

            case PacketType.UpdateWindowProperty:
                pack = new UpdateWindowPropertyPacket(_tools.ReadSignedByte(), _tools.ReadInt16(), _tools.ReadInt16());
                break;

            case PacketType.Transaction:
                pack = new TransactionPacket(_tools.ReadSignedByte(), _tools.ReadInt16(), _tools.ReadBoolean());
                break;

            case PacketType.CreativeInventoryAction:
                pack = new CreativeInventoryActionPacket(_tools.ReadInt16(), _tools.ReadSlotData());
                break;

            case PacketType.UpdateSign:
                pack = new UpdateSignPacket(_tools.ReadInt32(), _tools.ReadInt16(), _tools.ReadInt32(), _tools.ReadString(),
                                            _tools.ReadString(), _tools.ReadString(), _tools.ReadString());
                break;

            case PacketType.ItemData:
                pack = new ItemDataPacket(_tools.ReadInt16(), _tools.ReadInt16());

                byte len = _tools.ReadByte();
                ((ItemDataPacket)pack).Length = len;
                ((ItemDataPacket)pack).Text   = _tools.ReadSignedBytes(len);

                break;

            case PacketType.IncrementStatistic:
                pack = new IncrementStatisticPacket(_tools.ReadInt32(), _tools.ReadSignedByte());
                break;

            case PacketType.PlayerListItem:
                pack = new PlayerListItemPacket(_tools.ReadString(), _tools.ReadBoolean(), _tools.ReadInt16());
                break;

            case PacketType.PluginMessage:
                pack = new PluginMessagePacket(_tools.ReadString());
                var length = _tools.ReadInt16(); ((PluginMessagePacket)pack).Length = length;
                ((PluginMessagePacket)pack).Data = _tools.ReadSignedBytes(length);
                break;

            case PacketType.DisconnectKick:
                pack = new DisconnectKickPacket(_tools.ReadString());
                break;
            }

            return(pack);
        }
Esempio n. 12
0
        public static void ReadAnimation(TestClient client, PacketReader reader)
        {
            AnimationPacket ap = new AnimationPacket();

            ap.Read(reader);
        }