Example #1
0
    def main(self):
        """main function"""
        board = Board(15, 15, 32)
        board.read_map('resources/structure.txt')
        board.set_components()
        mac = Actor(board.start)
        gui = Gui(board.width, board.height)

        while True:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()
                elif event.type == pygame.KEYDOWN:
                    if mac.status == 'alive':
                        if event.key == pygame.K_UP:
                            mac.move(0, -32, board)
                        elif event.key == pygame.K_LEFT:
                            mac.move(-32, 0, board)
                        elif event.key == pygame.K_DOWN:
                            mac.move(0, +32, board)
                        elif event.key == pygame.K_RIGHT:
                            mac.move(+32, 0, board)
                    else:
                        if event.key == pygame.K_RETURN:
                            return self.main()
                        elif event.key == pygame.K_ESCAPE:
                            pygame.quit()
                            sys.exit()

            gui.draw(mac, board)
            pygame.display.update()
Example #2
0
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(',')
            if values[0] == 'screenw': 
              layersizex = Config.getint('graphics', 'width')
            else:
              layersizex = float(values[0])
            if values[1] == 'screenh': 
              layersizey = Config.getint('graphics', 'height')
            else:
              layersizey = float(values[1])
        layer = Layer(TextureHelper.loadTextureFromFile(texturename),tilesizex,tilesizey,positionx,positiony,offsetx,offsety,layersizex,layersizey)
        self.background.addLayer(layer)
    
  def setupShip(self,filename):
    domLevel = parse(filename)
    shipNodes = domLevel.getElementsByTagName("ship")
    shipNode = shipNodes[0]
    self.mainbody = Body()
    for node in shipNode.childNodes:
      if node.localName == "position":
        position = node.getAttribute('value')
        values = position.split(',')
        self.mainbody.setPosition(float(values[0]),float(values[1]))
      if node.localName == "mobile":
        m = Mobile()
        for childnode in node.childNodes:
          if childnode.localName == "position":
            values = childnode.getAttribute('value').split(',')
            m.setPosition(float(values[0]),float(values[1]))
          if childnode.localName == "velocity":
            values = childnode.getAttribute('value').split(',')
            m.setVelocity(float(values[0]),float(values[1]))
          if childnode.localName == "thrust":
            values = childnode.getAttribute('value').split(',')
            m.setThrustVector(float(values[0]),float(values[1]))
            m.setInitialThrustVector(float(values[0]),float(values[1]))                          
          if childnode.localName == "mass":
            value = childnode.getAttribute('value')
            m.setMass(float(value))      
          if childnode.localName == "radius":
            value = childnode.getAttribute('value')
            m.setRadius(float(value))  
          if childnode.localName == "texture":
            value = childnode.getAttribute('value')
            m.setTexture(TextureHelper.loadTextureFromFile(value))
          #if childnode.localName == "physicalPoints":
          #  for ppointnode in childnode.childNodes:
          #    if ppointnode.localName == "point":
          #      values = ppointnode.getAttribute('value').split(',')
          #      m.addPhysicalPoint(Vector2d(float(values[0]),float(values[1])))
        m.setupPhysicalPoint()
        self.mainbody.addMobile(m)
    self.mainbody.init()
    focus_position = self.mainbody.getPosition()
    self.world.addMobile(self.mainbody)

  def setupWorld(self,filename):
    self.world.reset()
    domLevel = parse(filename)
    worldNodes = domLevel.getElementsByTagName("world")
    for node in worldNodes[0].childNodes:
      if node.localName == "gravity":
        values = node.getAttribute('value').split(',')
        self.world.setGravity(float(values[0]),float(values[1]))
      if node.localName == "landingzone":
        values = node.getAttribute('value').split(',')
        self.world.setLandingzone(Landingzone(float(values[0]),float(values[1]),float(values[2]),float(values[3]),TextureHelper.loadTextureFromFile('checker.png')))

    h = Config.getint('graphics', 'height')
    w = Config.getint('graphics', 'width')
    p0 = Plane(1,0,-10)
    p1 = Plane(0,-1,h-10)
    p2 = Plane(-1,0,w-10)
    p3 = Plane(0,1,-64)
    self.world.addPlane(p0)
    self.world.addPlane(p1)
    self.world.addPlane(p2)
    self.world.addPlane(p3)

    #self.world.setGravity(0.0,-1.8)

  def setupGame(self):
    self.setupMenu()

  def updateGame(self,canvas):
    if self.mainbody != 0:
      self.camera.follow(self.mainbody)
    self.camera.setup(canvas)
    self.background.draw(canvas)

    
    self.world.draw(canvas)

    self.gui.draw(canvas)
    self.world.step(1/60.)
    if self.gameIsRunning():
      res = self.checkVictoryCondition()
      if res != 0:
        if res == -1:
          self.gui.messaging.displayText('FAIL ! !',200) 
          self.gameResult = -1
          Clock.schedule_once(self.setupLevel, 5)
        if res == 1:
          self.gui.messaging.displayText('SUCCESS ! !',200)
          self.gameResult = 1
          self.currentLevel += 1 
          Clock.schedule_once(self.setupLevel, 5)
  def on_touch_down(self, touch):
    worldpos = self.camera.screenToWorld(touch.pos[0],touch.pos[1])
    self.world.on_touch_down(worldpos)
    self.gui.on_touch_down(touch)
