Exemple #1
0
 public override void OnTeleportTo(AbsWorldCoords absCoords)
 {
     foreach (Client c in Server.GetNearbyPlayers(World, absCoords))
     {
         if (!Equals(this))
             c.SendTeleportTo(this);
         else
         {
             c.SendPacket(new PlayerPositionRotationPacket
             {
                 X = absCoords.X,
                 Y = absCoords.Y + Player.EyeGroundOffset,
                 Z = absCoords.Z,
                 Yaw = (float)Position.Yaw,
                 Pitch = (float)Position.Pitch,
                 Stance = c.Stance,
                 OnGround = false
             }
             );
         }
     }
 }
Exemple #2
0
 public void InitializePosition()
 {
     World = Server.GetDefaultWorld();
     Position = new AbsWorldCoords(
         World.Spawn.WorldX,
         World.Spawn.WorldY + this.EyeHeight,
         World.Spawn.WorldZ);
 }
Exemple #3
0
        // TODO: This should be removed in favor of the one below
        /// <summary>
        /// Sends a packet in parallel to each nearby player.
        /// </summary>
        /// <param name="world">The world containing the coordinates.</param>
        /// <param name="absCoords>The center coordinates.</param>
        /// <param name="packet">The packet to send</param>
        public void SendPacketToNearbyPlayers(WorldManager world, AbsWorldCoords absCoords, Packet packet)
        {
            Client[] nearbyClients = GetNearbyPlayers(world, absCoords).ToArray();

            if (nearbyClients.Length == 0)
                return;

            packet.SetShared(Logger, nearbyClients.Length);
            Parallel.ForEach(nearbyClients, (client) =>
            {
                client.SendPacket(packet);
            });
        }
Exemple #4
0
 public Player GetClosestPlayer(AbsWorldCoords coords, double radius)
 {
     var radiusSqrd = radius * radius;
     Vector3 coordVector = coords.ToVector();
     return (from c in Server.GetAuthenticatedClients().Where(client => client.Owner.World == this)
             let distance = coordVector.DistanceSquared(c.Owner.Position.ToVector())
             where distance <= radiusSqrd
             orderby distance
             select c.Owner).FirstOrDefault();
 }
Exemple #5
0
 public Player GetClosestPlayer(AbsWorldCoords coords, double radius)
 {
     Vector3 coordVector = coords.ToVector();
     return (from c in Server.GetAuthenticatedClients().Where(client => client.Owner.World == this)
             let distanceVector = coordVector - c.Owner.Position.ToVector()
             where distanceVector.X <= radius && distanceVector.Y <= radius && distanceVector.Z <= radius
             orderby distanceVector
             select c.Owner).FirstOrDefault();
 }
Exemple #6
0
        public IEnumerable<EntityBase> GetNearbyLivings(WorldManager world, AbsWorldCoords coords)
        {
            int radius = Settings.Default.SightRadius << 4;
            foreach (EntityBase entity in GetEntities())
            {
                if (!(entity is LivingEntity))
                    continue;

                if (entity.World == world && Math.Abs(coords.X - entity.Position.X) <= radius && Math.Abs(coords.Y - entity.Position.Y) <= radius && Math.Abs(coords.Z - entity.Position.Z) <= radius)
                    yield return (entity as LivingEntity);
            }
        }
Exemple #7
0
        public void GlobalTimer(object state)
        {
            int time = Interlocked.Increment(ref _time);

            if(time % 5 == 0)
            {
                Random randGen = new Random();
                double randX = 0.05 + randGen.NextDouble()*0.1;
                double randZ = 0.05 + randGen.NextDouble() * 0.1;

                Position = new AbsWorldCoords(Position.X + randX, Position.Y, Position.Z + randZ);

                SendPacket(new PlayerPacket{OnGround = true});
                SendPacket(new PlayerPositionPacket{OnGround = true, X = Position.X, Y = Position.Y, Z = Position.Z});
            }
        }
