def __init__(self, mainRef, attributes):
        print("Enemy instantiated")
        Unit.__init__(self)
        FSM.__init__(self, 'playerFSM')

        self._mainRef = mainRef
        self._playerRef = mainRef.player
        self._AIworldRef = mainRef.AIworld
        self._enemyListRef = mainRef.enemyList
        self._ddaHandlerRef = mainRef.DDAHandler
        self._stateHandlerRef = mainRef.stateHandler
        self._scenarioHandlerRef = mainRef.scenarioHandler

        #self.topEnemyNode = mainRef.mainNode.attachNewNode('topEnemyNode')
        self.initEnemyNode(mainRef.mainNode)

        utils.enemyDictionary[self.enemyNode.getName()] = self

        self.loadEnemyModel(attributes.modelName)
        self.initAttributes(attributes)
        self.initEnemyAi()

        self.initEnemyDDA()

        self.initEnemyCollisionHandlers()
        self.initEnemyCollisionSolids()

        #self.request('Idle')
        self.request('Disabled')

        # Start enemy updater task
        self.enemyUpdaterTask = taskMgr.add(self.enemyUpdater, 'enemyUpdaterTask')

    def __init__(self, mainObj, position, yon=4, layer=0, attrDict={}):
        self.type = 'Kurt'
        Unit.__init__(self, mainObj, position, yon, attrDict)

        self.image = self.changeImage('Kurt', yon) # Oyunun başında ilk yüklenen unit resim dosyasi
        self.rect = self.image.get_rect()
        self.rect.topleft = position
        self.layer = layer # LayeredUpdates grubu için gerekiyor
        
        self.colRect = copy(Kurt.colRect[self.yon])
        self.colRect.topleft = (self.colRect.topleft[0] + self.rect.topleft[0], self.colRect.topleft[1] + self.rect.topleft[1])
        
        # çarpışmalarda kullanılan noktalar
        self.colPoints = None
        
        self.tolerans = 0
        self.speed = 4
        
        if self.player.type == Player.human_player:
            self.ai = KurtFSM(self, human=True)
        else:
            self.ai = KurtFSM(self)
        
        # unit'in gerçek pozisyonunu (reel sayılarla) tutar. rect'e atılırken int'e dönüştürülür.
        self.yer = Vector2(*self.colRect.center)

 def button_events(self, event):
     # check for clicks on a button 
     # (not in mousebuttondown to allow for mouseover highlight)         
     for button in self.buttons.btn_list:
         if "click" in button.handleEvent(event):
             if button.caption == "B":
                 self.player_command.player_msg = \
                     "That was the round button"
             if button.caption == "hi":
                 self.player_command.player_msg = \
                     "Nothing here but us buttons."
             if button.caption == "MAKE IT SO!":
                 Unit.movement(self.grid_map, self.players)
                 self.player_command.player_msg = ""
     """ check for unit-related button events """
     for player in self.players.active_list:
         for group in player.units:
             for unit in group.group_list:
                 for button in unit.unit_btns:
                     if "click" in button.handleEvent(event):
                         if button.caption == "B":
                             unit.active = "True"
                             unit.txt_status = "Targeting"
                             self.player_command.player_msg = \
                                 "Click on target tile."
                         elif button.caption == "A":
                             unit.txt_status = "A Button"
                         else:
                             unit.txt_status = "Unidentified Button"

	def __init__(self, player, sig, model, skeleton, animations, inventory):
		'''
		Constructor
		'''
		Unit.__init__(player, sig, numControllers = 1)
		self.player = player
		self.enabled = False

