Exemple #1
0
 def show(self, board):
     board.addBoard(self)
     for i in range(self.getSize()[0]):
         for j in range(self.getSize()[1]):
             sys.stdout.write(self.fore + Style.BRIGHT +
                              pos(self._y + MARGINY + i, self._x + MARGINX +
                                  j) + self.structure[i, j])
     sys.stdout.write(pos(ROWS - 2, 0) + " ")
Exemple #2
0
 def show(self, board):
     """Places/shows character on board with new position"""
     board.add_board(self)
     for i in range(self.get_size()[0]):
         for j in range(self.get_size()[1]):
             sys.stdout.write(self.fore + Style.BRIGHT +
                              pos(self._y + MARGINY + i, self._x + MARGINX +
                                  j) + self.structure[i, j])
     sys.stdout.write(pos(ROWS - 2, 0) + " ")
Exemple #3
0
 def remove(self, board):
     height, width = self.getSize()
     board.clear(self)
     for i in range(height):
         for j in range(width):
             sys.stdout.write(self.fore + pos(self._y + MARGINY +
                                              i, self._x + MARGINX + j) +
                              str(' '))
     sys.stdout.write(pos(ROWS - 2, 0) + " ")
Exemple #4
0
 def show(self, board):
     """Places/shows updated element on board"""
     board.add_board(self)
     for i in range(self.get_size()[0]):
         for j in range(self.get_size()[1]):
             sys.stdout.write(self.fore + Style.BRIGHT +
                              pos(self._y+MARGINY+i, self._x+MARGINX+j) +
                              self.structure[i, j])
     sys.stdout.write(pos(ROWS-2, 0) + " ")
Exemple #5
0
 def remove(self, board):
     """Removes lake from board"""
     height, width = self.get_size()
     board.clear(self)
     for i in range(height):
         for j in range(width):
             if i == 0:
                 sys.stdout.write(Style.BRIGHT + pos(self._y+MARGINY+i,
                                                     self._x+MARGINX+j) +
                                  str('-'))
             else:
                 sys.stdout.write(pos(self._y+MARGINY+i,
                                      self._x+MARGINX+j) + str(' '))
     sys.stdout.write(pos(ROWS-2, 0) + " ")
Exemple #6
0
 def lifeUpdate(self):
     self.life = self.life - 1
     if self.life <= 0:
         self.showScore()
         sys.stdout.write(Back.RED + pos(ROWS-2, 0) +
                          "Bro you dead".center(COLUMNS))
         exit()
Exemple #7
0
 def life_update(self):
     """Updating lives"""
     self.life = self.life - 1
     if self.life <= 0:
         self.show_score()
         sys.stdout.write(Back.RED + pos(ROWS - 2, 0) +
                          "Bro you dead".center(COLUMNS))
         exit()
Exemple #8
0
    def render(self):
        """Displaying the board at every frame"""

        temp_board = np.matrix(self._board)
        for row in range(self.height):
            for col in range(self.width):
                sys.stdout.write(Style.BRIGHT + pos(row + 3, col + 6) +
                                 self._board[row, col])
        del temp_board
Exemple #9
0
def main():
    """ Game Engine """
    os.system('tput reset')
    screen_height, screen_width = ROWS - 2 * MARGINY, COLUMNS - 2 * MARGINX
    board = Board(screen_height, screen_width)

    board.add_game(Enemy(screen_height, screen_width))
    board.add_game(Mario(screen_width, screen_height))

    i = 8

    while i:
        board.add_game(
            Brick(screen_height, screen_width, randint(4, screen_width - 5)))
        i = i - 1

    i = 5

    while i:
        board.add_game(
            Cloud(screen_height, screen_width, randint(4, screen_width - 6)))
        i = i - 1

    sys.stdout.write(Style.BRIGHT + Back.YELLOW + pos(2, 0) +
                     "SUPER MARIO".center(COLUMNS))

    board.render()

    game_on = True
    char = " "

    while game_on:
        board.player[0].scoreboard.show_score()
        board.player[0].move(char, board)
        board.update_enemys()
        board.update_bullets()
        if char == 'q':
            sys.stdout.write(Back.RED + pos(ROWS - 2, 0) +
                             "We got a quitter".center(COLUMNS))
            game_on = False
        char = get_input()
        board.add_more()
        board.player[0].scoreboard.score_update("time")