Exemple #8
0
        public override void OnTeleportTo(AbsWorldCoords absCoords)
        {
            base.OnTeleportTo(absCoords);

            Client.StopUpdateChunks();

            UpdateChunks(1, CancellationToken.None, true, false);

            Client.SendPacket(new PlayerPositionRotationPacket
                                  {
                                      X = absCoords.X,
                                      Y = absCoords.Y + EyeHeight,
                                      Z = absCoords.Z,
                                      Yaw = (float)Yaw,
                                      Pitch = (float)Pitch,
                                      Stance = Client.Stance,
                                      OnGround = false
                                  });

            UpdateEntities();
            Server.SendEntityToNearbyPlayers(World, this);
            Client.ScheduleUpdateChunks();
        }
Exemple #9
0
        private static void DoSpawn(WorldManager world, HashSet<int> chunksToSpawnIn, Mob[] mobEntities, List<WeightedValue<MobType>> mobGroup, int maximumMobs, bool inWater = false)
        {
            // Based on original server spawn logic and minecraft wiki (http://www.minecraftwiki.net/wiki/Spawn)

            // Check that we haven't already reached the maximum number of this type of mob
            if (mobGroup.Count > 0 && (mobEntities.Where(e => mobGroup.Where(mob => mob.Value == e.Type).Any()).Count() <= maximumMobs * chunksToSpawnIn.Count / 256))
            {
                foreach (var packedChunk in chunksToSpawnIn)
                {
                    MobType mobType = mobGroup.SelectRandom(world.Server.Rand);
                    UniversalCoords packSpawnPosition = GetRandomPointInChunk(world, UniversalCoords.FromPackedChunkToX(packedChunk), UniversalCoords.FromPackedChunkToZ(packedChunk));

                    byte? blockId = world.GetBlockId(packSpawnPosition);

                    if (blockId == null)
                        continue;

                    BlockBase blockClass = BlockHelper.Instance((byte)blockId);

                    if (!blockClass.IsOpaque && ((!inWater && blockClass.Type == BlockData.Blocks.Air) || (inWater && blockClass.IsLiquid))) // Lava is Opaque, so IsLiquid is safe to use here for water & still water
                    {
                        int spawnedCount = 0;
                        int x = packSpawnPosition.WorldX;
                        int y = packSpawnPosition.WorldY;
                        int z = packSpawnPosition.WorldZ;

                        for (int i = 0; i < 21; i++)
                        {
                            // Every 4th attempt reset the coordinates to the centre of the pack spawn
                            if (i % 4 == 0)
                            {
                                x = packSpawnPosition.WorldX;
                                y = packSpawnPosition.WorldY;
                                z = packSpawnPosition.WorldZ;
                            }

                            const int distance = 6;

                            x += world.Server.Rand.Next(distance) - world.Server.Rand.Next(distance);
                            y += world.Server.Rand.Next(1) - world.Server.Rand.Next(1);
                            z += world.Server.Rand.Next(distance) - world.Server.Rand.Next(distance);

                            if (CanMobTypeSpawnAtLocation(mobType, world, x, y, z))
                            {
                                AbsWorldCoords spawnPosition = new AbsWorldCoords(x + 0.5, y, z + 0.5);

                                // Check that no player is within a radius of 24 blocks of the spawnPosition
                                if (world.GetClosestPlayer(spawnPosition, 24.0) == null)
                                {
                                    // Check that the squared distance is more than 576 from spawn (24 blocks)
                                    if (spawnPosition.ToVector().DistanceSquared(new AbsWorldCoords(world.Spawn).ToVector()) > 576.0)
                                    {
                                        Mob newMob = MobFactory.CreateMob(world, world.Server.AllocateEntity(),
                                                                          mobType);

                                        if (newMob == null)
                                            break;

                                        newMob.Position = spawnPosition;
                                        newMob.Yaw = world.Server.Rand.NextDouble()*360.0;
                                        // Finally apply any mob specific rules about spawning here
                                        if (newMob.CanSpawnHere())
                                        {
                                            //Event
                                            EntitySpawnEventArgs e = new EntitySpawnEventArgs(newMob, newMob.Position);
                                            world.Server.PluginManager.CallEvent(Plugins.Events.Event.EntitySpawn, e);
                                            if (e.EventCanceled)
                                                continue;
                                            newMob.Position = e.Location;
                                            //End Event

                                            ++spawnedCount;
                                            MobSpecificInitialisation(newMob, world, spawnPosition);
                                            world.Server.AddEntity(newMob);

                                            if (spawnedCount >= newMob.MaxSpawnedPerGroup)
                                            {
                                                // This chunk is full - move to the next
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Exemple #10
0
        private static void MobSpecificInitialisation(Mob mob, WorldManager world, AbsWorldCoords coords)
        {
            // 1 in 100 chance to spawn a skeleton riding a spider
            if (mob.Type == MobType.Spider && world.Server.Rand.Next(100) == 0)
            {
                LivingEntity skeleton = MobFactory.CreateMob(world, world.Server.AllocateEntity(), MobType.Skeleton);
                skeleton.Position = coords;
                skeleton.Yaw = mob.Yaw;

                world.Server.AddEntity(skeleton);
                skeleton.MountEntity(mob);
            }
        }
Exemple #11
0
 public BoundingBox(AbsWorldCoords minimum, AbsWorldCoords maximum)
     : this(minimum.ToVector(), maximum.ToVector())
 {
 }
Exemple #12
0
 public EntitySpawnEventArgs(EntityBase entity, AbsWorldCoords Location)
     : base(entity)
 {
     this.Location = Location;
 }
Exemple #13
0
 public EntityMoveEventArgs(EntityBase entity, AbsWorldCoords newPosition, AbsWorldCoords oldPosition)
     : base(entity)
 {
     NewPosition = newPosition;
     OldPosition = oldPosition;
 }
Exemple #14
0
 /// <summary>
 /// Move less than four blocks to the given destination.
 /// </summary>
 /// <param name="x">The X coordinate of the target.</param>
 /// <param name="y">The Y coordinate of the target.</param>
 /// <param name="z">The Z coordinate of the target.</param>
 public override void MoveTo(AbsWorldCoords absCoords)
 {
     base.MoveTo(absCoords);
     UpdateEntities();
 }
Exemple #15
0
 public static void HandlePacketAnimation(Client client, AnimationPacket packet)
 {
     Player p = client.Owner;
     AbsWorldCoords absCoords = new AbsWorldCoords(p.Position.X, p.Position.Y, p.Position.Z);
     foreach (Client c in p.Server.GetNearbyPlayers(p.World, absCoords))
     {
         if (c == client)
             continue;
         c.SendPacket(new AnimationPacket
         {
             Animation = packet.Animation,
             PlayerId = p.EntityId
         });
     }
 }
Exemple #16
0
 /// <summary>
 /// Move less than four blocks to the given destination and rotate.
 /// </summary>
 /// <param name="x">The X coordinate of the target.</param>
 /// <param name="y">The Y coordinate of the target.</param>
 /// <param name="z">The Z coordinate of the target.</param>
 /// <param name="yaw">The absolute yaw to which client should change.</param>
 /// <param name="pitch">The absolute pitch to which client should change.</param>
 public override void MoveTo(AbsWorldCoords absCoords, float yaw, float pitch)
 {
     base.MoveTo(absCoords, yaw, pitch);
     UpdateEntities();
 }
Exemple #17
0
        public static void HandlePacketPlayerPositionRotation(Client client, PlayerPositionRotationPacket packet)
        {
            double feetY = packet.Y - client.Owner.EyeHeight;
            if(client.WaitForInitialPosAck)
            {
                AbsWorldCoords coords = new AbsWorldCoords(packet.X, feetY, packet.Z);
                if(coords == client.Owner.LoginPosition)
                {
                    client.WaitForInitialPosAck = false;
                    client.SendSecondLoginSequence();
                }
            }
            else
            {
                double threshold = 0.001;
                double diffX = Math.Abs(client.Owner.Position.X - packet.X);
                double diffY = Math.Abs(client.Owner.Position.Y - feetY);
                double diffZ = Math.Abs(client.Owner.Position.Z - packet.Z);
                if (diffX < threshold && diffY < threshold && diffZ < threshold)
                    return;

                client.Owner.MoveTo(new AbsWorldCoords(packet.X, feetY, packet.Z), packet.Yaw, packet.Pitch);
                client.OnGround = packet.OnGround;
                client.Stance = packet.Stance;

                client.CheckAndUpdateChunks(packet.X, packet.Z);
            }
        }
Exemple #18
0
        public void SynchronizeEntities()
        {
            AbsWorldCoords absCoords = new AbsWorldCoords(Position.X, Position.Y, Position.Z);
            foreach (EntityBase e in Server.GetNearbyEntities(World, absCoords))
            {
                if (e.Equals(this))
                    continue;

                _client.SendPacket(new EntityTeleportPacket
                {
                    EntityId = e.EntityId,
                    X = e.Position.X,
                    Y = e.Position.Y,
                    Z = e.Position.Z,
                    Yaw = e.PackedYaw,
                    Pitch = e.PackedPitch
                });
            }
        }
Exemple #19
0
        public static void HandlePacketUseEntity(Client client, UseEntityPacket packet)
        {
            //Console.WriteLine(e.Packet.Target);
            //this.SendMessage("You are interacting with " + e.Packet.Target + " " + e.Packet.LeftClick);
            Player handledPlayer = client.Owner;
            AbsWorldCoords absCoords = new AbsWorldCoords(handledPlayer.Position.X, handledPlayer.Position.Y, handledPlayer.Position.Z);
            foreach (EntityBase eb in handledPlayer.Server.GetNearbyEntities(handledPlayer.World, absCoords))
            {
                if (eb.EntityId != packet.Target)
                    continue;

                if (eb is Player)
                {
                    Player player = (Player)eb;

                    if (packet.LeftClick)
                    {
                        handledPlayer.Attack(player);
                    }
                    else
                    {
                        // TODO: Store the object being ridden, so we can update player movement.
                        // This will ride the entity, sends -1 to dismount.
                        foreach (Client cl in handledPlayer.Server.GetNearbyPlayers(handledPlayer.World, absCoords))
                        {
                            cl.SendPacket(new AttachEntityPacket
                            {
                                EntityId = handledPlayer.EntityId,
                                VehicleId = player.EntityId
                            });
                        }
                    }
                }
                else if (eb is Mob)
                {
                    Mob m = (Mob)eb;

                    if (packet.LeftClick)
                    {
                        handledPlayer.Attack(m);
                    }
                    else
                    {
                        // We are interacting with a Mob - tell it what we are using to interact with it
                        m.InteractWith(handledPlayer.Client, handledPlayer.Inventory.ActiveItem);

                        // TODO: move the following to appropriate mob locations
                        // TODO: Check Entity has saddle set.
                        //// This will ride the entity, sends -1 to dismount.
                        //foreach (Client c in Server.GetNearbyPlayers(World, Position.X, Position.Y, Position.Z))
                        //{
                        //    c.PacketHandler.SendPacket(new AttachEntityPacket
                        //    {
                        //        EntityId = this.EntityId,
                        //        VehicleId = c.EntityId
                        //    });
                        //}
                    }
                }
                /*else
                {
                    this.SendMessage(e.Packet.Target + " has no interaction handler!");
                }*/
            }
        }
Exemple #20
0
 /// <summary>
 /// Yields an enumerable of nearby entities, including players.  Thread-safe.
 /// </summary>
 /// <param name="world">The world containing the coordinates.</param>
 /// <param name="x">The center X coordinate.</param>
 /// <param name="y">The center Y coordinate.</param>
 /// <param name="z">The center Z coordinate.</param>
 /// <returns>A lazy enumerable of nearby entities.</returns>
 public IEnumerable<EntityBase> GetNearbyEntities(WorldManager world, AbsWorldCoords coords)
 {
     int radius = Settings.Default.SightRadius << 4;
     foreach (EntityBase e in GetEntities())
     {
         if (e.World == world && Math.Abs(coords.X - e.Position.X) <= radius && Math.Abs(coords.Y - e.Position.Y) <= radius && Math.Abs(coords.Z - e.Position.Z) <= radius)
             yield return e;
     }
 }
Exemple #21
0
        public void GlobalTimer(object state)
        {
            int time = Interlocked.Increment(ref _time);

            if (!WaitInitialPositionRequest && (time % 5) == 0)
            {
                int factor = 1;
                double rand1;
                double rand2;

                if ((rand1 = _rand.NextDouble()) > (rand2 = _rand.NextDouble()))
                    factor = -1;

                double randX = (0.1 + rand1 * 0.2) * factor;
                double randZ = (0.1 + rand2 * 0.2) * factor;

                Position = new AbsWorldCoords(Position.X + randX, Position.Y, Position.Z + randZ);

                SendPacket(new PlayerPacket{OnGround = true});
                SendPacket(new PlayerPositionPacket{OnGround = true, X = Position.X, Y = Position.Y, Z = Position.Z});
            }

            if((time % 50) == 0)
            {
                SendPacket(new KeepAlivePacket{KeepAliveID = 1});
            }
        }
Exemple #22
0
 // TODO: This should be removed in favor of the one below
 /// <summary>
 /// Yields an enumerable of nearby players, thread-safe.
 /// </summary>
 /// <param name="world">The world containing the coordinates.</param>
 /// <param name="absCoords">The center coordinates.</param>
 /// <returns>A lazy enumerable of nearby players.</returns>
 public IEnumerable<Client> GetNearbyPlayers(WorldManager world, AbsWorldCoords absCoords)
 {
     int radius = Settings.Default.SightRadius << 4;
     foreach (Client c in GetAuthenticatedClients())
     {
         if (c.Owner.World == world && Math.Abs(absCoords.X - c.Owner.Position.X) <= radius && Math.Abs(absCoords.Z - c.Owner.Position.Z) <= radius)
             yield return c;
     }
 }
Exemple #23
0
 public override void OnTeleportTo(AbsWorldCoords absCoords)
 {
     base.OnTeleportTo(absCoords);
     CheckDrowning();
     CheckSuffocation();
     TouchNearbyBlocks();
 }
Exemple #24
0
 public static UniversalCoords FromAbsWorld(AbsWorldCoords absWorldCoords)
 {
     return FromAbsWorld(absWorldCoords.X, absWorldCoords.Y, absWorldCoords.Z);
 }
Exemple #25
0
        /// <summary>
        /// Handles the respawning of the Client, called from respawn packet.
        /// </summary>
        public void HandleRespawn()
        {
            // This can no doubt be improved as waiting on the updatechunk thread is quite slow.
            Server.RemoveEntity(this);

            Position = new AbsWorldCoords(
                World.Spawn.WorldX,
                World.Spawn.WorldY + this.EyeHeight,
                World.Spawn.WorldZ);

            _client.StopUpdateChunks();
            UpdateChunks(1, CancellationToken.None, false);
            _client.SendPacket(new RespawnPacket { });
            UpdateEntities();
            //SendSpawnPosition();
            _client.SendInitialPosition();
            _client.SendInitialTime();
            InitializeInventory();
            InitializeHealth();
            _client.ScheduleUpdateChunks();

            Server.AddEntity(this);
        }
Exemple #26
0
        /// <summary>
        /// Ray traces the blocks along the ray. This method takes approx 0.1ms per 50-60 metres.
        /// </summary>
        /// <returns>
        /// The first block hit
        /// </returns>
        /// <param name='rayStart'>
        /// Ray start.
        /// </param>
        /// <param name='rayEnd'>
        /// Ray end.
        /// </param>
        public RayTraceHitBlock RayTraceBlocks(AbsWorldCoords rayStart, AbsWorldCoords rayEnd)
        {
            UniversalCoords startCoord = UniversalCoords.FromAbsWorld(rayStart);
            UniversalCoords endCoord = UniversalCoords.FromAbsWorld(rayEnd);

            UniversalCoords previousPoint;
            UniversalCoords currentPoint = startCoord;

            Vector3 rayStartVec = rayStart.ToVector();
            Vector3 rayEndVec = rayEnd.ToVector();

            Vector3 stepVector = (rayEndVec - rayStartVec).Normalize();

            bool xDirectionPositive = stepVector.X > 0;
            bool yDirectionPositive = stepVector.Y > 0;
            bool zDirectionPositive = stepVector.Z > 0;

            Vector3 currentVec = rayStartVec;
            previousPoint = currentPoint;

            RayTraceHitBlock blockTrace = null;
            int blockCheckCount = 0;
            try
            {
                // Step along the ray looking for block collisions
                while (true)
                {
                    #region Check adjacent blocks if necessary (to prevent skipping over the corner of one)
                    bool xChanged = currentPoint.WorldX - previousPoint.WorldX != 0;
                    bool yChanged = currentPoint.WorldY - previousPoint.WorldY != 0;
                    bool zChanged = currentPoint.WorldZ - previousPoint.WorldZ != 0;

                    // When we change a coord, need to check which adjacent block also needs to be checked (to prevent missing blocks when jumping over their corners)
                    if (xChanged && yChanged && zChanged)
                    {
                        // -X,Y,Z
                        blockCheckCount++;
                        blockTrace = DoRayTraceBlock(UniversalCoords.FromWorld(previousPoint.WorldX, currentPoint.WorldY, currentPoint.WorldZ), rayStartVec, rayEndVec);
                        if (blockTrace != null)
                            return blockTrace;
                        // X,-Y,Z
                        blockCheckCount++;
                        blockTrace = DoRayTraceBlock(UniversalCoords.FromWorld(currentPoint.WorldX, previousPoint.WorldY, currentPoint.WorldZ), rayStartVec, rayEndVec);
                        if (blockTrace != null)
                            return blockTrace;
                        // X,Y,-Z
                        blockCheckCount++;
                        blockTrace = DoRayTraceBlock(UniversalCoords.FromWorld(currentPoint.WorldX, currentPoint.WorldY, previousPoint.WorldZ), rayStartVec, rayEndVec);
                        if (blockTrace != null)
                            return blockTrace;

                        // -X,Y,-Z
                        blockCheckCount++;
                        blockTrace = DoRayTraceBlock(UniversalCoords.FromWorld(previousPoint.WorldX, currentPoint.WorldY, previousPoint.WorldZ), rayStartVec, rayEndVec);
                        if (blockTrace != null)
                            return blockTrace;
                        // -X,-Y,Z
                        blockCheckCount++;
                        blockTrace = DoRayTraceBlock(UniversalCoords.FromWorld(previousPoint.WorldX, previousPoint.WorldY, currentPoint.WorldZ), rayStartVec, rayEndVec);
                        if (blockTrace != null)
                            return blockTrace;
                        // X,-Y,-Z
                        blockCheckCount++;
                        blockTrace = DoRayTraceBlock(UniversalCoords.FromWorld(currentPoint.WorldX, previousPoint.WorldY, previousPoint.WorldZ), rayStartVec, rayEndVec);
                        if (blockTrace != null)
                            return blockTrace;
                    }
                    else if (xChanged && zChanged)
                    {
                        // -X,Y,Z
                        blockCheckCount++;
                        blockTrace = DoRayTraceBlock(UniversalCoords.FromWorld(previousPoint.WorldX, currentPoint.WorldY, currentPoint.WorldZ), rayStartVec, rayEndVec);
                        if (blockTrace != null)
                            return blockTrace;
                        // X,Y,-Z
                        blockCheckCount++;
                        blockTrace = DoRayTraceBlock(UniversalCoords.FromWorld(currentPoint.WorldX, currentPoint.WorldY, previousPoint.WorldZ), rayStartVec, rayEndVec);
                        if (blockTrace != null)
                            return blockTrace;
                    }
                    else if (xChanged && yChanged)
                    {
                        // -X,Y,Z
                        blockCheckCount++;
                        blockTrace = DoRayTraceBlock(UniversalCoords.FromWorld(previousPoint.WorldX, currentPoint.WorldY, currentPoint.WorldZ), rayStartVec, rayEndVec);
                        if (blockTrace != null)
                            return blockTrace;
                        // X,-Y,Z
                        blockCheckCount++;
                        blockTrace = DoRayTraceBlock(UniversalCoords.FromWorld(currentPoint.WorldX, previousPoint.WorldY, currentPoint.WorldZ), rayStartVec, rayEndVec);
                        if (blockTrace != null)
                            return blockTrace;
                    }
                    else if (zChanged && yChanged)
                    {
                        // X,Y,-Z
                        blockCheckCount++;
                        blockTrace = DoRayTraceBlock(UniversalCoords.FromWorld(currentPoint.WorldX, currentPoint.WorldY, previousPoint.WorldZ), rayStartVec, rayEndVec);
                        if (blockTrace != null)
                            return blockTrace;
                        // X,-Y,Z
                        blockCheckCount++;
                        blockTrace = DoRayTraceBlock(UniversalCoords.FromWorld(currentPoint.WorldX, previousPoint.WorldY, currentPoint.WorldZ), rayStartVec, rayEndVec);
                        if (blockTrace != null)
                            return blockTrace;
                    }
                    #endregion

                    // Check the currentPoint
                    blockCheckCount++;
                    blockTrace = DoRayTraceBlock(currentPoint, rayStartVec, rayEndVec);
                    if (blockTrace != null)
                        return blockTrace;

                    if (currentPoint == endCoord)
                    {
                        //Console.WriteLine("Reach endCoord with no hits");
                        break;
                    }

                    #region Get the next coordinate
                    previousPoint = currentPoint;
                    do
                    {
                        currentVec += stepVector;
                        currentPoint = UniversalCoords.FromAbsWorld(currentVec.X, currentVec.Y, currentVec.Z);
                    } while(previousPoint == currentPoint);

                    // check we haven't gone past the endCoord
                    if ((xDirectionPositive && currentPoint.WorldX > endCoord.WorldX) || (!xDirectionPositive && currentPoint.WorldX < endCoord.WorldX) ||
                        (yDirectionPositive && currentPoint.WorldY > endCoord.WorldY) || (!yDirectionPositive && currentPoint.WorldY < endCoord.WorldY) ||
                        (zDirectionPositive && currentPoint.WorldZ > endCoord.WorldZ) || (!zDirectionPositive && currentPoint.WorldZ < endCoord.WorldZ))
                    {
                        //Console.WriteLine("Went past endCoord: {0}, {1}", startCoord, endCoord);
                        break;
                    }
                    #endregion
                }
            }
            finally
            {
                //Console.WriteLine("Block check count {0}", blockCheckCount);
            }
            return null;
        }
Exemple #27
0
 /// <summary>
 /// Sends a packet in parallel to each nearby player.
 /// </summary>
 /// <param name="world">The world containing the coordinates.</param>
 /// <param name="absCoords>The center coordinates.</param>
 /// <param name="packet">The packet to send</param>
 public void SendPacketToNearbyPlayers(WorldManager world, AbsWorldCoords absCoords, Packet packet)
 {
     Parallel.ForEach(this.GetNearbyPlayers(world, absCoords), (client) =>
     {
         client.SendPacket(packet);
     });
 }