Example #3
0
class Oxo():
    gui: Gui = None
    stop_game = False
    board = None
    player_ones_turn = True
    game_over = False

    board_size = Size(3, 3)

    def window_close(self):
        self.stop()

    def click_cell(self, x: int, y: int):
        if self.game_over:
            return

        if self.board[y][x] != Cell.EMPTY:
            return

        if self.player_ones_turn:
            self.board[y][x] = Cell.X
        else:
            self.board[y][x] = Cell.O

        if self.max_same_cell_row_count(x, y) >= 3:
            self.game_over = True
            spelernaam = "één" if self.player_ones_turn else "twee"
            self.gui.draw(self.board, f"Speler {spelernaam} is gewonnen!")
        else:
            self.player_ones_turn = not self.player_ones_turn
            spelernaam = "één" if self.player_ones_turn else "twee"
            self.gui.draw(self.board, f"Speler {spelernaam} is aan zet")

    def max_same_cell_row_count(self, cx: int, cy: int):
        counts = []

        # Iterate top-left, -middle and -right
        for dx in range(-1, 2):
            dy = -1
            counts.append(self.same_cell_row_count(cx, cy, dx, dy))

        # Check left
        dx = -1
        dy = 0
        counts.append(self.same_cell_row_count(cx, cy, dx, dy))

        return max(counts)

    def same_cell_row_count(self, cx: int, cy: int, dx: int, dy: int):
        """Returns the number of same-value cells in a row.

        Checks both the (dx, dy) direction and its oposite.
        """
        return (self.directed_same_cell_row_count(cx, cy, dx, dy) + 1 +
                self.directed_same_cell_row_count(cx, cy, -dx, -dy))

    def directed_same_cell_row_count(self, cx: int, cy: int, dx: int, dy: int):
        """Returns the number of same-value cells in a row.

        Checks the (dx, dy) direction (delta-x, -y).
        """
        center_val = self.board[cy][cx]
        count = 0
        x, y = (cx + dx, cy + dy)
        if not self.is_on_board(x, y):
            return count
        val = self.board[y][x]
        while val == center_val:
            count += 1
            # Delta-extended-x, -y
            dex, dey = (dx * (count + 1), dy * (count + 1))
            x, y = (cx + dex, cy + dey)
            if not self.is_on_board(x, y):
                break
            val = self.board[y][x]
        return count

    def is_on_board(self, x, y):
        return (x >= 0 and x < self.board_size.width and y >= 0
                and y < self.board_size.height)

    def stop(self):
        print("\nExiting...")
        if self.gui is not None:
            self.gui.stop()
        self.stop_game = True

    def start(self):
        self.board = [[Cell.EMPTY for x in range(self.board_size.width)]
                      for y in range(self.board_size.height)]

        size = 500, 500
        self.gui = Gui(size, Color("blue"), Color("white"),
                       GuiHandlers(self.click_cell, self.window_close))
        self.gui.init()
        self.gui.draw(self.board, "Speler één is aan zet")

        while not self.stop_game:
            sleep(0.05)
