def test_critical_hit_true_and_false(self):
     new_weapon = Weapon("Mighty Axe", 25, 0.2)
     results = []
     for i in range(10):
         results.append(new_weapon.critical_hit())
     self.assertIn(True, results)
     self.assertIn(False, results)

	def rubber_bullet(self):
		'''
		Патрон с резиновой пулей.
		:return: int
		'''
		return int(
			(Weapon.special_carbine(self) * 250) + (Weapon.guns(self) * 48))

	def __init__(self, pos = (0,0), **images) :
		Projectile.__init__ (self, pos, **images)
		Weapon.__init__ (self, pos, **images)
		self._has_been_launched = False
		self.set_knockback_factor (5)
		self._damage = 5
		self._name = "Bomb"

	def automat_catridges(self):
		'''
		5,45 и 7,62 мм автоматные патроны.
		:return: int
		'''
		return int(
			(Weapon.automat(self) * 246) + (Weapon.hand_gun(self) * 750))

class TestWeapon(unittest.TestCase):

    def setUp(self):
        self.sword = Weapon('Sword', 15, 0.4)

    def test_init_weapon(self):
        self.assertEqual(self.sword.type, 'Sword')
        self.assertEqual(self.sword.damage, 15)
        self.assertEqual(self.sword.critical_strike_percent, 0.4)

    def test_critical_hit(self):
        critical_hit_used = False
        critical_hit_not_used = False
        while True:
            if self.sword.critical_hit():
                critical_hit_used = True
                return
        while True:
            if not self.sword.critical_hit():
                critical_hit_not_used = True
                return
        self.assertTrue(critical_hit_used)
        self.assertFalse(critical_hit_not_used)

    def test_critical_raises_error(self):
        with self.assertRaises(ValueError):
            axe = Weapon('Axe', 25, 2)

	def pistol_catridges(self):
		'''
		Пистолетные патроны.
		:return: int
		'''
		return int((Weapon.guns(self) * 24) + (
			Weapon.pistol_gun(self) * 100))

class WeaponTest(unittest.TestCase):

    def setUp(self):
        self.weapon = Weapon("Spike", 200)

    def test_is_instance(self):
        self.assertTrue(isinstance(self.weapon, Weapon))

    def test_valid_members(self):
        self.assertEqual(self.weapon.name, "Spike")
        self.assertEqual(self.weapon.damage, 200)

    def test_str(self):
        expected = "{} with damage = {}"
        expected = expected.format(self.weapon.name, self.weapon.damage)
        self.assertEqual(str(self.weapon), expected)

    def test_get_functions(self):
        self.assertEqual(self.weapon.get_name(), "Spike")
        self.assertEqual(self.weapon.get_damage(), 200)

    def test_prepare_json(self):
        data = {
            "name": "Spike",
            "damage": 200
        }
        self.assertEqual(self.weapon.prepare_json(), data)

 def test_critical_hit(self):
     weapon = Weapon("axe", 10, 0.5)
     results = []
     for x in range(1000):
         results.append(weapon.critical_hit())
     self.assertTrue(True in results)
     self.assertTrue(False in results)

 def test_weapon_no_crit(self):
     new_weapon = Weapon("alwayscrit", 10, 0)
     for i in range(0, 1000):
         iscrit = new_weapon.critical_hit()
         if iscrit:
             break
     self.assertFalse(iscrit)

 def test_weapon_critical_hit(self):
     new_weapon = Weapon("alwayscrit", 10, 1)
     for i in range(0, 10):
         iscrit = new_weapon.critical_hit()
         if not iscrit:
             break
     self.assertTrue(iscrit)

	def update (self) :
		assert (self._cooldown_frames_left >= 0)

		if self._cooldown_frames_left > 0 :
			self._cooldown_frames_left -= 1

		Weapon.update (self)

 def __init__(self):
    Weapon.__init__(self)
    self.enhancement = 2
    self.damageDie = 'd8'
    self.numDie = 0
    self.extraCrit = '2d6'
    self.weaponType = 'implement'
    self.keywords = ['implement',]

class WeaponTest(unittest.TestCase):
    def setUp(self):
        self.weapon = Weapon("gun", 40)

    def test_damage(self):
        self.assertEqual(self.weapon.get_damage(), 40)

    def test_name(self):
        self.assertEqual(self.weapon.get_name(), 'gun')

	def __init__(self, pos = (0,0), **images) :
		Weapon.__init__ (self, pos,**images)
		self._firing_velocity = 20
		self._magazine = []
		self._cooldown = 30
		self._name = "Firearm"

		#used for timing
		self._cooldown_frames_left = 0

 def __init__(self):
     Weapon.__init__(self)
     self.enhancement = 3
     self.damageDie = "d8"
     self.numDie = 1
     self.critDamage = "3d6"
     self.damageType = "str"
     self.weaponType = "dagger"
     self.keywords = ["dagger", "lightBlade", "radiant"]
     self.extraCrit = "3d6"

 def test_weapon_critical(self):
     new_weapon = Weapon("Ico", 100, 0.2)
     self.assertEqual(new_weapon.name, "Ico")
     self.assertEqual(new_weapon.damage, 100)
     self.assertEqual(new_weapon.critical_strike_percent, 0.2)
     weapontests = []
     for n in range(1, 11):
         weapontests.append(new_weapon.critical_hit())
     self.assertIn(200, weapontests)
     self.assertIn(False, weapontests)

 def test_critical_hit(self):
     test_weapon = Weapon("axe", 20, 0.2)
     is_False = False
     is_True = False
     for i in range(100):
         if test_weapon.critical_hit():
             is_True = True
         else:
             is_False = True
     self.assertTrue(is_True)
     self.assertTrue(is_False)

    def update(self, *args):
        Weapon.update(self, *args)

        if self.cooldown > 0:
            self.cooldown -= 1
            return

        self.cooldown = 5

        if self.engaged:
            bp = self.pos
            bv = (self.target_pos - bp).normal * 1400
            if bv.x != 0 or bv.y != 0:
                self.fire_sound.play()
                bullet.pool.fire(bp.x, bp.y, bv.x, bv.y) 

def test_boltgun():
    boltgun = Weapon("Boltgun", 24, 4, 5, ["rapid fire"])
    expected  = "        Range S  AP Type\n"
    expected += "Boltgun  24\"  4  5  rapid fire"

    output = boltgun.print_statline()

    result = output == expected

    if not result:
        print "expected:"
        print expected
        print output
        print "^- output"

    assert result

	def cartridge_lighting(self):
		'''
		26 мм патрон осветительный.
		26 мм патроны красного, зеленого, желтого огня каждого вида.
		:return: int
		'''
		return int(Weapon.signal_pistol(self) * 5)