Python World.reset方法代码示例

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import reset [as 别名]
class Game:
  world = 0
  camera = 0
  background = 0
  gui = 0
  mainbody = 0
  gameResult = 0
  currentLevel = 1
  def __init__(self):
    self.world = World()
    self.camera = Camera()
  def setupMenu(self):
    self.gui = Gui()
    self.gui.setupMenu(self)
    self.setupBackground('levels/menu.xml')
  def setupLevel(self, *largs):
    print "CURRENT LEVEL %d"%self.currentLevel
    
    levelstring = 'levels/level'
    levelstring +=`self.currentLevel`.zfill(2)
    levelstring +='.xml'
    print levelstring
    if os.path.isfile(levelstring):
      self.camera.scale = 1.1
      self.gui.messaging.reset()
      self.gameResult = 0
      self.setupWorld(levelstring)
      self.setupBackground(levelstring)
      self.setupShip(levelstring)
      self.gui.messaging.displayText('Level %d'%(self.currentLevel),60)
    else:
      self.gui.messaging.reset()
      self.mainbody = 0
      self.setupWorld('levels/endgame.xml')
      self.setupBackground('levels/endgame.xml')
      self.gui.messaging.displayText('Congratulations ! !',-1)   

  def checkVictoryCondition(self):
    if self.mainbody.isStable() == 0:
      return 0
    landingzone = self.world.getLandingzone()
    if landingzone.checkBody(self.mainbody) == 1:
      return 1
    else :
      return -1
  def gameIsRunning(self):
    if self.mainbody != 0 and self.gameResult == 0:
      return 1
  def setupBackground(self,filename):
    self.background = Background()
    domLevel = parse(filename)
    backgroundNodes = domLevel.getElementsByTagName("background")
    backgroundNode = backgroundNodes[0]
    for node in backgroundNode.childNodes:
      if node.localName == "layer":
        texturename = 0
        tilesizex = 0
        tilesizey = 0
        positionx = 0
        positiony = 0
        layersizex = 0
        layersizey = 0
        offsetx = 0
        offsety = 0
        for childnode in node.childNodes:
          if childnode.localName == "texture":
            texturename = childnode.getAttribute('value')
          if childnode.localName == "tilesize":
            values = childnode.getAttribute('value').split(',')
            if values[0] == 'screenw': 
              tilesizex = Config.getint('graphics', 'width')
            else:
              tilesizex = float(values[0])
            if values[1] == 'screenh': 
              tilesizey = Config.getint('graphics', 'height')
            else:
              tilesizey = float(values[1])
          if childnode.localName == "position":
            values = childnode.getAttribute('value').split(',')
            if values[0] == 'screenw':
              positionx = Config.getint('graphics', 'width')
            else:
              positionx = float(values[0])
            if values[1] == 'screenh':
              positiony = Config.getint('graphics', 'height')
            else:
              positiony = float(values[1])

          if childnode.localName == "offset":
            values = childnode.getAttribute('value').split(',')
            if values[0] == 'screenw': 
              offsetx = Config.getint('graphics', 'width')
            else:
              offsetx = float(values[0])
            if values[1] == 'screenh': 
              offsety = Config.getint('graphics', 'height')
            else:
              offsety = float(values[1])
          if childnode.localName == "layersize":
            values = childnode.getAttribute('value').split(',')
#.........这里部分代码省略.........

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import reset [as 别名]
class Shooting(GameState):
    """Main gameplay state."""
    colors = {
            "day": {
                    "sky": pg.Color("skyblue"),
                    "grass": pg.Color(125, 183, 100)},
            "night": {
                    "sky": pg.Color(1, 2, 7),
                    "grass":  pg.Color(11, 15, 8)}}

    def __init__(self):
        super(Shooting, self).__init__()
        self.animations = pg.sprite.Group()
        self.world = World(True)
        self.cooldown = 0
        self.cooldown_duration = 250
        self.mag_size = 4
        self.bullets_in_mag = self.mag_size
        self.crosshairs_day = prepare.GFX['crosshairs_day']
        self.crosshairs_night = prepare.GFX['crosshairs_night']
        self.crosshairs = self.crosshairs_day
        self.crosshairs_rect = self.crosshairs.get_rect()
        self.switched = False
        self.bullet = pg.transform.scale(prepare.GFX['bullet'], (15,100))
        self.bullet_rect = self.bullet.get_rect()
        self.bullet_spacer = 5
        self.clay_score = 0
        self.clay_scores = []
        self.clay_score_timer = 0.0

    def startup(self, persistent):
        self.persist = persistent
        self.score = 0
        self.score_label = Label("{}".format(self.score),
                                           {"topleft": (5, 5)}, font_size=64)
        self.world.reset()
        pg.mouse.set_visible(False)

    def get_event(self, event):
        if event.type == pg.QUIT:
            pg.mouse.set_visible(True)
            self.quit = True
        elif event.type == pg.KEYUP:
            if event.key == pg.K_ESCAPE:
                self.quit = True
            elif event.key == pg.K_r:
                self.on_reload()
        elif event.type == pg.MOUSEBUTTONDOWN:
            if event.button == 1:
                self.shoot()
            elif event.button == 3:
                self.on_reload()
            
    def on_reload(self):
        self.bullets_in_mag = self.mag_size
        prepare.SFX["reload"].play()
            

    def update(self, dt):
        self.cooldown += dt
        self.animations.update(dt)
        self.world.update(dt)
        for sprite in self.world.all_sprites:
            self.world.all_sprites.change_layer(sprite, sprite.z * -1)
        self.score_label.set_text("{}".format(int(self.score)))
        if self.world.done:
            self.done = True
            self.persist["score"] = int(self.score)
            self.next_state = "HIGHSCORES"
        self.crosshairs_rect.center = pg.mouse.get_pos()
        if self.world.nighttime:
            self.crosshairs = self.crosshairs_night
        else:
            self.crosshairs = self.crosshairs_day
        if self.world.h >= 19:
            if not self.switched:
                prepare.SFX["clicker"].play()
                self.switched = not self.switched
        #elif self.world.h < 19:
        #    self.switched = False
            
        if self.world.h >= 6 and self.world.h < 19:
            if self.switched:
                prepare.SFX["clicker"].play()
                self.switched = not self.switched
            
        self.remove_clay_score()
            
    def shoot(self):
        if self.cooldown < self.cooldown_duration:
            return
        else:
            self.cooldown = 0
        
        if not self.bullets_in_mag:
            return
        else:
            self.bullets_in_mag -= 1
            
        prepare.SFX["gunshot"].play()