Example #4
0
def main():
    pygame.init()
    screen = pygame.display.set_mode((640, 480),pygame.SWSURFACE)
    pygame.key.set_repeat(100, 100)
    '''TEST'''
    g=Gui()
    #g.enableDirtyRect()
    g.optimizeDraw()
    i=PygameInput()
    Image.mImageLoader=PygameImageLoader()
    gr=PygameGraphics()
    gr.setTarget(screen)
    f=ImageFont("C:\Python25\Projects\Guichan\consolefont.bmp")
    #f=ImageFont("consolefont.bmp")
    f.setColorkey( Color(255,0,255) )
    f.setGlyphSpacing(2)
    f2=PygameFont("C:\Python25\Projects\Guichan\LiberationMono-Regular.ttf",14,Color(0,0,0,255))
    #f2=PygameFont("C:\Python25\Projects\Guichan\Caracteres L1.ttf",13,Color(0,0,0,255))
    f2.setGlyphSpacing(1)
    Widget.setGlobalFont(f2)
    
    c=Container()
    c.setOpaque(False)
    c.setPosition(0,0)
    c.setSize(640,480)
    c.setBaseColor( Color(255,0,0,255) )
    
    a=ActionListener()
    a.action=action
    b, b2=Button("YEY!"), Button("WHa?")
    b.setPosition(0,50)
    b.setActionEventId("Button 1")
    b.addActionListener(a)
    b2.setPosition(100,100)
    b2.setActionEventId("Button 2")
    b2.addActionListener(a)
    b2.setBaseColor( Color(200,200,200) )
    b2.setCaption("ABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*()")
    w,w2=Window("Hey over here!"), Window("Trapped in a window!")
    wColor=w.getBaseColor()
    wColor.a=200
    w.setBaseColor(wColor)
    w.setTextColor(Color(255,0,255))
    xyz=Button("XYZ")
    xyz.setTextColor(Color(0,255,255))
    pb=ProgressBar(100.0)
    pb.setBaseColor( Color(255,255,0) )
    pb.setForegroundColor( Color(0,255,255) )
    pb.setSize(100, 20)
    pb.setPosition(300, 300)
    pb.setValue(50.0)
    c.add(w,0,100)
    c.add(b)
    c.add(b2)
    c.add(xyz,10,10)
    c.add(pb)
    
    check=Checkbox("Ye what? GET BACK HERE BOY!")
    check.setActionEventId("Checkbox")
    check.addActionListener(a)
    text=TextField("Hey Hey Hey Hey Hey Hey Hey Hey")
    text.setBackgroundColor( Color(255,255,255,255) )
    text.setMaxSize(150)
    text2=TextBox("Hey, HeyTrapped in a window!\nWhat's goin' onTrapped in a window!\ntodays???Trapped in a window!")
    text2.setTabSize(10)
    sc=ScrollArea(text2)
    sc.setSize(200,100)
    rBox=Container()
    r1=RadioButton("1984","Dystopia")
    r2=RadioButton("Fahrenheit 451","Dystopia")
    r3=RadioButton("Brave New World","Dystopia")
    rBox.add(r1,0,0)
    rBox.add(r2,0,r1.getY()+r1.getHeight())
    rBox.add(r3,0,r2.getY()+r2.getHeight())
    label=Label("WE AIN'T GOT IT")
    ico_image=Image.load("C:\Python25\Projects\Guichan\May.bmp")
    ico=Icon(ico_image)
    lb=ListBox( List_ListModel(["Bollocks!","Never!","Cuppa tea, mate?","Hello!","Goodbye!","OK Computer!","Oh Inverted World!","How To Disappear Completely!","Hold Still!","It Takes A Train To Cry!","A","B","C","D","E","F","G","H","I",]) )
    sc2=ScrollArea(lb)
    sc2.setSize(125,100)
    lb.setWidth(110)
    slider=Slider(0,100)
    slider.setOrientation(Slider.Orientation.VERTICAL)
    slider.setSize(15,100)
    slider.setActionEventId("Slider")
    #slider.addActionListener(a)
    ib=ImageButton(ico_image)
    ta=TabbedArea()
    c.add(w2)
    ta.addTab("Text",[ (text,0,0), (sc,0,50) ])
    ta.addTab("Check",check)
    ta.addTab("Radio",rBox)
    ta.addTab("List",[ (sc2,0,0) ])
    ta.addTab("Label",label)
    ta.addTab("Icon",[ (ico,0,0), (ib,100,0) ])
    ta.addTab("Slider",slider)
    ta.setSize(300,300)
    w2.add(ta,0,0)
    g.setGraphics(gr)
    w2.resizeToContent()
    w.setSize(300,300)
    g.setInput(i)
    g.setTop(c)
    clock=pygame.time.Clock()
    
    g.mDirtyRect.addRect( Rectangle(0,0,640,480) )
    done=False
    while done == False:
        clock.tick(0)

        for event in pygame.event.get():
            if event.type==KEYDOWN:
                if event.key == K_ESCAPE:
                    c.remove(b)
                    c.remove(b2)
                    done=True
                
                elif event.key == K_RETURN:
                    w=Window("It'a window!")
                    w.add(Checkbox("Kool thing"))
                    w.resizeToContent()
                    c.add(w, 10, 10)
                    
                elif event.key == K_LEFT:
                    pb.setValue( pb.getValue()-1.0 )
                elif event.key == K_RIGHT:
                    pb.setValue( pb.getValue()+1.0 )                
                    
            if event.type == ACTIVEEVENT:
                if event.gain == 1:
                    g.mDirtyRect.addRect( Rectangle(0,0,640,480) )
                    
            i.pushInput(event)
            g.logic()
            
        b2.setCaption( str( int(clock.get_fps()) ) )
        fRect=GuichanToPygameDirtyRect(g.mDirtyRect.getList())
        #for ix in fRect: screen.fill((255,0,0),ix)
        
        screen.fill((255,0,0))    
        g.draw()
        #pygame.display.update( GuichanToPygameDirtyRect(g.mDirtyRect.getList()) )
        pygame.display.update()
        
        g.mDirtyRect.clearList()
