Example #1
0
    def __init__(self):
        self.width = 11
        self.height = 24
        self.visible_height = 21
        self.guide_on = False
        self.dot_spawn_troll = False
        self.reset_matrix()
        self.win_functions = [
            self.win_func1
            ]
        self.loss_functions = [
            self.loss_func1
            ]
        self.win_conditions = [self.win_func1]
        self.loss_conditions = [self.loss_func1]
        self.forfeit = False
        self.send_multi = False
        self.multi_msg = ""

        self.active_block = blocks.block()
        self.pos = [5, 20]
        self.end_count = 0
        self.end_count_pos = [20, 380]
        self.end_count_matrix = [[]]

        self.last_game_step = time()
        self.curr_game_step = 0.0

        self.dot_meter = 0
        self.troll_meter = 0
        self.troll_meter_to_send = 0

        self.bo_pos = [200, 200]
        self.level = 0
        self.game_turn_time = 1.0
        self.end_time_increase = 0.5
        self.red_block_reward = 0.04
        self.turn_time_decrease = 0.83
        self.defill_time_decrease = True
        self.troll_time_decrease = False
        self.troll_time_modifier = 1.0
        self.troll_counter = 0 # Number of troll blocks spawned
        self.troll_time_counter = 0 # Number of time decreases

        self.init_images(1)

        self.scale = 1.0
        self.sp_level = 0

        self.last_landed = [5, 0]
        self.ai = AI(self)