Exemple #10
0
    def check_path(self, element, x_coord, y_coord):
        """Checking wether all elements can move and the result"""

        height, width = element.get_size()
        emp_mat = np.chararray((height, width), unicode=True)
        emp_mat[:, :] = " "

        # mario can land and kill Enemy otherwise get killed by enemy
        if element.get_type() == "player":
            for enem in self._storage["enemy"]:
                x_en, y_en = enem.get_coord()
                if (x_coord, y_coord + 1) == (x_en, y_en) or\
                   (x_coord+1, y_coord + 1) == (x_en, y_en) or\
                   (x_coord, y_coord + 1) == (x_en+1, y_en):
                    self._storage["enemy"].remove(enem)
                    enem.alive = False
                    enem.remove(self)
                    element.scoreboard.score_update("enemy")
                    sys.stdout.write(
                        pos(ROWS - 2, 0) +
                        str(os.system('aplay mb_touch.wav&')))
                    return True

                if (x_coord+1, y_coord) == (x_en, y_en) or\
                   (x_coord+1, y_coord+1) == (x_en, y_en) or\
                   (x_coord, y_coord) == (x_en+1, y_en) or\
                   (x_coord, y_coord+1) == (x_en+1, y_en):
                    enem.alive = False
                    element.scoreboard.life_update()
                    self._storage["enemy"].remove(enem)
                    enem.remove(self)
                    sys.stdout.write(
                        pos(ROWS - 2, 0) + str(os.system('aplay mb_die.wav&')))
                    return True

            for coi in self._storage["coin"]:
                x_en, y_en = coi.get_coord()
                if (x_coord, y_coord) == (x_en, y_en+1) or\
                   (x_coord+1, y_coord+1) == (x_en, y_en) or\
                   (x_coord, y_coord) == (x_en+1, y_en+1) or\
                   (x_coord, y_coord) == (x_en+1, y_en) or\
                   (x_coord+1, y_coord) == (x_en, y_en+1) or\
                   (x_coord+1, y_coord) == (x_en, y_en) or\
                   (x_coord, y_coord+1) == (x_en+1, y_en) or\
                   (x_coord, y_coord+1) == (x_en, y_en):
                    self._storage["coin"].remove(coi)
                    coi.remove(self)
                    return True

            for lak in self._storage["lake"]:
                x_en, y_en = lak.get_coord()
                if (x_coord, y_coord+1) == (x_en, y_en) or\
                   (x_coord+1, y_coord+1) == (x_en, y_en) or\
                   (x_coord, y_coord+1) == (x_en+1, y_en) or\
                   (x_coord, y_coord+1) == (x_en+2, y_en):
                    element.scoreboard.life_update()
                    self._storage["lake"].remove(lak)
                    lak.remove(self)
                    sys.stdout.write(
                        pos(ROWS - 2, 0) + str(os.system('aplay mb_die.wav&')))
                    return False

        elif element.get_type() == "enemy":
            if self.player:
                x_en, y_en = self.player[0].get_coord()
                if (x_en+1, y_en) == (x_coord, y_coord) or\
                   (x_en+1, y_en+1) == (x_coord, y_coord) or\
                   (x_en, y_en) == (x_coord+1, y_coord) or\
                   (x_en, y_en+1) == (x_coord+1, y_coord):
                    element.alive = False
                    element.remove(self)
                    self._storage["enemy"].remove(element)
                    self.player[0].scoreboard.life_update()
                    sys.stdout.write(pos(ROWS - 2, 0) + " ")
                    os.system('aplay mb_die.wav&')
                    return False

        elif element.get_type() == "brick":
            for enem in self._storage["enemy"]:
                x_en, y_en = enem.get_coord()
                if (x_coord+1, y_coord) == (x_en, y_en) or\
                   (x_coord+1, y_coord+1) == (x_en, y_en) or\
                   (x_coord, y_coord) == (x_en+1, y_en) or\
                   (x_coord, y_coord+1) == (x_en+1, y_en):
                    enem.move_left(self)
                    return True

        elif element.get_type() == "bullet":
            if np.all(self._board[y_coord:y_coord + 1,
                                  x_coord:x_coord + 1] != emp_mat):
                ben = self._storage["bossenemy"][0]
                ben.life = ben.life - 1
                element.remove(self)
                self._storage["bullet"].remove(element)
                if ben.life <= 0:
                    ben.alive = False
                    self.player[0].scoreboard.score_update("bossenemy")
                    self.player[0].scoreboard.show_score("Final Score:: ")
                    self._storage["bossenemy"].remove(ben)
                    ben.remove(self)
                    msg = "You Won!! and still it doesn't matter:-p"
                    sys.stdout.write(Back.RED + pos(ROWS - 2, 0) +
                                     msg.center(COLUMNS))
                    exit()
                return False

        if np.all(self._board[y_coord:y_coord + height,
                              x_coord:x_coord + width] == emp_mat):
            return True
        return False