#.........这里部分代码省略.........

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import reset [as 别名]
class Shooting(GameState):
    """Main gameplay state."""
    colors = {
            "day": {
                    "sky": pg.Color("skyblue"),
                    "grass": pg.Color(125, 183, 100)},
            "night": {
                    "sky": pg.Color(1, 2, 7),
                    "grass":  pg.Color(11, 15, 8)}}

    def __init__(self):
        super(Shooting, self).__init__()
        self.animations = pg.sprite.Group()
        self.world = World(True)
        self.cooldown = 0
        self.cooldown_duration = 250

    def startup(self, persistent):
        self.persist = persistent
        self.score = 0
        self.score_label = Label("{}".format(self.score),
                                           {"topleft": (5, 5)}, font_size=64)
        self.world.reset()

    def get_event(self, event):
        if event.type == pg.QUIT:
            pg.mouse.set_visible(True)
            self.quit = True
        elif event.type == pg.KEYUP:
            if event.key == pg.K_ESCAPE:
                self.quit = True
        elif event.type == pg.MOUSEBUTTONDOWN:
            self.shoot()

    def update(self, dt):
        self.cooldown += dt
        self.animations.update(dt)
        self.world.update(dt)
        for sprite in self.world.all_sprites:
            self.world.all_sprites.change_layer(sprite, sprite.z * -1)
        self.score_label.set_text("{}".format(int(self.score)))
        if self.world.done:
            self.done = True
            self.persist["score"] = int(self.score)
            self.next_state = "HIGHSCORES"

    def shoot(self):
        if self.cooldown < self.cooldown_duration:
            return
        else:
            prepare.SFX["gunshot"].play()
            self.cooldown = 0
        for clay in [x for x in self.world.clays if not x.shattered]:
            if clay.rect.collidepoint(pg.mouse.get_pos()):
                clay.shatter()
                self.add_points(clay)

    def add_points(self, clay):
        modifier = clay.z / 50.
        score = modifier * (100. / clay.speed)
        self.score += score

    def draw(self, surface):
        surface.fill(self.world.sky)
        surface.fill(self.world.grass, self.world.ground_rect)
        self.world.all_sprites.draw(surface)
        self.score_label.draw(surface)

# 需要导入模块: from world import World [as 别名]
# 或者: from world.World import reset [as 别名]
class Simulator(object):
    def __init__(self, rabbit_num, fox_num, world_size):
        self.rabbit_list = []
        self.fox_list = []
        self.world = World(world_size)

        for i in range(1, rabbit_num):
            self.rabbit_list.append(Rabbit(self.world, i))

        for r in self.rabbit_list:
            self.world.marking_rabbit(r)

        for i in range(1, fox_num):
            self.fox_list.append(Fox(self.world, i))

        for f in self.fox_list:
            self.world.marking_fox(f)

        pass



    def print(self):
        self.world.print()
        pass

    def reset(self):
        self.world.reset()
        for r in self.rabbit_list:
            self.world.marking_rabbit(r)
        for f in self.fox_list:
            self.world.marking_fox(f)

    def move(self):
        for r in self.rabbit_list:
            r.move(self.world)

        for f in self.fox_list:
            f.move(self.world)



    def eat(self):
        rabbit_die = []
        for f in self.fox_list:
            temp = f.eat(self)
            if temp[0] != -1 and temp[1] != -1 :
                for r in self.rabbit_list:
                    if temp[0] == r.x and temp[1] == r.y:
                        rabbit_die.append(r)

        for dr in rabbit_die:
            self.rabbit_list.remove(dr)




    def starve(self):
        fox_starve = []
        for f in self.fox_list:
            if f.is_too_old():
                fox_starve.append(f)

        for sf in fox_starve:
            self.fox_list.remove(sf)


    def getold(self):
        for f in self.fox_list:
            f.get_old()
            print(f.count)