Example #5
0
class Kitchen(object):
    """
    Kitchen environment for Kitchen for Progress 2D.
    Serves as main API interface.
    """
    def __init__(self):
        # PyGame Initialization
        pygame.display.init()
        self.clock = pygame.time.Clock()
        self.gui = Gui()
        self.gripper = Gripper()
        self.plan = []
        self.cur_plan = []
        self.cur_action = ''
        self.target_name = None
        self.beput_name = None
        self.action_status = True  #to check if the current action is done
        self.plan_status = True  #to check if the plan is done
        #self.in_grip_obj = None #None if there is no object in the gripper
        #
    def pour(self, bepour, target):
        self.cur_plan.append('pouring')
        self.plan += ['pour', target, bepour]
        self.plan_status = False
        self.run()

    def fill_water(self, target, faucet):
        self.cur_plan.append('filling water')
        self.plan += [
            'pick', target, 'back', target, 'put', target, faucet,
            'fill_water', 'none'
        ]
        self.plan_status = False
        self.run()

    def stir(self, target, bestir):
        self.cur_plan.append('stirring')
        self.plan += [
            'put', target, bestir, 'pick', target, 'stir', target, 'back',
            target
        ]
        self.plan_status = False
        self.run()

    def pick_up(self, target):
        """
        Adds `pick up` operation to existing plan;
        Picks up `target`.
        Input: `target`, a string denoting target object
        """
        self.cur_plan.append('picking up target')
        self.plan += ['pick', target, 'back', target]
        self.plan_status = False
        self.run()

    def put(self, target, beput):
        """
        Adds `put` operation to existing plan;
        Puts `beput` onto `target`.
        Input:  `target`, a string denoting target platform
                `beput`, string denoting object to be put 
        """
        self.cur_plan.append('putting target')
        self.plan += ['put', target, beput, 'back', 'none']
        self.plan_status = False
        self.run()

    def open_drawer(self, target):
        self.cur_plan.append('opening drawer')
        self.plan += ['pick', target, 'open', target]
        self.plan_status = False
        self.run()

    def close_drawer(self, target):
        self.cur_plan.append('closing drawer')
        self.plan += ['pick', target, 'close', target]
        self.plan_status = False
        self.run()

    def _execute_plan(self):
        """
        If the last action was completed, pop the next action from our plan.
        Execute the action.
        """
        if self.action_status and len(self.plan):
            self.cur_action = self.plan.pop(0)
            self.target_name = self.plan.pop(0)
            if self.cur_action == 'put' or self.cur_action == 'pour':
                self.beput_name = self.plan.pop(0)
        self.action_status = self.gui.executeAction(self.gripper,
                                                    self.cur_action,
                                                    self.target_name,
                                                    self.beput_name)
        #if the last action of the plan is done
        if self.action_status and len(self.plan) == 0:
            self.plan_status = True

    def run(self):
        """
        Run the kitchen environment and display it.
        """
        while True:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()
            if self.plan_status == False:
                self._execute_plan()
            self.gui.draw(self.gripper, self.cur_action)
            pygame.display.flip()
            self.clock.tick(60)
            if self.plan_status:
                break