def generate_one_unit(i, paper, problem_list):
    """
    随机生成一个个体
    """

    unit = Unit()
    unit.id = i + 1

    each_type_count = paper.each_type_count
    while paper.total_score != unit.sum_score:
        unit.problem_list = []
        for j in range(len(each_type_count)):
            one_type_problem = [
                p for p in problem_list
                if p.type == j+1 and is_contain_points(p, paper)]

            for k in range(0, each_type_count[j]):
                length = len(one_type_problem)
                index = randint(0, length - k - 1)
                unit.problem_list.append(one_type_problem[index])
                one_type_problem[index], one_type_problem[length-k-1] = \
                    one_type_problem[length-k-1], \
                    one_type_problem[index]

    return unit

    def __init__(self, is_intaractive_run, an_errhandler):
        """ EvalVisitorを初期化して応答する．
        """
        self.is_test = False
        self.is_intaractive_run = is_intaractive_run
        self.errhandler = an_errhandler
        self.scopes = ScopeList()
        self.is_break = False
        self.is_return = False
        self.return_value = UnitXObject(value=None, varname=None, unit=None, token=None, is_none=True)

        this_dir, _ = os.path.split(__file__)
        data_path = os.path.join(this_dir, Constants.SYSTEM_UNIT_DATA)
        self.unit_manager = UnitManager(data_path) # Sets a database(data/unit_table.dat) for calculating units.
        self.stdlib = Stdlib()
        self.NULL_UNITX_OBJ = UnitXObject(value=None, varname=None, is_none=True, unit=Unit(), token=None)
        
        #
        # Sets a mediator to each classes for a management,
        # because this class is a mediator class.
        # Also, UnitXObject, Unit, Scope classes have to create many new instances.
        # So, We set a mediator by using classmethod.
        #
        self.scopes.set_mediator(self)
        self.unit_manager.set_mediator(self)
        self.stdlib.set_mediator(self)
        UnitXObject.set_mediator(self)
        Unit.set_mediator(self)
        Scope.set_mediator(self)
        DefinedFunction.set_mediator(self)

        UnitXObject.manager = self.get_unit_manager()
        UnitXObject.scopes = self.get_scopes()

    def visitPrimary(self, ctx):
        """ それぞれのPrimaryの値をUnitXObjectにラップして，応答する．

            Identifier: variable or function
            literal: number, string, boolean, none
            PAREN=(): expression
            BRACK=[]: list
        """
        unit = Unit()
        if ctx.unit(): unit = self.visitUnit(ctx.unit())

        if ctx.Identifier():
            # Here
            varname = ctx.Identifier().getText()
            unitx_obj = UnitXObject(value=None, varname=varname, unit=unit)
            """
            current_scope = self.get_scopes().peek()
            if varname in current_scope:
                unitx_obj = current_scope[varname]
                if not unit.is_empty():
                    unitx_obj.unit = unit
            else:
                unitx_obj = UnitXObject(value=None, varname=varname, unit=unit)
            """

            found_scope = self.get_scopes().peek().find_scope_of(varname)
            if found_scope:
                unitx_obj = found_scope[varname]
                if not unit.is_empty():
                    unitx_obj.unit = unit
            else:
                unitx_obj = UnitXObject(value=None, varname=varname, unit=unit)
            unitx_obj.token = ctx.Identifier().getSymbol()

        elif ctx.literal():
            unitx_obj = self.visitLiteral(ctx.literal())
            unitx_obj.unit = unit

        elif ctx.start.type == UnitXLexer.LPAREN:
            unitx_obj = self.visitExpression(ctx.expression(i=0))
            if not unit.is_empty():
                unitx_obj.unit = unit
            unitx_obj.token = ctx.start

        elif ctx.start.type == UnitXLexer.LBRACK:
            unitx_objs = []
            for an_expr in ctx.expression():
                an_obj = self.visitExpression(an_expr)
                if not unit.is_empty():
                    an_obj.unit = unit
                unitx_objs.append(an_obj)

            unitx_obj = UnitXObject(value = unitx_objs, varname = None, unit=unit, token=ctx.start)

        else:
            if not self.is_intaractive_run:
                raise Exception("Syntax error. EvalVisitor#visitPrimary") # Never happen.

        assert(isinstance(unitx_obj, UnitXObject))
        return unitx_obj

 def value_unit_to_number(self, param, value):
     # string is of the form "32.3L"
     unit = value[-1]
     #v = float(value[:-1])
     v = self.str_to_float(param, value[:-1])
     if (Unit.get(param) != unit):
         v = Unit.convert(unit, Unit.get(param), v)
     return round(v, self.precision)

 def __init__(self, constraint, x=0, y=0, direction=(1, 0), kind=0):
     Unit.__init__(self, constraint, x, y, direction, 160, 65)
     if kind:
         self.kind = 'lion'
         self.health = 200
     else:
         self.kind = 'blue'
         self.health = 100

	def handleCubeIntoCollision(self, entry):
		try:
			fromName = entry.getFromNodePath().getParent().getName()
			Unit.collideWithObstacle(self.actors[fromName])
			if fromName == "player" and self.collisionSound.status() is not self.collisionSound.PLAYING:
				self.collisionSound.play()
		except:
			pass

	def update(self, time):
		self.applyForceFrom(-0.1, self.player.getPos())
		
		Unit.update(self, time)
		
		angle = math.atan2(self.player.getY() - self.getY(), \
							self.player.getX() - self.getX())
		self.setH(angle * 180 / math.pi)

    def reduce_unit(self, guide_unit=None):
        """
        Combine similar component units and scale, to form an
        equal Quantity in simpler units.

        Returns underlying value type if unit is dimensionless.
        """
        key = (self.unit, guide_unit)
        if key in Quantity._reduce_cache:
            (unit, value_factor) = Quantity._reduce_cache[key]
        else:
            value_factor = 1.0
            canonical_units = {} # dict of dimensionTuple: (Base/ScaledUnit, exponent)
            # Bias result toward guide units
            if guide_unit is not None:
                for u, exponent in guide_unit.iter_base_or_scaled_units():
                    d = u.get_dimension_tuple()
                    if d not in canonical_units:
                        canonical_units[d] = [u, 0]
            for u, exponent in self.unit.iter_base_or_scaled_units():
                d = u.get_dimension_tuple()
                # Take first unit found in a dimension as canonical
                if d not in canonical_units:
                    canonical_units[d] = [u, exponent]
                else:
                    value_factor *= (u.conversion_factor_to(canonical_units[d][0])**exponent)
                    canonical_units[d][1] += exponent
            new_base_units = {}
            for d in canonical_units:
                u, exponent = canonical_units[d]
                if exponent != 0:
                    assert u not in new_base_units
                    new_base_units[u] = exponent
            # Create new unit
            if len(new_base_units) == 0:
                unit = dimensionless
            else:
                unit = Unit(new_base_units)
            # There might be a factor due to unit conversion, even though unit is dimensionless
            # e.g. suppose unit is meter/centimeter
            if unit.is_dimensionless():
                unit_factor = unit.conversion_factor_to(dimensionless)
                if unit_factor != 1.0:
                    value_factor *= unit_factor
                    # print "value_factor = %s" % value_factor
                unit = dimensionless
            Quantity._reduce_cache[key] = (unit, value_factor)
        # Create Quantity, then scale (in case value is a container)
        # That's why we don't just scale the value.
        result = Quantity(self._value, unit)
        if value_factor != 1.0:
            # __mul__ strips off dimensionless, if appropriate
            result = result * value_factor
        if unit.is_dimensionless():
            assert unit is dimensionless # should have been set earlier in this method
            if is_quantity(result):
                result = result._value
        return result

	def handleUnitIntoCollision(self, entry):
		try:
			fromName = entry.getFromNodePath().getParent().getName()
			intoName = entry.getIntoNodePath().getParent().getName()
			Unit.collideWithUnit(self.actors[intoName], self.actors[fromName])
			if (fromName == "player" or intoName == "player") and self.collisionSound.status() is not self.collisionSound.PLAYING:
				self.collisionSound.play()
		except:
			pass

	def __init__(self, models = None, anims = None, sphereString = None, game = None, xStart = 0, yStart = 0, zStart = 0):
		Unit.__init__(self, models, anims, sphereString, game, xStart, yStart, zStart)
		
		#set up sounds
		self.deathSound = game.loader.loadSfx(SFX_PATH + "enemy_death.wav")
		
		self.randomMovement = 0
		self.randomMovementMax = 30 * 7
		self.minRandomVel = 1000
		self.maxRandomVel = 2000

 def test_hero_attack(self):
     hero = Unit(100, 100, 5)
     hero.learn(Spell('a', 10, 10, 2))
     self.dungeon.spawn(hero)
     self.dungeon.move_hero('down')
     self.dungeon.move_hero('down')
     self.assertEqual('Nothing in casting range 2',
                      self.dungeon.hero_attack(by="spell"))
     self.dungeon.move_hero('down')
     self.assertIsInstance(self.dungeon.hero_attack(by='spell'), Fight)

    def __init__(self, name, title, health, mana, mana_regen):
        self.name = name
        self.title = title
        self.mana_regen = mana_regen
        Unit.__init__(self, health, mana, name)

        self.phisical_damage = 0
        self.magic_damage = 0

        self.max_equiped_weapons = 0
        self.max_learned_spells = 0

 def __init__(self, sport, xparam, yparam, xvals = None, yvals = None):
     self.xparam = xparam
     self.yparam = yparam
     self.sport = sport
     if (xvals is None):
         xvals = []
     if (yvals is None):
         yvals = []
     self.xvals = xvals
     self.yvals = yvals
     self.xlabel = self.xparam + " (%s)"%(Unit.get(self.xparam))
     self.ylabel = self.yparam + " (%s)"%(Unit.get(self.yparam))

	def __init__(self, team, sig, model, numControllers, keyinput):
		'''
		Constructor
		'''
		self.input = keyinput
		
		self.model = loader.loadModel(model)
		
		tankNode = render.attachNewNode(ActorNode("tank-physics"))
		tankNode.detachNode()
		self.tankNode = tankNode
		actorNode = tankNode.node()
		base.physicsMgr.attachPhysicalNode(actorNode)
		
		actorNode.getPhysicsObject().setMass(1000)
		
		fromObject = tankNode.attachNewNode(CollisionNode('tank-coll'))
		fromObject.node().addSolid(CollisionSphere(0, 0, 0, 1))
		self.model.reparentTo(tankNode)
		
		pusher = PhysicsCollisionHandler()
		pusher.addCollider(fromObject,tankNode)
		
		base.cTrav.addCollider(fromObject, pusher)
		
		fromObject.show()
		
		Unit.__init__(self, sig, numControllers)
		self.enabled = False
		self.camera = VehicleCamera(self.tankNode, Vec3(0,-10,5))
		
		self.rotation = Rotation(self.tankNode, self.camera.camNode)
		
		self.engineFN=ForceNode('tank-hover-engine-front-left')
		self.engineFNP=tankNode.attachNewNode(self.engineFN)
		
		self.engineNodes = [NodePath("front-left-engine") ,
							NodePath("front-right-engine"),
							NodePath("back-left-engine")  ,
							NodePath("back-right-engine")  ]
		
		for i in range(0,4):
			self.engineNodes[i].reparentTo(tankNode)
			self.engineNodes[i].setPos(tankNode, ENGINELIST[i])
			blah = loader.loadModel(model)
			blah.reparentTo(self.engineNodes[i])
			blah.setScale(0.1)
		
		self.linearForce = None
		self.rotateForce = None
		
		self.movement = Movement(tankNode)
		self.movement.enable()

 def __init__(self, constraint, x=0, y=0, direction=(1, 0), size=0):
     radius = (size * 15 + 41) / 2
     Unit.__init__(self, constraint, x, y, direction, 80, radius)
     SinkingItem.__init__(self, constraint, x, y, 80, radius)
     self.hungry = False
     self.growth = 0
     # Fish size: 0 - small, 1 - normal, 2 - big
     self.size = size
     self.last_fed = int(time())
     self.grow_time = int(time())
     self.drop_coin = False
     # Prevents multiple coin drops in the same second.
     self.coin_drop_time = time()

 def test_get_new_commands(self):
     ip = "127.0.0.1"
     port = 8080
     unit_id = "3c82ef61-0875-41d3-99ba-101672d79d6b"
     testunit = Unit(ip, unit_id, fallback_units = [])
     # Post five tasks to taskboard
     for _ in xrange(5):
         task = create_valid_task()
         # Posting a task should result in no error
         testunit.post_task(task)
     tasks = testunit.get_new_commands()
     print tasks
     self.assertTrue(len(tasks) == 5)