public void activateWeapon(WeaponType weapon)
    {
        switch(weapon){
            case WeaponType.NONE:
                equippedWeapon = null;
                break;
            case WeaponType.MINIGUN:
                equippedWeapon = minigunComp;
                break;
            case WeaponType.ROCKET_LAUNCHER:
                equippedWeapon = rocketLauncherComp;
                break;
            case WeaponType.SPIKES:
                equippedWeapon = spikeHandleComp;
                break;
            case WeaponType.MINE_THROWER:
                equippedWeapon = mineThrowerComp;
            break;
        }

        if(equippedWeapon != null)
            equippedWeaponNumber = (int)equippedWeapon.weaponType;
        /*
        if(equippedWeapon != null)
            equippedWeapon.reset();
        */
    }

 public Weapon(WeaponType type, string name, int price, float fireRate)
 {
     FireRate = fireRate;
     Price = price;
     WeaponType = type;
     Name = name;
 }

 public void SetType(WeaponType eType)
 {
     // Set the _type
     _type = eType;
     WeaponDefinition def = Main.GetWeaponDefinition(_type);
     GetComponent<Renderer>().material.color = def.projectileColor;
 }

        public Item(GraphicsDeviceManager g, ContentManager c, int weapon, Vector2 startLoc, Vector2 playerDim)
        {
            graphics = g;
            content = c;

            dimensions = new Vector2(90, 120);
            loc = new Vector2(startLoc.X - playerDim.X / 2, startLoc.Y - playerDim.Y / 3);

            random = new Random();

            if (weapon == 0)
            {
                LoadContent("Textures/ShortSwordWalk");

                vitality = 0;
                dexterity = 0;
                intelligence = 0;
                strength = 0;

                critBonus = 0;
                critChance = 0;

                minDmg = 1f;
                maxDmg = 5f;

                statType = StatType.str;
                weaponType = WeaponType.slash;

                atkSpd = 1f;
            }

            animation = new SpriteAnimation(8, itemSpriteSheet, .45, new Rectangle((int)loc.X, (int)loc.Y,
                                                                      (int)dimensions.X, (int)dimensions.Y));
        }

    //Note that there ARE some differences between sword, axe, and hammer calculations
    public void UpdateSize(WeaponType newType, float bladeScale, float handleScale)
    {
        //TODO - make small blade + large handle not horribly broken
        if (newType == WeaponType.SWORD) {

            //The sword handle scale gets a special calculation applied to map the 1-2 scale to a 1-12 scale
            handleTrans.localScale = new Vector3 (DEFAULT_SWORD_HANDLE_SCALE.x, (DEFAULT_SWORD_HANDLE_SCALE.y * (((handleScale - 1.6f) * 6f) + 10f)) + DEFAULT_SWORD_HANDLE_LENGTH_OFFSET, DEFAULT_SWORD_HANDLE_SCALE.z);
            handleTrans.localPosition = DEFAULT_SWORD_HANDLE_POS;

            bladeTrans.localScale = new Vector3 (DEFAULT_SWORD_BLADE_SCALE.x * bladeScale, DEFAULT_SWORD_BLADE_SCALE.y * bladeScale, DEFAULT_SWORD_BLADE_SCALE.z);
            //Weird math to get the blade in the right spot
            bladeTrans.localPosition = new Vector3 (DEFAULT_SWORD_HANDLE_POS.x, handleTrans.localPosition.y + (handleTrans.localScale.y / 2) + (bladeTrans.localScale.y / 2) + DEFAULT_SWORD_BLADE_OFFSET, DEFAULT_SWORD_HANDLE_POS.z);

        } else if (newType == WeaponType.AXE) {

            handleTrans.localScale = new Vector3 (DEFAULT_AXE_HANDLE_SCALE.x, DEFAULT_AXE_HANDLE_SCALE.y * handleScale, DEFAULT_AXE_HANDLE_SCALE.z);
            handleTrans.localPosition = new Vector3 (DEFAULT_AXE_HANDLE_POS.x, DEFAULT_AXE_HANDLE_POS.y * handleScale * .75f, DEFAULT_AXE_HANDLE_POS.z);

            bladeTrans.localScale = new Vector3 (DEFAULT_AXE_BLADE_SCALE.x * bladeScale, DEFAULT_AXE_BLADE_SCALE.y * bladeScale, DEFAULT_AXE_BLADE_SCALE.z);
            //Weird math to get the blade in the right spot
            bladeTrans.localPosition = new Vector3 (DEFAULT_AXE_HANDLE_POS.x, handleTrans.localPosition.y + (handleTrans.localScale.y / 2) - (bladeTrans.localScale.y / 2) + DEFAULT_AXE_BLADE_OFFSET, DEFAULT_AXE_HANDLE_POS.z);

        } else if (newType == WeaponType.HAMMER) {

            handleTrans.localScale = new Vector3 (DEFAULT_HAMMER_HANDLE_SCALE.x, DEFAULT_HAMMER_HANDLE_SCALE.y * handleScale, DEFAULT_HAMMER_HANDLE_SCALE.z);
            handleTrans.localPosition = new Vector3 (DEFAULT_HAMMER_HANDLE_POS.x, DEFAULT_HAMMER_HANDLE_POS.y * handleScale * .75f, DEFAULT_HAMMER_HANDLE_POS.z);

            bladeTrans.localScale = new Vector3 (DEFAULT_HAMMER_BLADE_SCALE.x * bladeScale, DEFAULT_HAMMER_BLADE_SCALE.y * bladeScale, DEFAULT_HAMMER_BLADE_SCALE.z * bladeScale);
            //Weird math to get the blade in the right spot
            bladeTrans.localPosition = new Vector3 (DEFAULT_HAMMER_HANDLE_POS.x, handleTrans.localPosition.y + (handleTrans.localScale.y / 2) - (bladeTrans.localScale.y / 2) + DEFAULT_HAMMER_BLADE_OFFSET, DEFAULT_HAMMER_HANDLE_POS.z);
        }
    }

 public DeathInfo(float LastDamage, WeaponType DamageType, SourceType SourceType, Unit Killer = null)
 {
     this.DamageType = DamageType;
     this.LastDamage = LastDamage;
     this.SourceType = SourceType;
     this.Killer = Killer;
 }

 public void UnlockWeapon(WeaponType type)
 {
     if(!UnlockedWeapons.Contains (type))
     {
         UnlockedWeapons.Add (type);
     }
 }

	// Use this for initialization
	public Weapon(WeaponType Type)
    {
        Weapontype = Type;
        //left?

        Facing = ItemFacing.Left;

        switch (Type)
        { 
            case WeaponType.Axe:
                break;
            case WeaponType.Pistol:
                break;
            case WeaponType.Rifle:
                ItemSprite = GameObject.CreatePrimitive(PrimitiveType.Plane);
                ItemSprite.transform.localScale = new Vector3(-(0.5f / SizeMod), 1.0f, -(0.2f / SizeMod));

                Texture tex = (Texture)UnityEditor.AssetDatabase.LoadAssetAtPath("Assets\\Resources\\Drawings\\Weapons\\rifle.png", typeof(Texture));
                ItemSprite.GetComponent<Renderer>().material = (Material)UnityEditor.AssetDatabase.LoadAssetAtPath("Assets\\Resources\\Drawings\\Weapons\\rifle.mat", typeof(Material));

                ItemSprite.transform.rotation = Quaternion.AngleAxis(TargetAngle, -Vector3.up);

                break;
        }
	}

 protected IWeapon(int damage, int durability, WeaponType type, List<Rune> runes)
 {
     this.damage = damage;
             this.durability = this.currentDurability = durability;
             this.type = type;
             this.runes = runes;
 }

 public void SetHitPct(bool hit, WeaponType weapon)
 {
     switch (weapon)
     {
         case WeaponType.Bullet:
             bulletsFired++;
             if(hit)
             {
                 bulletsHit++;
             }
             bulletHitPct = (bulletsHit / bulletsFired) * 100;
             break;
         case WeaponType.Laser:
             lasersFired++;
             if (hit)
             {
                 lasersHit++;
             }
             laserHitPct = (lasersHit / lasersFired) * 100;
             break;
         case WeaponType.Rocket:
             rocketsFired++;
             if (hit)
             {
                 rocketsHit++;
             }
             rocketHitPct = (rocketsHit / rocketsFired) * 100;
             break;
     }
 }

 public Weapon(string texturePath, Rectangle rectangle, int speed, int damage, WeaponType type, string name)
     : base(texturePath, rectangle, speed)
 {
     this.WeaponType = type;
     this.Damage = damage;
     this.Name = name;
 }

 public void initialize()
 {
     energy = 100;
             weaponLevel = 5;
             weaponType = WeaponType.BARE_HANDS;
             health = 10;
 }

    public static WeaponDefinition GetWeaponDefinition( WeaponType wt )
    {
        if (W_DEFS.ContainsKey (wt))
            return W_DEFS [wt];

        return new WeaponDefinition ();
    }

 /// <summary>
 /// Create an item for the player or enemy
 /// </summary>
 /// <param name="SlotType">What type of slot this item uses</param>
 /// <param name="Location">The location of this slot, relative to the user</param>
 /// <param name="WeaponType">What type of weapon this item is</param>
 public WeaponBay(Vector2 Location, Boolean PlayerOwned, WeaponType WeaponType, Vector2 Direction, Texture2D ProjectileTexture)
     : base(SlotType.WeaponBay, Location, PlayerOwned)
 {
     wtWeaponType = WeaponType;
     v2Direction = Direction;
     t2dProjectile = ProjectileTexture;
 }

        public float GetAmmo(WeaponType offset)
        {
            // proc not running?
            if(CanRead && _baseAddress > 0)
            {
                return 0f;
            }

            var bytesRead = 0;

            // yo dawg I heard you like pointers so I'mma point to these pointers that
            // point to pointers, get the point(ers)?
            if(!_finalLocations.ContainsKey(offset))
            {
                byte[] p1a = _bl2.ReadMemory(_baseAddress + BASE_OFFSET, 4, out bytesRead);
                int p1v = BitConverter.ToInt32(p1a, 0);

                byte[] p2a = _bl2.ReadMemory(p1v + 0x2c, 4, out bytesRead);
                int p2v = BitConverter.ToInt32(p2a, 0);

                byte[] p3a = _bl2.ReadMemory(p2v + (int)offset, 4, out bytesRead);
                int p3v = BitConverter.ToInt32(p3a, 0);

                // lets cache the actual ammo location so we're not doing this every time we check for ammo
                _finalLocations[offset] = p3v;
            }

            byte[] ammo = _bl2.ReadMemory(_finalLocations[offset] + 0x6c, 4, out bytesRead);
            return BitConverter.ToSingle(ammo, 0);
        }

    // public int speed = 0;
    public Creature(World world, int location_x, int location_y, float hp, ArmorType armor, WeaponType weapon,
		float atk, float def, int area, int movement, int range = 1)
        : base(world, location_x, location_y, hp, area, movement)
    {
        Armor = armor;
        Weapon = weapon;
        Range = range;
        // Units = unit;

        // Here speed is treated as priority for attacking. The party has higher speed attacks first.
        // Here we calcuate speed bonus for Armors.
        if (Armor == ArmorType.Cloth)
            Speed += 10;
        else if (Armor == ArmorType.Leather)
            Speed += 8;
        else if (Armor == ArmorType.Wooden)
            Speed += 6;
        else if (Armor == ArmorType.Mail)
            Speed += 4;
        else if (Armor == ArmorType.Plate)
            Speed += 3;

        // Here we calcuate speed bonus for Weapons.
        if (Weapon == WeaponType.Light)
            Speed += 6;
        else if (Weapon == WeaponType.Piercing)
            Speed += 4;
        else if (Weapon == WeaponType.Heavy)
            Speed += 2;
        else if (Weapon == WeaponType.Energy)
            Speed += 3;

        Def = def + (int)Armor;
        Atk = atk;
    }

    public static int getModifier(WeaponType weaponType, EnemyType enemyType)
    {
        if (weaponType == WeaponType.BARE_HANDS) {
                        if (enemyType == EnemyType.Spider) {
                                return 1;
                        } else if (enemyType == EnemyType.Zombie) {
                                return -1;
                        } else {
                                return 0;
                        }
                } else if (weaponType == WeaponType.STAFF) {
                        if (enemyType == EnemyType.Spider) {
                                return -1;
                        } else if (enemyType == EnemyType.Zombie) {
                                return 0;
                        } else {
                                return 1;
                        }
                } else if (weaponType == WeaponType.SWORD) {
                        if (enemyType == EnemyType.Spider) {
                                return 0;
                        } else if (enemyType == EnemyType.Zombie) {
                                return 1;
                        } else {
                                return -1;
                        }
                } else {
                        return 0;

                }
    }

 public Weapon(string _name, DmgType _dmgType, int _physDmgAmt, EleDmgType _eleDmgType, int _eleDmgAmt, int _range) : base()
 {
     Name = _name;
     Id = (double)UnityEngine.Random.Range(0, 1000000000);
     Range = _range;
     EleDmgAmt = _eleDmgAmt;
     PhysDmgAmt = _physDmgAmt;
     PhysDmg = _dmgType;
     EleDmg = _eleDmgType;
     if (Range < 2)
     {
         WeapType = WeaponType.Low;
     }
     else if (Range < 4)
     {
         WeapType = WeaponType.Medium;
     }
     else if (Range < 10)
     {
         WeapType = WeaponType.High;
     }
     else if (Range < 30)
     {
         WeapType = WeaponType.RLow;
     }
     else
     {
         WeapType = WeaponType.RHigh;
     }
     Id = Database.WeaponDbInsert(this);
 }

    public void UpdateStats(WeaponType newType = WeaponType.AXE, float newHandleLength = 1.0f, float newHeadSize = 1.0f)
    {
        type = newType;
        handleLength = newHandleLength;
        headSize = newHeadSize;

        //TODO - balance these?
        //DPS is identical on all weapons, but bigger weapons also get larger knockback and reach, so...
        damageMod = headSize * handleLength;
        knockbackMod = headSize * handleLength;
        attackTime = headSize * handleLength;

        switch (type) {
        case WeaponType.AXE:
            damageMod *= GLOBAL_AXE_DAMAGE_MOD;
            knockbackMod *= GLOBAL_AXE_KNOCKBACK_MOD;
            attackTime *= GLOBAL_AXE_ATTACK_TIME_MOD;
            break;
        case WeaponType.HAMMER:
            damageMod *= GLOBAL_HAMMER_DAMAGE_MOD;
            knockbackMod *= GLOBAL_HAMMER_KNOCKBACK_MOD;
            attackTime *= GLOBAL_HAMMER_ATTACK_TIME_MOD;
            break;
        //Other weapons default to sword stats
        default:
            damageMod *= GLOBAL_SWORD_DAMAGE_MOD;
            knockbackMod *= GLOBAL_SWORD_KNOCKBACK_MOD;
            attackTime *= GLOBAL_SWORD_ATTACK_TIME_MOD;
            break;
        }
    }

        public static Weapon CreateWeapon(WeaponType weaponType, float ammoMultiplier)
        {
            switch (weaponType)
            {
                case WeaponType.AssaultRifle:
                    return new AssaultRifle();

                case WeaponType.Shotgun:
                    return new Shotgun(ammoMultiplier);

                case WeaponType.RocketLauncher:
                    return new RocketLauncher(ammoMultiplier);

                case WeaponType.Laser:
                    return new Laser(ammoMultiplier);

                case WeaponType.Minigun:
                    return new Minigun(ammoMultiplier);

                case WeaponType.Bouncer:
                    return new Bouncer(ammoMultiplier);

                case WeaponType.Flamethrower:
                    return new Flamethrower(ammoMultiplier);

                case WeaponType.Waterblaster:
                    return new Waterthrower(ammoMultiplier);

                default:
                    throw new ArgumentOutOfRangeException("weaponType");
            }
        }