Exemple #11
0
 def show_score(self, fin=""):
     """Show score"""
     disp = fin + "Score: " + str(self.score) + "     Lives: " +\
            str(self.life)
     sys.stdout.write(Back.YELLOW + Style.BRIGHT + pos(ROWS - 3, 0) +
                      disp.center(COLUMNS))
Exemple #12
0
    def checkPath(self, element, x, y):
        height, width = element.getSize()
        emp_mat = np.chararray((height, width), unicode=True)
        emp_mat[:, :] = " "

        # mario can land and kill Enemy otherwise get killed by enemy
        if element.getType() == "player":
            for en in self._storage["enemy"]:
                x_en, y_en = en.getCoord()
                if (x, y + 1) == (x_en, y_en) or\
                   (x+1, y + 1) == (x_en, y_en) or\
                   (x, y + 1) == (x_en+1, y_en):
                    self._storage["enemy"].remove(en)
                    en.alive = False
                    en.remove(self)
                    element.scoreboard.scoreUpdate("enemy")
                    sys.stdout.write(
                        pos(ROWS - 2, 0) +
                        str(os.system('aplay mb_touch.wav&')))
                    return True
                if (x+1, y) == (x_en, y_en) or\
                   (x+1, y+1) == (x_en, y_en) or\
                   (x, y) == (x_en+1, y_en) or\
                   (x, y+1) == (x_en+1, y_en):
                    en.alive = False
                    element.scoreboard.lifeUpdate()
                    self._storage["enemy"].remove(en)
                    en.remove(self)
                    sys.stdout.write(
                        pos(ROWS - 2, 0) + str(os.system('aplay mb_die.wav&')))
                    return True

            for cn in self._storage["coin"]:
                x_cn, y_cn = cn.getCoord()
                if (x, y) == (x_cn, y_cn+1) or\
                   (x+1, y+1) == (x_cn, y_cn) or\
                   (x, y) == (x_cn+1, y_cn+1) or\
                   (x, y) == (x_cn+1, y_cn) or\
                   (x+1, y) == (x_cn, y_cn+1) or\
                   (x+1, y) == (x_cn, y_cn) or\
                   (x, y+1) == (x_cn+1, y_cn) or\
                   (x, y+1) == (x_cn, y_cn):
                    self._storage["coin"].remove(cn)
                    cn.remove(self)
                    return True

            for lk in self._storage["lake"]:
                x_lk, y_lk = lk.getCoord()
                if (x, y+1) == (x_lk, y_lk) or\
                   (x+1, y+1) == (x_lk, y_lk) or\
                   (x, y+1) == (x_lk+1, y_lk) or\
                   (x, y+1) == (x_lk+2, y_lk):
                    element.scoreboard.lifeUpdate()
                    self._storage["lake"].remove(lk)
                    lk.remove(self)
                    sys.stdout.write(
                        pos(ROWS - 2, 0) + str(os.system('aplay mb_die.wav&')))
                    return False

        elif element.getType() == "enemy":
            x_pl, y_pl = self.player[0].getCoord()
            if (x_pl+1, y_pl) == (x, y) or\
               (x_pl+1, y_pl+1) == (x, y) or\
               (x_pl, y_pl) == (x+1, y) or\
               (x_pl, y_pl+1) == (x+1, y):
                element.alive = False
                element.remove(self)
                self._storage["enemy"].remove(element)
                self.player[0].scoreboard.lifeUpdate()
                sys.stdout.write(pos(ROWS - 2, 0) + " ")
                os.system('aplay mb_die.wav&')
                return False

        elif element.getType() == "brick":
            for en in self._storage["enemy"]:
                x_en, y_en = en.getCoord()
                if (x+1, y) == (x_en, y_en) or\
                   (x+1, y+1) == (x_en, y_en) or\
                   (x, y) == (x_en+1, y_en) or\
                   (x, y+1) == (x_en+1, y_en):
                    en.moveLeft(self)
                    return True

        elif element.getType() == "bullet":
            if np.all(self._board[y:y + 1, x:x + 1] != emp_mat):
                ben = self._storage["bossenemy"][0]
                ben.life = ben.life - 1
                element.remove(self)
                self._storage["bullet"].remove(element)
                if ben.life <= 0:
                    ben.alive = False
                    self.player[0].scoreboard.scoreUpdate("bossenemy")
                    self.player[0].scoreboard.showScore("Final Score:: ")
                    self._storage["bossenemy"].remove(ben)
                    ben.remove(self)
                    msg = "You Won!! and still it doesn't matter:-p"
                    sys.stdout.write(Back.RED + pos(ROWS - 2, 0) +
                                     msg.center(COLUMNS))
                    exit()
                return False

        if np.all(self._board[y:y + height, x:x + width] == emp_mat):
            return True
        return False