Example #2
0
class board:
    def __init__(self):
        self.width = 11
        self.height = 24
        self.visible_height = 21
        self.guide_on = False
        self.dot_spawn_troll = False
        self.reset_matrix()
        self.win_functions = [
            self.win_func1
            ]
        self.loss_functions = [
            self.loss_func1
            ]
        self.win_conditions = [self.win_func1]
        self.loss_conditions = [self.loss_func1]
        self.forfeit = False
        self.send_multi = False
        self.multi_msg = ""

        self.active_block = blocks.block()
        self.pos = [5, 20]
        self.end_count = 0
        self.end_count_pos = [20, 380]
        self.end_count_matrix = [[]]

        self.last_game_step = time()
        self.curr_game_step = 0.0

        self.dot_meter = 0
        self.troll_meter = 0
        self.troll_meter_to_send = 0

        self.bo_pos = [200, 200]
        self.level = 0
        self.game_turn_time = 1.0
        self.end_time_increase = 0.5
        self.red_block_reward = 0.04
        self.turn_time_decrease = 0.83
        self.defill_time_decrease = True
        self.troll_time_decrease = False
        self.troll_time_modifier = 1.0
        self.troll_counter = 0 # Number of troll blocks spawned
        self.troll_time_counter = 0 # Number of time decreases

        self.init_images(1)

        self.scale = 1.0
        self.sp_level = 0

        self.last_landed = [5, 0]
        self.ai = AI(self)
    def send(self, b1, b2):
        """
        If multiplayer is enabled send two bytes to the other player.
        First byte is an unsigned integer, second byte is a signed integer.
        b1 <0, 255>
        b2 <-128, 127>
        If multiplayer is not enabled does nothing.
        """

        if self.send_multi:
            self.connection.send([b1, b2 + 128])
    def send_state(self):
        """
        Send elements necessary to recreate the board state.
        Pcket should be 512 bytes.
        """
        msg = []
        msg.append(self.level)
        msg.append(self.width) # Height doesn't change
        msg.append(self.active_block.identifier)
        msg.append(self.active_block.rotation)
        msg.append(self.active_block.colour)
        msg.append(self.pos[0])
        msg.append(self.pos[1])
        msg.append(self.forfeit)
        
        for l in self.matrix:
            msg.extend(l)
        msg.extend([0]*(512-len(msg)))

        self.connection.send(msg)
    def recreate_state(self, msg):
        """
        Recreate state from bytearry.
        """
        
        if (len(msg) - 8) % self.height != 0:
            print(msg)
        self.level = ord(msg[0]) # Python2 so msg is a string
        prev_width = self.width
        self.width = ord(msg[1])

        self.active_block.from_int(ord(msg[2]))
        self.active_block.rotation = ord(msg[3])
        self.active_block.colour = ord(msg[4])
        self.pos[0] = ord(msg[5])
        self.pos[1] = ord(msg[6])
        self.forfeit = ord(msg[7])

        mat = []
        for i in range(self.height):
            mat.append([ord(j) for j in msg[8 + i * self.width : 8 + (i+1) * self.width]])
        self.matrix = mat

    def try_recreate_state(self):
        """
        Receive 512 bytes encoding the board state
        """
        msg = self.connection.receive()
        if msg != 0:
            self.multi_msg += msg
            if len(msg) >= 512:
                index = (len(msg) // 512 - 1) * 512
                self.recreate_state(self.multi_msg[index:index+512])
                self.multi_msg = self.multi_msg[index+512:]
    def print_matrix(self):
        print(10*"*")
        self.add_block(self.pos, self.active_block.current_sqares())
        for i in reversed(range(self.visible_height)):
            for j in range(self.width):
                stdout.write(str(self.matrix[i][j]))
            print()
        self.erase_block(self.pos, self.active_block.current_sqares())
    def reset_matrix(self):
        self.matrix = []

        for i in range(self.height):
            self.matrix.append([])
            for j in range(self.width):
                self.matrix[i].append(0)

    def add_block(self, pos, sqares):
        for sq in sqares:
            self.matrix[pos[1]+sq[1]][pos[0]+sq[0]] = self.active_block.colour
    def check_block(self, pos, sqares):
        for sq in sqares:
            if (pos[0] + sq[0]) < 0 or (pos[0] + sq[0]) > self.width - 1:
                return 1
            if (pos[1] + sq[1]) < 0 or (pos[1] + sq[1]) > self.height - 1:
                return 1
            if self.matrix[pos[1]+sq[1]][pos[0]+sq[0]] >= 1:
                return 1
        return 0
    def erase_block(self, pos, sqares):
        for sq in sqares:
            self.matrix[pos[1]+sq[1]][pos[0]+sq[0]] = 0
    def spawn_block(self, seed=-1):
        self.pos = [5, 19]

        if seed != -1:
            self.active_block.from_int(seed)
        else:
            if self.dot_meter > 0:
                self.active_block.from_int(16)
                self.dot_meter -= 1
            elif self.troll_meter > 0:
                self.spawn_troll_block()
                self.troll_meter -= 1
            else:
                self.active_block.from_int(randint(0, 6))
        if self.check_block(self.pos, self.active_block.current_sqares()):
            self.end()
    def spawn_troll_block(self):
        self.troll_counter += 1
        if self.dot_spawn_troll:
            self.active_block.from_int(16)
        else:
            self.active_block.from_int(randint(7, 11))

    def advance_turn(self):
        if self.check_block([self.pos[0], self.pos[1] - 1], self.active_block.current_sqares()):
            self.last_landed = list(self.pos)
            self.add_block(self.pos, self.active_block.current_sqares())
            self.defill()
            self.spawn_block()
            self.last_game_step = time()
            return 1
        else:
            self.pos[1] -= 1
            return 0
    def dry_advance(self):
        if self.check_block([self.pos[0], self.pos[1] - 1], self.active_block.current_sqares()):
            self.add_block(self.pos, self.active_block.current_sqares())
            levels_cleared = self.dry_defill()
            self.erase_block(self.pos, self.active_block.current_sqares())
            return [True, levels_cleared]
        else:
            self.pos[1] -= 1
            return [False, 0]
    def dry_defill(self):
        counter = 0
        for i in range(self.height):
            counter += self.matrix[i].count(0) == 0
        return counter
    def try_move(self, x):
        if not self.check_block([self.pos[0] + x, self.pos[1]], self.active_block.current_sqares()):
            self.pos[0] += x
            return 1
        return 0
    def try_rotate(self, x):
        self.active_block.rotate(x)
        if self.check_block(self.pos, self.active_block.current_sqares()):
            self.active_block.rotate(-x)
            return 0
        return 1
    def defill(self):
        for i in reversed(range(self.height)):
            if self.matrix[i].count(0) == 0:
                if self.matrix[i].count(2) != 0:
                    self.dot_meter += 1
                    self.game_turn_time += self.red_block_reward
                self.bring_down(i)
                self.level += 1
                if self.defill_time_decrease:
                    self.game_turn_time *= self.turn_time_decrease
                self.troll_meter_to_send += 1
                if self.troll_time_decrease:
                    self.troll_time_modifier *= self.turn_time_decrease
    def bring_down(self, line):
        for i in range(line + 1, self.height):
            self.matrix[i-1] = deepcopy(self.matrix[i])
    def advance_to_bottom(self):
        while not self.advance_turn():
            pass
    def draw(self, screen):
        self.add_block(self.pos, self.active_block.current_sqares())
        for i in range(self.visible_height):
            for j in range(self.width):
                b_pos = (
                    self.bo_pos[0] + self.block_image.get_width() * j,
                    self.bo_pos[1] + self.block_image.get_height() * (self.visible_height - i))
                if self.matrix[i][j] == 1:
                    if i < self.level:
                        screen.blit(self.green_block_image, b_pos)
                    else:
                        screen.blit(self.block_image, b_pos)
                elif self.matrix[i][j] == 2:
                    screen.blit(self.red_block_image, b_pos)
                elif self.matrix[i][j] == 0:
                    screen.blit(self.gray_grid_image, b_pos)
        self.erase_block(self.pos, self.active_block.current_sqares())
        #draw_border
        self.draw_border(screen)
        self.draw_end_count(screen)
        if self.guide_on:
            self.draw_guidelines(screen)

    def draw_border(self, screen):
        for i in range(-1, self.width + 1):
            b_pos = (self.bo_pos[0] + self.block_image.get_width()*i,self.bo_pos[1] + self.block_image.get_height()*(0))
            screen.blit(self.brown_block_image, b_pos)
            b_pos = (self.bo_pos[0] + self.block_image.get_width()*i,self.bo_pos[1] + self.block_image.get_height()*(self.visible_height+1))
            screen.blit(self.brown_block_image, b_pos)
        for i in range(self.visible_height+1):
            b_pos = (self.bo_pos[0] + self.block_image.get_width()*(-1),self.bo_pos[1] + self.block_image.get_height()*(i))
            screen.blit(self.brown_block_image, b_pos)
            b_pos = (self.bo_pos[0] + self.block_image.get_width()*(self.width),self.bo_pos[1] + self.block_image.get_height()*(i))
            screen.blit(self.brown_block_image, b_pos)
    def draw_matrix(self, screen, matrix, pos, image):
        for i in range(len(matrix)):
            for j in range(len(matrix[i])):
                if matrix[i][j] == 1:
                    b_pos = (pos[0]+image.get_width()*j,pos[1]+image.get_height()*i)
                    screen.blit(image, b_pos)
    def draw_end_count(self, screen):
        pos = [0,0]
        pos[0] = self.bo_pos[0] + self.end_count_pos[0]
        pos[1] = self.bo_pos[1] + self.end_count_pos[1]
        self.draw_matrix(screen, self.end_count_matrix, pos, self.green_block_image)
    def draw_guidelines(self, screen):
            guide_pos = deepcopy(self.pos)
            while not self.check_block(guide_pos, self.active_block.current_sqares()):
                guide_pos[1] -= 1
            guide_pos[1] += 1
            for sq in self.active_block.current_sqares():
                b_pos = (self.bo_pos[0] +self.blue_guidelines_image.get_width()*(guide_pos[0]+sq[0]),self.bo_pos[1] + self.blue_guidelines_image.get_height()*(self.visible_height - (guide_pos[1]+sq[1])))
                screen.blit(self.blue_guidelines_image, b_pos)
    def end(self):
        if self.matrix[self.visible_height-1].count(0) != self.width:
            self.end_count += 1
            self.end_count_matrix[0].append(1)
            self.width += 1
            self.reset_matrix()
            self.game_turn_time += self.end_time_increase
            self.spawn_block()
            return True
        else:
            return False
    def time_advance(self):
        self.curr_game_step = time()
        if self.curr_game_step - self.last_game_step >= self.game_turn_time:
            self.last_game_step = self.curr_game_step
            self.advance_turn()
            return True
        else:
            return False
    def change_enemy_board(self, enemy_board):
        self.send_troll(enemy_board)
    def send_troll(self, enemy_board):
        enemy_board.troll_meter = self.level - enemy_board.troll_counter
        if enemy_board.troll_time_decrease:
            power = max(0, self.level - enemy_board.troll_time_counter)
            enemy_board.game_turn_time *= self.turn_time_decrease**power
            enemy_board.troll_time_counter += power
    def init_images(self, scale):
        pos = int(16 * scale)
        pos = (pos, pos)
        self.block_image = pygame.transform.scale(pygame.image.load("images/block.png"), pos)
        self.red_block_image = pygame.transform.scale(pygame.image.load("images/red_block.png"), pos)
        self.green_block_image = pygame.transform.scale(pygame.image.load("images/green_block.png"), pos)
        self.yellow_block_image = pygame.transform.scale(pygame.image.load("images/yellow_block.png"), pos)
        self.brown_block_image = pygame.transform.scale(pygame.image.load("images/brown_block.png"), pos)
        self.blue_block_image = pygame.transform.scale(pygame.image.load("images/blue_block.png"), pos)
        self.purple_block_image = pygame.transform.scale(pygame.image.load("images/purple_block.png"), pos)
        self.blue_guidelines_image = pygame.transform.scale(pygame.image.load("images/blue_guidelines.png"), pos)
        self.gray_grid_image = pygame.transform.scale(pygame.image.load("images/gray_grid.png"), pos)

        self.scale = scale
    def draw_win(self, screen):
        win_mat = [
                [1,0,0,0,1,0,1,0,1,1,0,1,0,0],
                [1,0,1,0,1,0,1,0,1,0,1,1,0,0],
                [0,1,0,1,0,0,1,0,1,0,0,1,0,0],
                ]
        pos = [self.bo_pos[0], self.bo_pos[1] + 16*(self.visible_height/2)*self.scale]
        self.draw_matrix(screen, win_mat, pos, self.blue_block_image)
    def draw_level(self, screen):
        mat = str_to_matrix(str(self.level))
        pos = [self.bo_pos[0], self.bo_pos[1] + 16*(self.visible_height/2)*self.scale]
        self.draw_matrix(screen, mat, pos, self.blue_block_image)
    def sp_level_win(self):
        if self.level >= 10:
            self.width += 1
            self.reset_matrix()
            self.game_turn_time += self.end_time_increase
            self.sp_level += 1
            self.level = 0
            return True
        else:
            return False
    def sp_win(self):
        if self.sp_level == 5:
            return True
        else:
            return False
    def AI_move(self):
        choice = self.ai.move()
    def win_func1(self):
        return self.level >= self.visible_height
    def loss_func1(self):
        return self.end_count >= 3
    def outcome(self):
        for win_con in self.win_conditions:
            if win_con():
                return 1
        for loss_con in self.loss_conditions:
            if loss_con():
                self.forfeit = True
                return 2
        if self.forfeit:
            return 2
        return 0
    def set_win_cons(self, func_str):
        self.win_conditions = []
        for i, val in enumerate(func_str):
            if val != "0":
                self.win_conditions.append(self.win_functions[i])
    def set_loss_cons(self, func_str):
        self.loss_conditions = []
        for i, val in enumerate(func_str):
            if val != "0":
                self.loss_conditions.append(self.loss_functions[i])
    def set_game_cons(self, win_cons, loss_cons):
        self.set_win_cons(win_cons)
        self.set_loss_cons(loss_cons)
    def set_forfeit(self, value):
        self.forfeit = value
    def set_level(self, level):
        self.level = level
    def add_troll(self, value):
        self.troll_meter_to_send += value
    def add_wait_connection(self, ip):
        self.connection = Connection(self, ip, send=False)
    def add_send_connection(self, ip):
        self.connection = Connection(self, ip, send=True)