Example #6
0
class Minesweeper(object):
    """
    Main game application
    """
    def __init__(self, difficulty, use_ai, total_games):

        # read settings file
        with open('settings.yaml', 'r') as f:
            settings = yaml.load(f)            
            self.rows = settings[difficulty]["rows"]
            self.cols = settings[difficulty]["columns"]
            self.mines = settings[difficulty]["mines"]
            self.width = settings[difficulty]["width"]
            self.height = settings[difficulty]["height"]
            self.size = self.width, self.height
        
        # pygame setup
        self._running = True # used to stop game loop        
        self.screen = self.setup_screen()

        # scorekeeping
        self.start_time = time.time()
        self.time_elapsed = 0        
        self.score = 0
        self.lost_game = False
        self.won_game = False

        # game board setup        


        # AI / autoplay
        self.use_ai = use_ai        

        # create board and gui 
        self.board = Board(self.width, self.height, self.rows, self.cols, self.mines, self.screen, 36)    
        self.gui = Gui(self.board, self)

        # autoplay or enter event loop        
        if self.use_ai:
            self.autoplay(total_games)
        self.loop()



    def autoplay(self, times_to_play):
        """
        Automatically play minesweeper a certain number of times.        
        :param times_to_play: int
        """
        for i in range(times_to_play):
            print "\n### Playthrough", i

            # draw the starting board; also draws scores
            self.draw()

            # play 1 game

            solver.Solver.play_best_guess(self)            
            
            # reset board
            self.reset_game()


    def game_over(self):
        # unflag and reveal all cells
        for i in xrange(self.rows):
            for j in xrange(self.cols):
                self.board.cells[i][j].revealed = True


    def reset_game(self):
        # reset score and draw new board
        self.lost_game = False
        self.won_game = False
        self.score = 0
        self.start_time = time.time()
        self.time_elapsed = 0
        self.board.reset()
        self.draw()


    def flag_cell(self, i, j):
        """
        Flags cell and redraws board when user right-clicks or control-clicks cell
        :param i: cell row
        :param j: cell column
        """
        # do not flag revealed squares
        if not self.board.cells[i][j].revealed:
            if self.board.cells[i][j].flagged == True:
                self.board.cells[i][j].flagged = False
            else:
                self.board.cells[i][j].flagged = True
        if self.test_did_win():
            self.game_over()


    def reveal_cell(self, row, col):
        """
        Mark a cell as revealed and if it's not a mine 
        either display its neighbor count or reveal its empty neighbors.
        :param row: int, row index for cell to reveal in board
        :param col: int, col index for cell to reveal in board
        """
        cell = self.board.cells[row][col]
        if cell.is_mine == True:
            print "You lose! Final Score: ", self.score
            cell.revealed = True
            cell.detonated = True
            self.lost_game = True
            self.game_over()
        elif cell.neighbors > 0:
            # cell has a neighbor # value, show it
            cell.revealed = True
            self.score += 1
        else:
            # cell is empty, reveal all empty neighbors
            cell.revealed = True
            self.score += 1
            self.reveal_neighbors(row, col)


    def reveal_neighbors(self, row, col):
        """
        Recursive function that marks all adjacent unrevealed empty cells as revealed
        :param row: int, row index for cell in board
        :param col: int, col index for cell in board
        """
        neighbors = self.board.get_neighbor_cells(row, col)
        for cell in neighbors:
            # if not revealed yet, reveal it and reveal its neighbors
            if not cell.revealed:
                cell.revealed = True
                if cell.neighbors == 0 and cell.is_mine == False:
                    self.reveal_neighbors(cell.row, cell.col)


    """
    # Pygame Setup and Event Functions
    """

    def setup_screen(self):
        """
        :return: pygame screen object
        """
        pygame.init()
        screen = pygame.display.set_mode(self.size, pygame.HWSURFACE | pygame.DOUBLEBUF)       
        screen.fill(colors.bg_gray)        
        pygame.display.flip()
        return screen


    def loop(self):
        """
        Game loop that responds to user events
        """
        self._running = True
        while (self._running):
            # increment the game clock if we're playing now
            if (not self.lost_game) and (not self.won_game):
                now = time.time()
                self.time_elapsed = now - self.start_time
            # listen for user input events
            for event in pygame.event.get():
                self.on_event(event)
            # draw the updated game board and score
            self.draw()


    def on_event(self, event):
        """
        Handle individual events
        :param event: pygame event
        """
        if event.type == pygame.QUIT:
            print "App quitting"
            self._running = False

        # keypresses
        elif event.type == KEYDOWN:
            if event.key == K_ESCAPE:
                self._running = False

        # mouse events
        elif event.type == MOUSEBUTTONUP:
            # left-click
            if event.button == 1:
                # macs don't have right click, so process control-click as right click
                key = pygame.key.get_pressed()
                if key[K_LCTRL]:
                    self.flag_event(event)
                else:
                    # left click reveals a cell
                    x,y = event.pos
                    if self.gui.button_icon.rect.collidepoint(x,y):
                        self.reset_game()
                    if self.gui.auto_icon.rect.collidepoint(x,y):
                        self.autoplay(total_games)
                        self.reset_game()
                    else:
                        for i in xrange(self.rows):
                            for j in xrange(self.cols):
                                cell_rect = self.board.cells[i][j].rect
                                if cell_rect.collidepoint(x,y):
                                    # if unrevealed, reveal the cell
                                    if not self.board.cells[i][j].revealed:
                                        self.reveal_cell(i, j)
                                        # test if we won or not
                                        if self.test_did_win():
                                            self.game_over()
            # right click
            elif event.button == 3:
                self.flag_event(event)


    def flag_event(self, event):
        """
        Action taken when screen is right-clicked or ctrl-clicked
        :param event: 
        :return:
        """
        x,y = event.pos
        for i in xrange(self.rows):
            for j in xrange(self.cols):
                cell_rect = self.board.cells[i][j].rect
                if cell_rect.collidepoint(x,y):
                    self.flag_cell(i, j)
                    self.draw()


    def draw(self):
        # Fill background
        background = pygame.Surface(self.screen.get_size())
        background = background.convert()
        background.fill(colors.gray) 
        self.board.draw()
        self.gui.draw() # update scoreboard
        pygame.display.flip() # update screen


    def test_did_win(self):
        """
        Tests whether the game's board is in a winning position.
        Also sets self.won_game for use in the solver.
        Winning conditions:
        All cells revealed or with flags
        All mines have flags
        No cells without mines have flags
        :return: bool
        """
        did_win = True
        for i in xrange(self.rows):
            for j in xrange(self.cols):
                cell = self.board.cells[i][j]
                # unrevealed and not flagged squares
                if not cell.revealed and not cell.flagged:
                    did_win = False
                    break
                # incorrect flags
                if cell.flagged and not cell.is_mine:
                    did_win = False
                    break
                # unflagged mines
                if cell.is_mine and not cell.flagged:
                    did_win = False
                    break
        if did_win:
            print "You won!"
            self.won_game = True

        return did_win
