public void HandleCollision(IPlayer link, IBlock block, Constants.Direction side) { if (link.State.GetType() == typeof(LinkPickingUpItemState)) { return; } Vector2 correctDirection; switch (side) { case Constants.Direction.Up: correctDirection = new Vector2(0, -1); link.Move(linkMoveDistance, correctDirection); break; case Constants.Direction.Down: correctDirection = new Vector2(0, 1); link.Move(linkMoveDistance, correctDirection); break; case Constants.Direction.Left: correctDirection = new Vector2(-1, 0); link.Move(linkMoveDistance, correctDirection); break; case Constants.Direction.Right: correctDirection = new Vector2(1, 0); link.Move(linkMoveDistance, correctDirection); break; default: break; } }
private void UpdatePlayersPositions(Constants.Direction doorLocation) { foreach (IPlayer player in RoomGameState.PlayerList) { player.StopMoving(); switch (doorLocation) { case Constants.Direction.Right: player.Position = LinkConstants.DoorRightSpawnPosition; break; case Constants.Direction.Left: player.Position = LinkConstants.DoorLeftSpawnPosition; break; case Constants.Direction.Up: player.Position = LinkConstants.DoorUpSpawnPosition; break; case Constants.Direction.Down: player.Position = LinkConstants.DoorDownSpawnPosition; break; } } }
public BlockMovement(Constants.Direction direction, string door) { this.door = door; switch (direction) { case Constants.Direction.UP: motion = new Vector2(0, -1); break; case Constants.Direction.DOWN: motion = new Vector2(0, 1); break; case Constants.Direction.LEFT: motion = new Vector2(-1, 0); break; case Constants.Direction.RIGHT: motion = new Vector2(1, 0); break; default: motion = new Vector2(); break; } }
// Helper function that reverses current direction (used in EXTENDING -> RETRACTING transition) public void ReverseDirection() { // Console.WriteLine("Reversing direction."); if (state == State.RETRACTING) { state = State.EXTENDING; } else { state = State.RETRACTING; } switch (direction) { case Constants.Direction.UP: direction = Constants.Direction.DOWN; break; case Constants.Direction.RIGHT: direction = Constants.Direction.LEFT; break; case Constants.Direction.DOWN: direction = Constants.Direction.UP; break; case Constants.Direction.LEFT: direction = Constants.Direction.RIGHT; break; default: //Console.WriteLine("BladeTrapMovement: Unrecognized direction transition!"); break; } }
public LinkKnockback(Constants.Direction direction, float distance, int numFrames) { this.direction = direction; this.distance = distance; this.numFrames = numFrames; this.frame = 0; }
public void HandleCollision(INpc enemy, IBlock block, Constants.Direction side) { Vector2 correctDirection; enemy.SetKnockBack(false, Constants.Direction.None); switch (side) { case Constants.Direction.Up: correctDirection = new Vector2(Constants.EnemyNoMove, Constants.EnemyMoveUp); enemy.Move(correctDirection); break; case Constants.Direction.Down: correctDirection = new Vector2(Constants.EnemyNoMove, Constants.EnemyMoveDown); enemy.Move(correctDirection); break; case Constants.Direction.Left: correctDirection = new Vector2(Constants.EnemyMoveLeft, Constants.EnemyNoMove); enemy.Move(correctDirection); break; case Constants.Direction.Right: correctDirection = new Vector2(Constants.EnemyMoveRight, Constants.EnemyNoMove); enemy.Move(correctDirection); break; default: break; } }
public void HandleCollision(INpc enemy, IBlock block, Constants.Direction side) { if (CheckCollision(block.GetType())) { Vector2 direction = new Vector2(); switch (side) { case Constants.Direction.Up: direction = new Vector2(Constants.EnemyNoMove, Constants.EnemyMoveUp); break; case Constants.Direction.Down: direction = new Vector2(Constants.EnemyNoMove, Constants.EnemyMoveDown); break; case Constants.Direction.Right: direction = new Vector2(Constants.EnemyMoveRight, Constants.EnemyNoMove); break; case Constants.Direction.Left: direction = new Vector2(Constants.EnemyMoveLeft, Constants.EnemyNoMove); break; } ((Bat)enemy).ChooseDirection(); ((Bat)enemy).Move(direction); } }
public override void Enter(Actor owner, ActorAIController ownerAI) { base.Enter(owner, ownerAI); ownerAI.ChaseTarget = GameSystem.Instance.ActorManager.GetRandomPlayer(); this.currentDirection = this.GetTargetDirection(owner, ownerAI); this.GetObserver(owner) .SubscribeWithState3(this, owner, ownerAI, (_, _this, _owner, _ownerAI) => { _owner.StatusController.SetMoveSpeedRate(_this.moveSpeedRate); _owner.Broker.Publish(RequestMove.Get(_this.currentDirection.ToVector2())); if (_this.IsReverse(_owner, _ownerAI)) { _this.changeDirectionDuration += Time.deltaTime; } else { _this.changeDirectionDuration = 0.0f; } if (_this.changeDirectionDuration > _this.changeDirectionDelay) { _this.changeDirectionDuration = 0.0f; _this.currentDirection = _this.GetTargetDirection(_owner, _ownerAI); } }) .AddTo(this.events); }
public Boomerang(Constants.Direction direction, Entity entity) { var entityTransform = entity.GetComponent <Transform>(); GetComponent <Transform>().position = entityTransform.position; Constants.SetLayerDepth(this, Constants.LayerDepth.Item); Sprite s = new Sprite(EnemySpriteFactory.Instance.CreateGoriyaBoomerang()); AddComponent(s); s.SetAnimate(true); BehaviorScript b = new BoomerangMovement(entity, direction); AddComponent(b); var coll = new Collider(); coll.response = new BoomerangCollisionResponse(this, entity, 1); // Half a heart of damage, we'll say AddComponent(coll); // Play sound Sound.PlaySound(Sound.SoundEffects.Arrow_Boomerang, entity, !Sound.SOUND_LOOPS); }
public void Move(Constants.Direction direction) { moving = true; goal = entity.GetComponent <Transform>().position; switch (direction) { case Constants.Direction.UP: goal.Y += Level.screen_height; break; case Constants.Direction.LEFT: goal.X += Level.screen_width; break; case Constants.Direction.RIGHT: goal.X -= Level.screen_width; break; case Constants.Direction.DOWN: goal.Y -= Level.screen_height; break; } start = entity.GetComponent <Transform>().position; }
public void HandleCollision(INpc enemy, IProjectile swordBeam, Constants.Direction side) { SwordBeamFlyingProjectile swordBeamCast = (SwordBeamFlyingProjectile)swordBeam; enemy.TakeDamage(swordBeamCast.DamageAmount()); swordBeamCast.ExplodeSword(); }
public MovePacket(Objects.Client c, Constants.Direction direction) : base(c) { Direction = direction; switch (direction) { case Tibia.Constants.Direction.Down: Type = OutgoingPacketType.MoveDown; break; case Tibia.Constants.Direction.Up: Type = OutgoingPacketType.MoveUp; break; case Tibia.Constants.Direction.Right: Type = OutgoingPacketType.MoveRight; break; case Tibia.Constants.Direction.Left: Type = OutgoingPacketType.MoveLeft; break; case Tibia.Constants.Direction.DownLeft: Type = OutgoingPacketType.MoveDownLeft; break; case Tibia.Constants.Direction.DownRight: Type = OutgoingPacketType.MoveDownRight; break; case Tibia.Constants.Direction.UpLeft: Type = OutgoingPacketType.MoveUpLeft; break; case Tibia.Constants.Direction.UpRight: Type = OutgoingPacketType.MoveUpRight; break; } Destination = PacketDestination.Server; }
/// <summary> /// constructor of a servershare /// </summary> /// <param name="location">location appreviation</param> /// <param name="shortloc">location appreviation</param> /// <param name="repr">HPC copy cluster head name</param> /// <param name="legacy">legacy share for backward compatibility</param> public ServerShare(string location, string shortloc, string repr, Constants.Direction dir) { _location = location; _shortloc = shortloc; _repr = repr; _direction = dir; }
/// <summary> /// Called when the end of a branch is reached. /// </summary> /// <param name="branchIndex"></param> private void EndReached(int branchIndex) { lastDirection = attackDirection; CancelGrid(); balance.TriggerEnd(endPoints[branchIndex].typeID); }
public static async void PlayerMove(Constants.Direction dir, string uid, string sessionKey = "") { var player = LobbyService.Sessions[sessionKey]?.Players?.FirstOrDefault(n => n.UID == uid); if (player != null) { // Don't reverse into yourself. if (player.Direction == Constants.Direction.Left && dir == Constants.Direction.Right) { return; } if (player.Direction == Constants.Direction.Right && dir == Constants.Direction.Left) { return; } if (player.Direction == Constants.Direction.Up && dir == Constants.Direction.Down) { return; } if (player.Direction == Constants.Direction.Down && dir == Constants.Direction.Up) { return; } player.Direction = dir; } }
public void HandleCollision(IPlayer link, INpc enemy, Constants.Direction side) { link.BeDamaged(enemy.GetDamageAmount()); Vector2 velocity = Vector2.Zero; switch (side) { case Constants.Direction.Up: velocity = new Vector2(0, -1 * knockbackVelocityScalar); break; case Constants.Direction.Down: velocity = new Vector2(0, knockbackVelocityScalar); break; case Constants.Direction.Left: velocity = new Vector2(-1 * knockbackVelocityScalar, 0); break; case Constants.Direction.Right: velocity = new Vector2(knockbackVelocityScalar, 0); break; } link.Move(knockbackDistance, velocity); }
public TurnPacket(Objects.Client c, Constants.Direction direction) : base(c) { Direction = direction; switch (direction) { case Tibia.Constants.Direction.Down: Type = OutgoingPacketType.TurnDown; break; case Tibia.Constants.Direction.Up: Type = OutgoingPacketType.TurnUp; break; case Tibia.Constants.Direction.Right: Type = OutgoingPacketType.TurnRight; break; case Tibia.Constants.Direction.Left: Type = OutgoingPacketType.TurnLeft; break; default: throw new ArgumentOutOfRangeException( "direction", "Valid directions for turning are Up, Right, Down, and Left."); } Destination = PacketDestination.Server; }
// If Link is within a small distance of either vertical or horizontal axis from us, move in that direction. private void Waiting() { // TODO: Convert all the rectangles to floating point. Only noticeable on the subpixel layer so it's not super important though. // Have to reconstruct a rectangle here because if we just grab the rectangle from the Sprite class it isn't the transform we expect (is instead on the spritesheet I think) // Grab a rectangle representing each entity at this point in time Entity link = Scene.Find("Link"); Rectangle linkSpriteRect = link.GetComponent <Sprite>().sprite.frames[0]; Vector2 linkTransform = link.GetComponent <Transform>().WorldPosition; // link. Rectangle linkRect = new Rectangle((int)linkTransform.X, (int)linkTransform.Y, linkSpriteRect.Width, linkSpriteRect.Height); Rectangle bladeSpriteRect = entity.GetComponent <Sprite>().sprite.frames[0]; Vector2 bladeTransform = entity.GetComponent <Transform>().position; Rectangle bladeRect = new Rectangle((int)bladeTransform.X, (int)bladeTransform.Y, bladeSpriteRect.Width, bladeSpriteRect.Height); // Check if Link is horizontal if (HorizontallyAligned(linkRect, bladeRect)) { // Console.WriteLine("BladeTrap at pos " + entity.GetComponent<Transform>().position + " detected link horiziontally!"); state = State.EXTENDING; // If blade trap is to the left of Link right now if (linkRect.X >= bladeRect.X) { // Console.WriteLine("BladeTrap going right."); direction = Constants.Direction.RIGHT; } else { // Console.WriteLine("BladeTrap going left."); direction = Constants.Direction.LEFT; } } // Check if Link is vertical else if (VerticallyAligned(linkRect, bladeRect)) { // Console.WriteLine("BladeTrap at pos " + entity.GetComponent<Transform>().position + " detected link vertically!"); state = State.EXTENDING; // If Blade trap is above Link right now if (linkRect.Y >= bladeRect.Y) { // Console.WriteLine("BladeTrap going down."); direction = Constants.Direction.DOWN; } else { // Console.WriteLine("BladeTrap going up."); direction = Constants.Direction.UP; } } else { // Console.WriteLine("BladeTrap at pos " + entity.GetComponent<Transform>().position + " detected nothing!"); } }
public override void Move(Constants.Direction direction) { if (direction == link.FacingDirection) { stillMoving = true; } }
public GoriyaBehavior(string color) { // Initial State state = State.MOVING; direction = Constants.Direction.RIGHT; framesSinceTurn = 0; framesSinceThrow = 0; framesBeforeLastFlip = 0; framesUntilThrow = Constants.GetRandomIntMinMax(50, 90); // sprites if (color.Equals("red")) { GoriyaLeft = EnemySpriteFactory.Instance.CreateRedGoriyaLeft(); GoriyaRight = EnemySpriteFactory.Instance.CreateRedGoriyaRight(); GoriyaUp = EnemySpriteFactory.Instance.CreateRedGoriyaUp(); GoriyaUpFlipped = EnemySpriteFactory.Instance.CreateRedGoriyaUpFlipped(); GoriyaDown = EnemySpriteFactory.Instance.CreateRedGoriyaDown(); GoriyaDownFlipped = EnemySpriteFactory.Instance.CreateRedGoriyaDownFlipped(); } else { GoriyaLeft = EnemySpriteFactory.Instance.CreateBlueGoriyaLeft(); GoriyaRight = EnemySpriteFactory.Instance.CreateBlueGoriyaRight(); GoriyaUp = EnemySpriteFactory.Instance.CreateBlueGoriyaUp(); GoriyaUpFlipped = EnemySpriteFactory.Instance.CreateBlueGoriyaUpFlipped(); GoriyaDown = EnemySpriteFactory.Instance.CreateBlueGoriyaDown(); GoriyaDownFlipped = EnemySpriteFactory.Instance.CreateBlueGoriyaDownFlipped(); } }
// Helper function to choose a new direction private void NewDirection(Sprite sprite) { direction = Constants.RandomEnumValue <Constants.Direction>(); switch (direction) { case Constants.Direction.UP: direction = Constants.Direction.RIGHT; sprite.SetSprite(GoriyaRight); break; case Constants.Direction.RIGHT: direction = Constants.Direction.DOWN; sprite.SetSprite(GoriyaDown); break; case Constants.Direction.DOWN: direction = Constants.Direction.LEFT; sprite.SetSprite(GoriyaLeft); break; case Constants.Direction.LEFT: direction = Constants.Direction.UP; sprite.SetSprite(GoriyaUp); break; default: Console.WriteLine("RedGoriyaBehavior @ TurnRight(): Unrecognized direction!"); break; } }
public void Move(Constants.Direction direction) { moving = true; goal = entity.GetComponent <Transform>().position; int offsetUpDown = -270; int offsetLeftRight = -310; switch (direction) { case Constants.Direction.UP: goal.Y += offsetUpDown; break; case Constants.Direction.LEFT: goal.X += offsetLeftRight; break; case Constants.Direction.RIGHT: goal.X -= offsetLeftRight; break; case Constants.Direction.DOWN: goal.Y -= offsetUpDown; break; } start = entity.GetComponent <Transform>().position; }
public void HandleCollision(INpc enemy, IProjectile sword, Constants.Direction side) { enemy.TakeDamage(sword.DamageAmount()); if (enemy.GetType() == typeof(Skeleton) || enemy.GetType() == typeof(Goriya)) { enemy.SetKnockBack(true, side); } }
public override IRoom GetRoom(Constants.Direction direction) { if (direction == Constants.Direction.Stairs) { UpdatePlayerPositions(); } return(base.GetRoom(direction)); }
/// <summary> /// Walk in the specified direction /// </summary> /// <param name="direction"></param> /// <returns></returns> public bool Walk(Constants.Direction direction) { byte[] packet = new byte[3]; packet[0] = 0x01; packet[1] = 0x00; packet[2] = Convert.ToByte(0x65 + direction); return(client.Send(packet)); }
public virtual void Move(Constants.Direction direction) { if (link.BlockStateChange) { return; } link.State = new LinkWalkingState(link, direction, damaged, healthyDateTime); }
public WallMasterMovement(Constants.Direction startingDirection) { // initial state state = State.ROAMING; direction = startingDirection; // initial values directionSwitchCurrent = 0; }
public ItemMovement(bool moving, bool disappearing, int framesToDraw, Constants.Direction directionThrown) { this.moving = moving; this.disappearing = disappearing; this.framesToDraw = framesToDraw; this.directionThrown = directionThrown; this.framesDrawn = 0; }
public void HandleCollision(INpc enemy, IProjectile boomerang, Constants.Direction side) { if (boomerang.Owner == Constants.ProjectileOwner.Link) { BoomerangFlyingProjectile boomerangCast = (BoomerangFlyingProjectile)boomerang; enemy.TakeDamage(boomerangCast.DamageAmount()); boomerangCast.ReturnToOwner(); } }
public void HandleCollision(INpc enemy, IProjectile bomb, Constants.Direction side) { BombExplodingProjectile bombCast = (BombExplodingProjectile)bomb; if (bombCast.IsExploded()) { enemy.TakeDamage(bombCast.DamageAmount()); } }
/// <summary> /// Turn to the specified direction. /// </summary> /// <param name="direction"></param> /// <returns></returns> public bool Turn(Constants.Direction direction) { byte[] packet = new byte[3]; packet[0] = 0x01; packet[1] = 0x00; packet[2] = Convert.ToByte(0x6F + direction); return(client.Player.Turn(direction)); //return client.Player.Turn(direction); }