source: 2012/27/DenisZ/TheDungeonGame/TheDungeonGame/TheDungeonGame/Player.cs @ 3596

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Jypeli;
using Jypeli.Controls;
using MathHelper;
using Rooms;
using Jypeli.Assets;
using Items;

namespace Entity
{
    public class Player : PhysicsObject
    {
        public const double playerWidth = 120 / 3;
        public const double playerHeight = 180 / 3;
        // private PhysicsObject head;
        public Vector movementVector = Vector.Zero;
        public bool isMoving = false;
        private Keyboard keyboard;
        public double speed = 250;
        private TheDungeonGame game;
        public Room currentRoom;
        public IntMeter playerHealth = new IntMeter(5, 0, 30);
        private Item itemInInventory;
        private AssaultRifle weapon;

        private Angle UpAngle = Angle.FromDegrees(90);
        private Angle RightAngle = Angle.Zero;
        private Angle DownAngle = Angle.FromDegrees(270);
        private Angle LeftAngle = Angle.FromDegrees(180);

        public Player(TheDungeonGame game, Vector pos, Image texture)
            : base(playerWidth, playerHeight)
        {
            this.game = game;
            keyboard = game.Keyboard;
            CanRotate = false;
            setupKeys();
            Image = texture;
            itemInInventory = new TestItem(TheDungeonGame.LoadImage("items/testItem"), "Test Item", false);
            Tag = "Player";

            weapon = new AssaultRifle(playerWidth / 3, playerHeight / 3);
            weapon.Top = Top;
            weapon.Image = null;
            weapon.Color = Color.Transparent;
            weapon.CanHitOwner = false;
            weapon.InfiniteAmmo = true;
            weapon.MaxAmmoLifetime = TimeSpan.FromSeconds(0.5);
            weapon.TimeBetweenUse = TimeSpan.FromSeconds(0.4);
            weapon.ProjectileCollision = bulletCollided;
            Add(weapon);
        }

        private void setupKeys()
        {
            keyboard.Listen(Key.W, ButtonState.Down, move, "Move Up", new Vector(0, speed));
            keyboard.Listen(Key.A, ButtonState.Down, move, "Move Left", new Vector(-speed, 0));
            keyboard.Listen(Key.S, ButtonState.Down, move, "Move Down", new Vector(0, -speed));
            keyboard.Listen(Key.D, ButtonState.Down, move, "Move Right", new Vector(speed, 0));

            keyboard.Listen(Key.W, ButtonState.Released, removeMovement, null, new Vector(0, speed));
            keyboard.Listen(Key.A, ButtonState.Released, removeMovement, null, new Vector(-speed, 0));
            keyboard.Listen(Key.S, ButtonState.Released, removeMovement, null, new Vector(0, -speed));
            keyboard.Listen(Key.D, ButtonState.Released, removeMovement, null, new Vector(speed, 0));

            keyboard.Listen(Key.Up, ButtonState.Down, shootAmmo, "Shoot up", UpAngle);
            keyboard.Listen(Key.Down, ButtonState.Down, shootAmmo, "Shoot up", DownAngle);
            keyboard.Listen(Key.Right, ButtonState.Down, shootAmmo, "Shoot up", RightAngle);
            keyboard.Listen(Key.Left, ButtonState.Down, shootAmmo, "Shoot up", LeftAngle);

            keyboard.Listen(Key.Space, ButtonState.Pressed, useItemInInventory, "Use Item");
        }

        private void bulletCollided(PhysicsObject collidingObject, PhysicsObject targetObject)
        {

            if (targetObject.Tag.Equals("Enemy"))
            {
                EntityBase entity = (EntityBase)targetObject;
                entity.hit(WeaponDamage);
                collidingObject.Destroy();
                currentRoom.EntityAmount--;
            }
            else if(targetObject.Tag.Equals("Wall") || targetObject.Tag.Equals("ObjectRock"))
                collidingObject.Destroy();
        }