Example #7
0
class Oxo():
    gui: Gui = None
    net: Net = None
    stop_game = False
    board = None
    is_my_turn = False
    im_player_one = None
    game_over = False

    board_size = Size(3, 3)

    def game_start(self, im_player_one: bool):
        self.im_player_one = im_player_one
        self.is_my_turn = self.im_player_one
        if self.is_my_turn:
            self.gui.draw(self.board, "Doe een zet!")
        else:
            self.gui.draw(self.board, "Speler twee is aan zet")

    def game_already_started(self):
        print("Oeps! Er is al een spel bezig.")
        self.stop()

    def move_made(self, x: int, y: int):
        if self.game_over or self.is_my_turn:
            return

        self.is_my_turn = True
        if self.im_player_one:
            self.board[y][x] = Cell.O
        else:
            self.board[y][x] = Cell.X

        if self.max_same_cell_row_count(x, y) >= 3:
            self.game_over = True
            self.gui.draw(self.board, "Speler twee is gewonnen!")
        else:
            self.gui.draw(self.board, "Doe een zet!")

    def window_close(self):
        self.stop()

    def click_cell(self, x: int, y: int):
        if self.game_over or not self.is_my_turn:
            return

        if self.board[y][x] != Cell.EMPTY:
            return

        self.is_my_turn = False
        self.net.make_move(x, y)
        if self.im_player_one:
            self.board[y][x] = Cell.X
        else:
            self.board[y][x] = Cell.O

        if self.max_same_cell_row_count(x, y) >= 3:
            self.game_over = True
            self.gui.draw(self.board, "Jij bent gewonnen!")
        else:
            self.gui.draw(self.board, "Speler twee is aan zet")

    def max_same_cell_row_count(self, cx: int, cy: int):
        counts = []

        # Iterate top-left, -middle and -right
        for dx in range(-1, 2):
            dy = -1
            counts.append(self.same_cell_row_count(cx, cy, dx, dy))

        # Check left
        dx = -1
        dy = 0
        counts.append(self.same_cell_row_count(cx, cy, dx, dy))

        return max(counts)

    def same_cell_row_count(self, cx: int, cy: int, dx: int, dy: int):
        """Returns the number of same-value cells in a row.

        Checks both the (dx, dy) direction and its oposite.
        """
        return (self.directed_same_cell_row_count(cx, cy, dx, dy) + 1 +
                self.directed_same_cell_row_count(cx, cy, -dx, -dy))

    def directed_same_cell_row_count(self, cx: int, cy: int, dx: int, dy: int):
        """Returns the number of same-value cells in a row.

        Checks the (dx, dy) direction (delta-x, -y).
        """
        center_val = self.board[cy][cx]
        count = 0
        x, y = (cx + dx, cy + dy)
        if not self.is_on_board(x, y):
            return count
        val = self.board[y][x]
        while val == center_val:
            count += 1
            # Delta-extended-x, -y
            dex, dey = (dx * (count + 1), dy * (count + 1))
            x, y = (cx + dex, cy + dey)
            if not self.is_on_board(x, y):
                break
            val = self.board[y][x]
        return count

    def is_on_board(self, x, y):
        return (x > 0 and x < self.board_size.width and y > 0
                and y < self.board_size.height)

    def stop(self):
        print("\nExiting...")
        if self.gui is not None:
            self.gui.stop()
        if self.net is not None:
            self.net.stop()
        self.stop_game = True

    def start(self):
        game_name = input("Game name> ")

        self.board = [[Cell.EMPTY for x in range(self.board_size.width)]
                      for y in range(self.board_size.height)]

        size = 500, 500
        self.gui = Gui(size, Color("blue"), Color("white"),
                       GuiHandlers(self.click_cell, self.window_close))
        self.gui.init()
        self.gui.draw(self.board, "Wachten op speler 2...")

        self.net = Net(
            MqttCommHandlers(self.game_start, self.game_already_started,
                             self.move_made))
        self.net.init()
        self.net.connect(game_name)

        while not self.stop_game:
            sleep(0.05)