该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

剩下的一半在这

def reset_board(self):

for i, t in enumerate(self.tiles):

t.run_action(A.sequence(A.fade_to(0, 0.3), A.remove()))

new_tile = Tile(choice(colors))

new_tile.grid_pos = t.grid_pos

new_tile.position = t.position

new_tile.scale = 0

new_tile.run_action(A.scale_to(1, 0.5, TIMING_EASE_OUT_2))

self.root_node.add_child(new_tile)

self.tiles[i] = new_tile

def show_hint(self):

self.last_move_t = self.t

shuffled_tiles = list(self.tiles)

shuffle(shuffled_tiles)

for t in shuffled_tiles:

visited = set()

count = self.count_from(t, visited)

if len(visited) >= 3:

for s in visited:

s.run_action(A.repeat(

A.sequence(A.fade_to(0.1, 0.25), A.fade_to(1, 0.25)), 3))

break

else:

self.reset_board()

def touch_began(self, touch):

if touch.location.x < 48 and touch.location.y > self.size.h - 48:

self.show_pause_menu()

return

selected = [s for s in self.tiles if s.selected]

if selected:

return

t = self.tile_for_touch(touch)

if t:

sound.play_effect('ui:click2')

self.select_from(t)

def touch_ended(self, touch):

selected = [s for s in self.tiles if s.selected]

if not selected:

return

if len(selected) < 3:

for t in selected:

t.selected = False

sound.play_effect('ui:switch35')

else:

sound.play_effect('arcade:Coin_5', 0.15)

added_score = int((len(selected) * (len(selected) + 1) / 2) * 10)

self.score += added_score

self.score_label.text = str(self.score)

self.show_points(added_score, selected[-1].position)

self.remove_selected_tiles()

self.last_move_t = self.t

def show_pause_menu(self):

self.paused = True

self.menu = MenuScene('Paused', 'Highscore: %i' % self.highscore, ['Continue', 'New Game'])

self.present_modal_scene(self.menu)

def show_start_menu(self):

self.paused = True

self.menu = MenuScene('Match3', 'Highscore: %i' % self.highscore, ['New Game'])

self.present_modal_scene(self.menu)

def show_game_over_menu(self):

self.paused = True

self.menu = MenuScene('Time Up!', 'Score: %i' % (self.score), ['New Game'])

self.present_modal_scene(self.menu)

def menu_button_selected(self, title):

if title.startswith('Retro Mode'):

self.retro_mode = not self.retro_mode

self.root_node.shader = self.retro_shader if self.retro_mode else None

return 'Retro Mode: ' + ('On' if self.retro_mode else 'Off')

elif title in ('Continue', 'New Game'):

self.dismiss_modal_scene()

self.menu = None

self.paused = False

if title == 'New Game':

self.new_game()

def show_points(self, points, pos):

label = LabelNode('+%i' % (points,), font=('Avenir Next Condensed', 40), position=pos, z_position=1)

label.run_action(A.sequence(A.wait(0.5), A.fade_to(0, 0.5)))

label.run_action(A.sequence(A.move_by(0, 100, 1), A.remove()))

self.root_node.add_child(label)

def tile_for_touch(self, touch):

touch_pos = self.root_node.point_from_scene(touch.location)

for t in self.tiles:

if t.frame.contains_point(touch_pos):

return t

def tile_at(self, x, y):

if 0 <= x < COLS and 0 <= y < ROWS:

return self.tiles[y*COLS+x]

return None

def remove_selected_tiles(self):

new_tiles = []

for col in range(COLS):

drop = 0

for row in range(ROWS):

t = self.tile_at(col, row)

if t.selected:

drop += 1

else:

t.grid_pos = (t.grid_pos[0], max(0, t.grid_pos[1] - drop))

for i in range(drop):

row = ROWS - i - 1

new_tile = Tile(choice(colors), col, row)

new_tile.position = (24 + (col - 0.5*COLS) * 48,

24 + (row - 0.5*ROWS) * 48 + drop * 48)

new_tile.alpha = 0

new_tile.run_action(A.fade_to(1.0, 0.35))

new_tiles.append(new_tile)

self.root_node.add_child(new_tile)

all_tiles = self.tiles + new_tiles

self.tiles = [None] * (ROWS * COLS)

for t in all_tiles:

if t.selected:

t.run_action(A.sequence(A.fade_to(0.0, 0.15), A.remove()))

e = Emitter(t.img_name)

e.position = t.position

self.root_node.add_child(e)

else:

x, y = t.grid_pos

self.tiles[y*COLS+x] = t

dy = t.position.y - (y * 48 - ROWS * 24 + 24)

if dy > 0:

t.run_action(A.move_by(0, -dy, sqrt(dy/750.0), TIMING_EASE_IN_2))

def neighbors(self, tile):

result = []

x, y = tile.grid_pos

directions = [(0, -1), (1, 0), (0, 1), (-1, 0)]

for direction in directions:

neighbor = self.tile_at(x+direction[0], y+direction[1])

if neighbor and neighbor.img_name == tile.img_name:

result.append(neighbor)

return result

def count_from(self, tile, visited, count=1):

visited.add(tile)

neighbors = self.neighbors(tile)

for n in neighbors:

if not n in visited:

visited.add(n)

count += self.count_from(n, visited, count+1)

return count

def select_from(self, tile):

tile.selected = True

neighbors = self.neighbors(tile)

for n in neighbors:

if not n.selected:

n.selected = True

self.select_from(n)

if __name__ == '__main__':

if min(get_screen_size()) < 760:

# portrait-only on iPhone

run(Game(), PORTRAIT)

else:

# allow any orientation on iPad

run(Game())