void Awake()
 {
     weaponPool = new GameObjectPool(projectile, maximumSize, initialSize, transform);
     impactPool = new GameObjectPool(impact, -1, initialSize / 2, transform);
     WeaponManager.Register(this);
     weapon = projectile.GetComponent<IWeapon>();
 }

        public void CombatantsCreatedThruFactoryCanAttack()
        {
            // Setup our stub.
            this.stubWeapon = MockRepository.GenerateStub<IWeapon>();
            this.equipmentFactory.Stub(x => x.EquipCombatant(null)).IgnoreArguments().Do(
                new EquipCombatant(this.StubEquipCombatant));
            this.equipmentFactory.Replay();
            this.stubWeapon.Expect(x => x.CalculateDamage()).Return(10);
            this.stubWeapon.Expect(x => x.CalculateDamage()).Return(10);

            // Get our combatants.
            string knightName = "My Knight";
            var knight = combatantFactory.CreateCombatant<Knight>(knightName);
            string randomCombatantName = "My Random Combatant";
            var randomCombatant = combatantFactory.CreateRandomCombatant(randomCombatantName);

            int catapultHealth = randomCombatant.Health;
            int knightHealth = knight.Health;

            randomCombatant.Attack(knight);
            knight.Attack(randomCombatant);

            this.equipmentFactory.VerifyAllExpectations();
            this.stubWeapon.VerifyAllExpectations();
            Assert.AreNotEqual(catapultHealth, randomCombatant.Health);
            Assert.AreNotEqual(knightHealth, knight.Health);
        }

 public void ChangeWeapon(IWeapon newWeapon, List<Character> selectedNames)
 {
     foreach (Character character in selectedNames)
     {
         character.weapon = newWeapon;
     }
 }

 public void FightWithDefaultContext(IWeapon weapon1, IWeapon weapon2)
 {
     // Assert
       weapon1.Should().BeSameAs (weapon2);
       weapon1.Should().BeSameAs (_weapon1);
       weapon1.Should().NotBeSameAs (_weapon2);
 }

        // These two constructors are indicative of a needed abstraction.
        public ForgedWeapon(IWeapon weapon, IMaterialComponent component)
        {
            GivenName = weapon.GivenName;
            Damage = weapon.Damage;
            CriticalDamage = weapon.CriticalDamage;
            DamageType = weapon.DamageType;
            MaxRange = weapon.MaxRange;
            Proficiency = weapon.Proficiency;
            RangeIncrement = weapon.RangeIncrement;
            ThreatRange = weapon.ThreatRange;
            ThreatRangeLowerBound = weapon.ThreatRangeLowerBound;
            WeaponCategory = weapon.WeaponCategory;
            WeaponName = string.Format("{0} {1}", component.ComponentName, weapon.WeaponName);
            WeaponSize = weapon.WeaponSize;
            WeaponSubCategory = weapon.WeaponSubCategory;
            WeaponUse = weapon.WeaponUse;
            Hardness = weapon.Hardness;
            HitPoints = weapon.HitPoints;
            IsBow = weapon.IsBow;

            Weight = component.ApplyWeightModifer(weapon);
            ToHitModifier = component.ApplyToHitModifier();
            WeaponCost = component.ApplyCostModifier(weapon);
            SpecialInfo = component.AppendSpecialInfo(weapon);
            IsMasterwork = component.VerifyMasterwork(weapon);
            DamageBonus = component.ApplyDamageModifier(weapon);
            ComponentName = component.ComponentName;
            AdditionalEnchantmentCost = component.GetAdditionalEnchantmentCost();
        }

		public void ApplyDamage(int _damage, IWeapon _weapon, Creature _source)
		{
			var fact = Math.Min(_damage, HP);

			if (!(Creature is Avatar))
			{
				HP -= _damage;
			}
			Creature.DamageTaken(this, _source, _weapon, _damage);

			fact -= Creature[0, 0].AddSplatter(fact, FColor.Crimson);
			if (fact > 0)
			{
				var ro = World.Rnd.NextDouble() * Math.PI * 2;
				var x = (int)(Math.Sin(ro) * 20f);
				var y = (int)(Math.Cos(ro) * 20f);

				new SplatterDropper(Creature.GeoInfo.Layer, Creature[0, 0], fact, FColor.Crimson, Creature[x, y]);
			}

			if (HP <= 0)
			{
				MessageManager.SendXMessage(this, new XMessage(EALTurnMessage.CREATURE_KILLED, _source, Creature));
				Creature[0, 0].AddItem(new Corpse(Creature));
				World.TheWorld.CreatureManager.CreatureIsDead(Creature);
			}
		}

 public LaserDecorator(IWeapon wpn)
 {
     _scale = GameLogic.GetInstance().GetScale();
     _offset = new Vector2(_scale*2.5f, -(_scale*5f));
     _speed = new Vector2(0, -(_scale*4f));
     _wpn = wpn;
 }

    protected virtual void Awake()
    {
        m_hForward = false;
        m_hBackward = false;
        m_hRight = false;
        m_hLeft = false;

        m_hWheels = new List<Wheel>();
        m_hRigidbody = this.GetComponent<Rigidbody>();
        m_hRigidbody.interpolation = RigidbodyInterpolation.None;
        //Initialize effective wheels
        List<Transform> gfxPos = this.GetComponentsInChildren<Transform>().Where(hT => hT.GetComponent<WheelCollider>() == null).ToList();
        this.GetComponentsInChildren<WheelCollider>().ToList().ForEach(hW => m_hWheels.Add(new Wheel(hW, gfxPos.OrderBy(hP => Vector3.Distance(hP.position, hW.transform.position)).First().gameObject)));
        m_hWheels = m_hWheels.OrderByDescending(hW => hW.Collider.transform.localPosition.z).ToList();

        //Initialize extra wheels
        m_hFakeWheels = GetComponentsInChildren<FakeWheel>().ToList();

        //Initialize VehicleTurret
        m_hTurret = GetComponentInChildren<VehicleTurret>();

        //Initialize IWeapon
        m_hCurrentWeapon = GetComponentInChildren<IWeapon>();

        m_hActor = GetComponent<Actor>();

        //Initialize Drive/Brake System
        switch (DriveType)
        {
            case DriveType.AWD:
                m_hEngine = new AwdDrive(Hp, m_hWheels);
                break;
            case DriveType.RWD:
                m_hEngine = new RearDrive(Hp, m_hWheels);
                break;
            case DriveType.FWD:
                m_hEngine = new ForwardDrive(Hp, m_hWheels);
                break;
            default:
                break;
        }


        m_hConstanForce = this.GetComponent<ConstantForce>();
        m_hReverseCOM = new Vector3(0.0f, -2.0f, 0.0f);

        m_hOriginalCOM = m_hRigidbody.centerOfMass;


        GroundState hGroundState = new GroundState(this);
        FlyState hFlyState = new FlyState(this);
        TurnedState hTurned = new TurnedState(this, m_hReverseCOM);

        hGroundState.Next = hFlyState;
        hFlyState.Grounded = hGroundState;
        hFlyState.Turned = hTurned;
        hTurned.Next = hFlyState;
        m_hFlyState = hFlyState;
    }

 protected Player(Position position, int health, int damage, string name, int energyPoints, Image image, IWeapon weapon, int healingPoints)
     : base(position, health, damage, image)
 {
     this.Name = name;
     this.EnergyPoints = energyPoints;
     this.Weapon = weapon;
     this.healingPoints = healingPoints;
 }

 void Awake()
 {
     this.HeliRigidBody = GetComponent<Rigidbody>();
     this.mass = HeliRigidBody.mass;
     this.isGrounded = true;
     this.playerPlane = new Plane(Vector3.up, this.transform.position);
     m_hCurrentWeapon = GetComponentInChildren<IWeapon>();
 }

 public static ArmorType GetNeededArmorType(IWeapon weapon)
 {
     if (weapon.Type == DamageType.Magical)
         return ArmorType.Magical;
     if (weapon.Range == 0)
         return ArmorType.Physical;
     return ArmorType.Ranged;
 }

 public double ApplyCostModifier(IWeapon weapon)
 {
     if (weapon.WeaponCategory.Contains("Light"))
     {
         return weapon.WeaponCost + lightWeaponCostModifier;
     }
     return weapon.WeaponCost;
 }

 public double ApplyDamageModifier(IWeapon weapon)
 {
     if (weapon.IsBow)
     {
         return 0;
     }
     return DamageBonus;
 }

        public ContextExample(IWeapon weapon1, [Ctx ("a")] IWeapon weapon2)
        {
            _weapon1 = weapon1;
              _weapon2 = weapon2;

              // Assert
              weapon1.Should().NotBeSameAs (weapon2);
        }

 public void setHitParameters(Vector2 playerPosition, Vector2 dir, LayerMask hittableLayers, IWeapon currentWeapon, IWeapon[] weapons)
 {
     this.dir = new Vector2(dir.x, -dir.y);
     this.hittableLayers = hittableLayers;
     this.currentWeapon = currentWeapon;
     this.weapons = weapons;
     area = this.currentWeapon.getCharacteristic(IWeapon.Stats.AOE);
     this.playerPosition = playerPosition;
 }

 public List<EffectivePoint> CalculateTargetablePoints(IWeapon weapon, Point wielderPosition)
 {
     List<EffectivePoint> targetablePoints = new List<EffectivePoint>();
     targetablePoints.Add(new EffectivePoint(wielderPosition + new Point(1, 0), 1.0f));
     targetablePoints.Add(new EffectivePoint(wielderPosition + new Point(-1, 0), 1.0f));
     targetablePoints.Add(new EffectivePoint(wielderPosition + new Point(0, 1), 1.0f));
     targetablePoints.Add(new EffectivePoint(wielderPosition + new Point(0, -1), 1.0f));
     return targetablePoints;
 }

 public override void Add(TypeOfGun type, IWeapon weapon)
 {
     KeyValuePair<TypeOfGun, IWeapon> tmp = new KeyValuePair<TypeOfGun, IWeapon>(type, weapon);
     
     if (weaponRepository.Contains(tmp) == false)
     {
         weaponRepository.Add(tmp);
     }
 }

        public EnchantedMagicWeapon(IWeapon weapon, List<IWeaponEnchantment> weaponEnchantments)
        {
            enchantments = new List<IWeaponEnchantment>();
            LoadCriticalDamageDictionary();

            plusWeapon = QualifyWeapon(weapon);
            enchantments.AddRange(weaponEnchantments);

            // IWeapon
            WeaponName = plusWeapon.WeaponName;
            GivenName = plusWeapon.GivenName;
            Proficiency = plusWeapon.Proficiency;
            WeaponUse = plusWeapon.WeaponUse;
            WeaponCategory = plusWeapon.WeaponCategory;
            WeaponSubCategory = plusWeapon.WeaponSubCategory;
            WeaponSize = plusWeapon.WeaponSize;
            WeaponCost = plusWeapon.WeaponCost;
            Damage = plusWeapon.Damage;
            ThreatRangeLowerBound = plusWeapon.ThreatRangeLowerBound;
            CriticalDamage = plusWeapon.CriticalDamage;
            DamageType = plusWeapon.DamageType;
            Weight = plusWeapon.Weight;
            Hardness = plusWeapon.Hardness;
            HitPoints = plusWeapon.HitPoints;
            RangeIncrement = plusWeapon.RangeIncrement;
            MaxRange = plusWeapon.MaxRange;
            IsBow = plusWeapon.IsBow;

            //IForgedWeapon
            AdditionalEnchantmentCost = plusWeapon.AdditionalEnchantmentCost;
            ToHitModifier = plusWeapon.ToHitModifier;
            DamageBonus = plusWeapon.DamageBonus;
            ComponentName = plusWeapon.ComponentName;

            //IPlusEnhancedWeapon
            PlusEnhancement = plusWeapon.PlusEnhancement;
            GeneratesLight = plusWeapon.GeneratesLight;
            RequiredFeats = plusWeapon.RequiredFeats;

            //IWeaponEnhancement

            // Properties needing method assignments
            //		IWeapon
            CostModifier = TallyCostModifiers();
            ThreatRange = CalculateThreatRange();
            //		IPlusWeapon and IWeaponEnchantment
            MinimumCasterLevel = DetermineMinimumCasterLevel(plusWeapon.MinimumCasterLevel);
            MagicAura = AssembleAuras();
            //		IWeaponEnchantment
            RequiredSpells = AssembleRequiredSpells();
            AdditionalRequirements = AssembleAdditionalRequirements();
            //		Non interface implemented properties
            ModifiedRangeIncrement = CalculateRangeModifier(plusWeapon.RangeIncrement);
            ModifiedMaxRange = CalculateRangeModifier(plusWeapon.MaxRange);

            SpecialInfo = AppendSpecialInfo();
        }

    public void ChangeWeapon( int newIndex )
    {
        InstancedWeapons[activeIndex].gameObject.SetActive(false);
        InstancedWeapons[activeIndex].PutAway();

        activeIndex = newIndex;

        activeWeapon = InstancedWeapons[activeIndex].GetComponent<IWeapon>();
        InstancedWeapons[activeIndex].gameObject.SetActive(true);
    }

 // Use this for initialization
 void Start()
 {
     if (primaryWeaponMount != null) {
         pWeapon = primaryWeaponMount.GetComponentInChildren<IWeapon> ();
         print (pWeapon);
     }
     if (secondaryWeaponMount != null) {
         sWeapon = secondaryWeaponMount.GetComponentInChildren<IWeapon> ();
     }
 }