CS_61A_ant_类的使用

 

    def reduce_armor(self, amount):
        """Reduce armor by AMOUNT, and remove the FireAnt from its place if it
        has no armor remaining.

        Make sure to damage each bee in the current place, and apply the bonus
        if the fire ant dies.
        """
        # BEGIN Problem 5
        "*** YOUR CODE HERE ***"
        def reflected_damage(amount):
            remaining_bees = []
            #for bee in self.place.bees:
                #if bee.armor > amount:
                    #remaining_bees.append(bee)# 好像这三行也不需要
            for bee in self.place.bees.copy():
                Insect.reduce_armor(bee,amount)
            #self.place.bees = remaining_bees 不需要
        reflected_damage(amount)
        print("DEBUG: remaining bees armor",[bee.armor for bee in self.place.bees])
        if self.armor <= amount:
            reflected_damage(self.damage)
            print("DEBUG: remaining bees armor",[bee.armor for bee in self.place.bees])
        Ant.reduce_armor(self,amount)

 

我的困难就是不知道如何使用Insect的reduce_armor，以下是Insect中，reduce_armor的定义，可以看到，有两个参数，其中的self 是自动引用。emm其实也就是一个属于Insect类的，有两个参数的函数，只不过他在这个类中代入的self。

以及，如何在改变list 内容的时候，继续进行迭代。他的方法是创建副本，[ self.place.bees.copy() ] 进行迭代，因为我只要用到里面的bee就行了，就相当于一个普通的list，我只需要里面的数字就行了。

 

【这个时候就是要注意到，bees是一个列表，但是里面存储的是bee这个对象，而不是一个数字，所以可以直接使用Insect.reduce_armor(bee,amount)，最后再更改self.place.bees】

 

可以注意到，这个函数中没有使用remove_from这个函数，是在使用reduce_armor的时候自动调用，所以如果我继续在函数中使用reduce_armor,就会产生对象不存在的问题。

    def reduce_armor(self, amount):
        """Reduce armor by AMOUNT, and remove the insect from its place if it
        has no armor remaining.

        >>> test_insect = Insect(5)
        >>> test_insect.reduce_armor(2)
        >>> test_insect.armor
        3
        """
        self.armor -= amount
        if self.armor <= 0:
            self.place.remove_insect(self)
            self.death_callback()

 

class A:
    def ping(self):
        print('ping',self)
        
class B(A):
    def pong(self):
        print('pong',self)
    
class C(A):
    def pong(self):
        print("PONG",self)

class D(B,C):

    def ping(self):
        super().ping()
        print('post-ping:',self)

    def pngpong(self):
        self.ping()
        super().ping() # A.ping()
        self.pong() # B.pong()
        super().pong() # B.pong()
        C.pong(self) # C.pong()

以上是多态的调用顺序，按照申明的顺序使用