        public TimeSpan WeaponSpeed
        {
            get
            {
                return weapon.TimeBetweenUse;
            }
            set
            {
                weapon.TimeBetweenUse = value;
            }
        }

        public TimeSpan BulletLife
        {
            get
            {
                return weapon.MaxAmmoLifetime;
            }
            set
            {
                weapon.MaxAmmoLifetime = value;
            }
        }

        public int WeaponDamage
        {
            get;
            set;
        }

        private void shootAmmo(Angle angle)
        {
            weapon.Angle = angle;
            weapon.Shoot();
        }

        private void useItemInInventory()
        {
            if (itemInInventory == null) return;
            itemInInventory.useItem(game);
            updateGuiImage();
        }

        public Item ItemInInventory
        {
            get
            {
                return itemInInventory;
            }
            set
            {
                itemInInventory = value;
            }
        }

        public void updateGuiImage()
        {
            game.gui.setInventoryImage(itemInInventory);
        }

        public void performCollision(PhysicsObject player, PhysicsObject target)
        {
            Room room;
            if (target.Tag.Equals(RoomDirection.North) || target.Tag.Equals(RoomDirection.East) || target.Tag.Equals(RoomDirection.South) || target.Tag.Equals(RoomDirection.West))
            {
                ObjectDoor door = (ObjectDoor)target;
                if (door != null && door.IsLocked) return;
            }
            
            if (target.Tag.Equals(RoomDirection.North))
            {
                room = game.LevelGen.getRoomAt(currentRoom.PosOnGrid + RoomDirection.getOffsetFromDir(RoomDirection.North));
                game.moveToRoom(room, RoomDirection.North);
                currentRoom = room;
            }
            else
                if (target.Tag.Equals(RoomDirection.East))
                {
                    room = game.LevelGen.getRoomAt(currentRoom.PosOnGrid + RoomDirection.getOffsetFromDir(RoomDirection.East));
                    game.moveToRoom(room, RoomDirection.East);
                    currentRoom = room;
                }
                else
                    if (target.Tag.Equals(RoomDirection.South))
                    {
                        room = game.LevelGen.getRoomAt(currentRoom.PosOnGrid + RoomDirection.getOffsetFromDir(RoomDirection.South));
                        game.moveToRoom(room, RoomDirection.South);
                        currentRoom = room;
                    }
                    else
                        if (target.Tag.Equals(RoomDirection.West))
                        {
                            room = game.LevelGen.getRoomAt(currentRoom.PosOnGrid + RoomDirection.getOffsetFromDir(RoomDirection.West));
                            game.moveToRoom(room, RoomDirection.West);
                            currentRoom = room;
                        }
        }

        public void handleItemPickup(IPhysicsObject player, IPhysicsObject item)
        {
            ItemEntity itemEnt = (ItemEntity)item;
            itemEnt.bindedItem.onPickup(this);
            item.Destroy();
        }

        public override void Update(Time time)
        {
            if (!isMoving)
            {
                movementVector = Vector.Zero;
                Stop();
            }

            isMoving = false;

            Console.WriteLine(currentRoom.EntityAmount);

            if (currentRoom.EntityAmount == 0)
            {
                foreach (ObjectDoor door in currentRoom.doors)
                {
                    if (door != null)
                        door.IsLocked = false;
                }
            }
            else
            {
                foreach (ObjectDoor door in currentRoom.doors)
                {
                    if (door != null)
                        door.IsLocked = true;
                }
            }


            base.Update(time);
        }

        public void move(Vector vec)
        {
            if (vec.X != 0)
                movementVector.X = vec.X;
            if (vec.Y != 0)
                movementVector.Y = vec.Y;

            Move(movementVector);
            isMoving = true;
        }

        public void removeMovement(Vector vec)
        {
            movementVector = VecMath.sub(movementVector, vec);
        }
    }
}