进一步，关于class attribute and instance attribute,class attribute 的声明，是在类中定义的，而不是在函数内部定义。instance attribute 是在initiate function——[ def __init__(self, ...] 中定义的，class attribute是所有对象所共有的，而instance是单个对象独有的，与其他对象独立。

并且如果是class attribute ，在子类中也是class attribute，重载这个class attribute只需要在类中说明一下就行了，不需要在 initial function中说明，而如果是instance attribute，则子类必须要在initial function中声明，例子： armor and food_cost

class Ant(Insect):
    """An Ant occupies a place and does work for the colony."""

    implemented = False  # Only implemented Ant classes should be instantiated
    food_cost = 0
    # ADD CLASS ATTRIBUTES HERE
    blocks_path  = True

    def __init__(self, armor=1):
        """Create an Ant with an ARMOR quantity."""
        Insect.__init__(self, armor)

class WallAnt(Ant):
    name = "Wall"
    damage = 1
    food_cost = 4 #class  attribute 
    implemented = True
    def __init__(self, armor=4):
        Ant.__init__(self, armor) # armor is instance attribute

 

额外的加分

class Bee(Insect):
    """A Bee moves from place to place, following exits and stinging ants."""

    name = "Bee"
    damage = 1
    # OVERRIDE CLASS ATTRIBUTES HERE
    is_watersafe = True

    def __init__(self, armor, place=None):
        super().__init__(armor, place)
        self.direction = 1
        self.already_scared = False

    def sting(self, ant):
        """Attack an ANT, reducing its armor by 1."""
        ant.reduce_armor(self.damage)

    def move_to(self, place):
        """Move from the Bee's current Place to a new PLACE."""
        self.place.remove_insect(self)
        place.add_insect(self)

    def blocked(self):
        """Return True if this Bee cannot advance to the next Place."""
        # Phase 4: Special handling for NinjaAnt
        # BEGIN Problem 7
        # return self.place.ant is not None
        if self.place.ant is None or (self.place.ant.blocks_path is False):
            return False
        else:
            return True
        # END Problem 7

    def action(self, gamestate):
        """A Bee's action stings the Ant that blocks its exit if it is blocked,
        or moves to the exit of its current place otherwise.

        gamestate -- The GameState, used to access game state information.
        """
        destination = self.place.exit
        # Extra credit: Special handling for bee direction
        # BEGIN EC
        "*** YOUR CODE HERE ***"
        # if bee's direction is -1,then destination is self.place.entrance
        # if self.place.entrance is Hive,then the bee doesn't action
        # END EC
        if self.direction == -1:
            destination = self.place.entrance
            if isinstance(destination, Hive):
                destination = self.place

        if self.blocked():
            self.sting(self.place.ant)
        elif self.armor > 0 and destination is not None:
            self.move_to(destination)

    def add_to(self, place):
        place.bees.append(self)
        Insect.add_to(self, place)

    def remove_from(self, place):
        place.bees.remove(self)
        Insect.remove_from(self, place)


############
# Statuses #
############


def make_slow(action, bee):
    """Return a new action method that calls ACTION every other turn.

    action -- An action method of some Bee
    """
    # BEGIN Problem EC
    "*** YOUR CODE HERE ***"

    def slow_action(gamestate):
        if gamestate.time % 2 == 0:
            action(gamestate)

    return slow_action
    # END Problem EC


def make_scare(action, bee):
    """Return a new action method that makes the bee go backwards.

    action -- An action method of some Bee
    """
    # BEGIN Problem EC
    "*** YOUR CODE HERE ***"

    def scare_action(gamestate):
        # make the bee's direction divert
        # then make the bee act ,if already 2 turns ,make the bee's direction turn back 1
        bee.direction = -1
        action(gamestate)
        bee.direction = 1

    return scare_action
    # END Problem EC


def apply_status(status, bee, length):
    """Apply a status to a BEE that lasts for LENGTH turns."""
    # BEGIN Problem EC
    "*** YOUR CODE HERE ***"
    original_action = bee.action
    new_action = status(bee.action, bee)

    def alt_action(gamestate):
        nonlocal length
        if length > 0:
            new_action(gamestate)
            length -= 1
        else:
            original_action(gamestate)

    bee.action = alt_action
    # END Problem EC


class SlowThrower(ThrowerAnt):
    """ThrowerAnt that causes Slow on Bees."""

    name = "Slow"
    food_cost = 4
    # BEGIN Problem EC
    implemented = True  # Change to True to view in the GUI
    # END Problem EC

    def throw_at(self, target):
        if target:
            apply_status(make_slow, target, 3)


class ScaryThrower(ThrowerAnt):
    """ThrowerAnt that intimidates Bees, making them back away instead of advancing."""

    name = "Scary"
    food_cost = 6
    # BEGIN Problem EC
    implemented = True  # Change to True to view in the GUI
    # END Problem EC

    def throw_at(self, target):
        # BEGIN Problem EC
        "*** YOUR CODE HERE ***"
        # if the target bee is not be scare ,then it is true
        # then call the apply_status method
        if target.already_scared is False:
            apply_status(make_scare, target, 2)
            target.already_scared = True
        # END Problem EC

apply_status 可以好好看看