Godot3 で作る進化形マッチ 3 パズルゲーム

###Piece.gd###
extends Area2D

# プレイヤーが動かしているピースに衝突したら発信するシグナル（引数にピース自身を渡す）
signal collided(self_piece)
# ピースの色を設定するプロパティ
export (String) var color
# マッチした場合のフラグとなるプロパティ
var matched = false
# マッチしたピースのグループに割り振られるインデックス
var matched_index = 0
# プレイヤーが動かしている場合のフラグとなるプロパティ
var held = false
# ピースのテクスチャと同じオフセット
var offset = Vector2(35, -35)
# Spriteノードへの参照
onready var sprite = $Sprite
# Tweenノードへの参照
onready var tween = $Tween

# メインループで毎フレーム呼ばれる組み込みメソッド
func _process(_delta):
    # もしプレイヤーがピースを移動中だったら
	if held:
        # ピースの位置を(35, -35)ずらしてマウスに追随させる
		position = get_global_mouse_position() - offset

# ピースを移動させるメソッド
func move(destination):
    # Tweenノードのアニメーションを設定する
    # ピースを0.1秒かけて現在の位置から引数destinationの位置まで移動させる
	tween.interpolate_property(self, "position", position, destination, .1, Tween.TRANS_QUINT, Tween.EASE_IN)
    # Tweenノードのアニメーションを開始する
	tween.start()

# ピースがマッチした時に呼ばれるメソッド
func make_matched(index):
    # マッチのフラグを立てる
	matched = true
    # マッチしたグループごとのインデックス（引数index）を割り当てる
	matched_index = index
    # ピースの色を半透明にする
	modulate = Color(1,1,1,.5)

# プレイヤーの指がピースに触れたら呼ばれるメソッド
func enable_held():
    # プレイヤーが動かしているフラグを立てる
	held = true
    # ピースの色を20％透明にする
	modulate = Color(1, 1, 1, 0.8)

# プレイヤーが指をピースから離したら呼ばれるメソッド
func disable_held():
    # プレイヤーが動かしているフラグを解除する
	held = false
    # ピースの色をデフォルトに戻す
	modulate = Color(1, 1, 1, 1)

###Piece.gd###

# Area2Dが当たったらシグナルが発信されて呼ばれるメソッド
func _on_Piece_area_entered(area):
    # もし当たったArea2Dが「Pieces」グループ（つまりPieceのインスタンス）で...
    # かつ、プレイヤーが動かしているピースだったら
	if area.is_in_group("Pieces") and area.held:
        # 引数に自分自身のピースを渡してシグナル collided を発信する
		emit_signal("collided", self)

###Grid.gd###

extends Area2D

# ピースを動かして指を離した後の自動処理開始時に発信するシグナル
signal waiting_started

# 各色のピースのシーンファイルを要素とした配列
const pieces_scn = [
	preload("res://Pieces/PieceBeige.tscn"),
	preload("res://Pieces/PieceBlue.tscn"),
	preload("res://Pieces/PieceGreen.tscn"),
	preload("res://Pieces/PiecePink.tscn"),
	preload("res://Pieces/PieceYellow.tscn")
]

# x軸方向のグリッド数
var width: = 7
# y軸方向のグリッド数
var height: = 6
# x軸方向のグリッド開始位置（pixel）
var x_start: = 70
# y軸方向のグリッド開始位置（pixel）
var y_start: = 1050
# 1グリッドのサイズ（PieceのSpriteのTextureと同じにする）
var grid_size: = 70
# ピースが生成される時に何グリッドy軸方向にズラして落とすか
var y_offset: = 3

# 盤面のピースの配置を表す配列（二次元配列）
var board = []
# プレイヤーが動かしているピースの参照
var moving_piece
# プレイヤーが動かしているピースの最後の位置（グリッド）
var last_pos = Vector2()

# ゲーム開始時の準備中のフラグ
var is_initializing = true
# プレイヤーがピースを動かしている場合のフラグ
var is_touching = false
# ピース入れ替え中のフラグ
var is_swapping = false
# プレイヤーがピースを動かした後の自動処理中のフラグ
var is_waiting = false

# マッチしたピースのグループの数（カウントアップする）
var matched_groups = 0

# PiecesContainerノードの参照
onready var pieces_container = $PiecesContainer
# TouchTimerノードの参照
onready var touch_timer = $TouchTimer
# WaitTimerノードの参照
onready var wait_timer = $WaitTimer

###Grid.gd###

# シーンが読み込まれたら呼ばれる関数
func _ready():
    # ランダムな数を生成する関数の出力結果を毎回ランダムにするための組み込み関数を呼ぶ
	randomize()
    # board（配列）を盤面のグリッドを構成する二次元配列にする
	board = make_2d_array() # このあと定義
    # ピースを生成して盤面に配置して盤面情報を board に反映する
	spawn_pieces() # このあと定義
	is_initializing = false

# 盤面のグリッドを構成する二次元配列を生成するメソッド
func make_2d_array() -> Array:
    # array という名前の配列を用意
	var array = []
    # array に x 軸方向のグリッド数だけ空の配列を入れる
	for i in width:
		array.append([])
        # さらにそれぞれの配列に y 軸方向のグリッド数だけ暫定的に null を入れる
		for j in height:
			array[i].append(null)
    # できあがった二次元配列を返す
	return array

# ピースを生成して盤面に配置して盤面情報を board に反映するメソッド
func spawn_pieces():
    # x軸方向のグリッド数だけループ
	for i in width:
        # y軸方向のグリッド数だけループ
		for j in height:
            # 全ピースの二次元配列上で該当グリッドにピースが存在しない場合
            #（ゲーム開始時は全部 null）
			if board[i][j] == null:
                # 各色のピースのシーンからランダムで１つ選択してインスタンス化
				var index = floor(rand_range(0, pieces_scn.size()))
				var piece = pieces_scn[index].instance()
                # もしゲーム開始時の準備中だったら
				if is_initializing:
                    # マッチしてしまった場合は、ピースのインスタンスを削除してやり直し
					while match_at(i, j, piece.color): # このあと定義
						piece.queue_free()
						index = floor(rand_range(0, pieces_scn.size()))
						piece = pieces_scn[index].instance()
                # ピースのインスタンスをPiecesContainerノードの子にする
				pieces_container.add_child(piece)
                # ピースのインスタンスの collided シグナルを...
                # _on_Piece_collided メソッド（あとで定義）に接続する
				piece.connect("collided", self, "_on_Piece_collided")
                # ピースのインスタンスを配置位置より y_offset 分ずらして置き...
                # そこから配置位置へ移動させる（落とす）
				piece.position = grid_to_pixel(i, j + y_offset) # このあと定義
				piece.move(grid_to_pixel(i, j)) # このあと定義
                # 盤面情報として board の適切なインデックスの要素に生成したピースを追加
				board[i][j] = piece

###Grid.gd###

# 指定したグリッド位置で同じ色ピースが３つ以上並んでいるか確認するメソッド
# 引数columnはx軸のグリッド位置、rowはy軸のグリッド位置、colorはピースの色
func match_at(column, row, color):
    # 指定したグリッドの x 軸方向の位置が3以上の場合
	if column >= 2:
        # 指定したグリッド位置の左隣ともう一つ左隣にピースがある場合
		if board[column-1][row] != null \
        and board[column-2][row] != null:
            # 左隣ともう一つ左隣のピースの色が指定したピースの色と同じ場合
			if board[column-1][row].color == color \
            and board[column-2][row].color == color:
                # true を返す
				return true
    # 指定したグリッドの y 軸方向の位置が3以上の場合
	if row >= 2:
        # 指定したグリッド位置の下ともう一つ下にピースがある場合
		if board[column][row-1] != null \
        and board[column][row-2] != null:
            # 下ともう一つ下のピースの色が指定したピースの色と同じ場合
			if board[column][row-1].color == color \
            and board[column][row-2].color == color:
                # true を返す
				return true

# グリッドの位置をピクセルの位置に変換するメソッド
func grid_to_pixel(column, row) -> Vector2:
    # 先にピクセル位置出力用に Vector2 型の変数 pixel_pos を定義
	var pixel_pos = Vector2()
    # ピクセル x 座標 = x 軸方向のグリッド開始位置 + グリッドサイズ x グリッド x 座標
	pixel_pos.x = x_start + grid_size * column
    # ピクセル y 座標 = y 軸方向のグリッド開始位置 - グリッドサイズ x グリッド y 座標
	pixel_pos.y = y_start - grid_size * row
    # ピクセル座標を返す
	return pixel_pos

###Grid.gd###

# ピクセルの位置をグリッドの位置に変換するメソッド
func pixel_to_grid(pixel_x, pixel_y) -> Vector2:
	var grid_pos = Vector2()
	grid_pos.x = floor((pixel_x - x_start) / grid_size)
	grid_pos.y = floor((pixel_y - y_start) / -grid_size)
	return grid_pos

###Grid.gd###

# 指定した位置が盤面グリッドの範囲内かどうかを返すメソッド
func is_in_grid(grid_position: Vector2) -> bool:
	if grid_position.x >= 0 and grid_position.x < width \
	and grid_position.y >= 0 and grid_position.y < height:
        # 盤面グリッドの範囲内だったら true を返す
		return true
	else:
        # 盤面グリッドの範囲外だったら false を返す
		return false

###Grid.gd###

# ゲームのメインループで毎フレーム呼ばれる関数
func _process(_delta):
    # もしマッチングの処理中でなければ
	if not is_waiting:
        # プレイヤーの入力を処理する
		touch_input() # このあと定義

# プレイヤーの入力を処理するメソッド
func touch_input():
    # もし画面に指が触れたら
	if Input.is_action_just_pressed("touch"):
        # ピースに触れた時の処理を実行するメソッドを呼ぶ
		touch_piece() # このあと定義
    # もし画面から指が離れたら
	if Input.is_action_just_released("touch") and is_touching:
        # ピースから指が離れた時の処理を実行するメソッドを呼ぶ
		release_piece() # このあと定義

# ピースに触れた時の処理を実行するメソッド
func touch_piece():
    # 指が触れた時のピクセル座標を取得する
	var pos = get_global_mouse_position()
    # ピクセル座標からグリッド座標に変換する
	var grid_pos = pixel_to_grid(pos.x, pos.y)
    # もしグリッド座標が盤面の範囲内だったら
	if is_in_grid(grid_pos):
        # 動かしているピースの最後の位置としてグリッド座標を登録
		last_pos = grid_pos
        # 動かしているピースとしてグリッド座標に位置するピースを登録
		moving_piece = board[last_pos.x][last_pos.y]
        # ピースを動かしているフラグを立てる
		is_touching = true
        # 動かしているピースインスタンス自体の動かしているフラグも立てる
		moving_piece.enable_held()
        # ピースを動かせる制限時間のタイマースタート
		touch_timer.start()

# ピースから指が離れた時の処理を実行するメソッド
func release_piece():
    # 二次元配列 board の要素から動かしていたピースを見つけたら...
    # 動かしていたピースを盤面グリッドにきっちり収める
	for i in width:
		for j in height:
			if board[i][j] == moving_piece:
				moving_piece.move(grid_to_pixel(i, j))
				break
    # 動かしていたピースインスタンス自体の動かしているフラグを解除する
	moving_piece.disable_held()
    # ピースを動かしているフラグを解除する
	is_touching = false
    # ピースを動かせる制限時間のタイマーストップ
	touch_timer.stop()
    # このあとのマッチング自動処理開始のシグナルを発信
	emit_signal("waiting_started")

###Grid.gd###

# Piece インスタンスの collided シグナルで呼ばれるメソッド
func _on_Piece_collided(self_piece):
    # ピースを動かしていて、かつピース交換中でなければ
	if is_touching and not is_swapping:
        # ピース交換中のフラグを立てる
		is_swapping = true
        # ピースを交換するメソッドを呼ぶ
		swap_pieces(self_piece) # あとで定義
        # ピース交換中のフラグを解除
		is_swapping = false

# 動かしているピースとそれに当たったピースの場所を入れ替えるメソッド
# 引数 collided_piece には動かしているピースに当たったピースが渡される
func swap_pieces(collided_piece):
    # 当たったピースのグリッド座標を取得する。
	var collided_pos = pixel_to_grid(collided_piece.position.x, collided_piece.position.y)
    # 二次元配列 board 上の動かしているピースと動かしているピースが一致していれば
	if board[last_pos.x][last_pos.y] == moving_piece:
        # board の動かしているピースの位置に当たったピースを入れる
		board[last_pos.x][last_pos.y] = collided_piece
        # 当たったピースを動かしているピースの最後のグリッド座標へ移動させる
		collided_piece.move(grid_to_pixel(last_pos.x, last_pos.y))
        # board の当たったピースの位置に動かしているピースを入れる
		board[collided_pos.x][collided_pos.y] = moving_piece
        # 動かしているピースの最後の位置として当たったピースのグリッド座標を登録する
		last_pos = collided_pos

###Grid.gd###

# 盤面から Area2D がはみ出たときにシグナルで呼ばれるメソッド
func _on_Grid_area_exited(area):
    # はみ出た Area2D が動かしているピースの場合
	if area.is_in_group("Pieces") and area.held:
        # ピースから指が離れた時の処理を実行するメソッドを呼ぶ
		release_piece()

# ピースを動かせる制限時間が切れたときにシグナルで呼ばれるメソッド
func _on_TouchTimer_timeout():
    # 移動中の場合
	if is_touching:
        # ピースから指が離れた時の処理を実行するメソッドを呼ぶ
		release_piece()

###Grid.gd###

# releaseメソッドの最後に発信されるシグナルで呼ばれるメソッド
func _on_Grid_waiting_started():
    
    # 自動処理中のフラグを立てる
	is_waiting = true

    # 人組でマッチしているピースが1組でもあればループし続ける
	while check_matches(): # このあと定義
        # マッチしているピースにフラグを立てるメソッドを呼ぶ
		find_matches() # このあと定義
        # WaitTimerのタイマースタート(0.3秒)
		wait_timer.start()
        # WaitTimerがタイムアウトするまで待機
		yield(wait_timer, "timeout")
    # 自動処理中のフラグを解除する
	is_waiting = false


# マッチしているピースが1組でもあるかチェックするメソッド
func check_matches() -> bool:
    # 盤面の x 軸方向のグリッド数だけループ
	for i in width:
        # 盤面の y 軸方向のグリッド数だけループ
		for j in height:
            # そのグリッド座標にピースが存在していれば
			if board[i][j] != null:
                # そのピースがマッチしていたら
				if match_at(i, j, board[i][j].color):
                    # true を返す
					return true
    # 1組もマッチしているピースがなければ false を返す
	return false


# マッチしているピースにフラグを立てるメソッド
func find_matches():
    # 盤面の x 軸方向のグリッド数だけループ
	for i in width:
        # 盤面の y 軸方向のグリッド数だけループ
		for j in height:
            # そのグリッド座標にピースが存在していれば
			if board[i][j] != null:
                # 現在の色をそのグリッド座標のピースの色と定義する
				var current_color = board[i][j].color
                # もしその x 軸座標が x 軸方向のグリッド数 - 2 より小さければ
				if i < width - 2:
                    # そのピースの右隣とさらにその右隣にピースが存在する場合
					if board[i+1][j] != null \
					and board[i+2][j] != null:
                        # それらのピースの色が現在の色と同じ場合
						if board[i+1][j].color == current_color \
						and board[i+2][j].color == current_color:
                            # マッチした組に割り振る番号の変数を定義
							var matched_index: int
                            # そのピースにすでにマッチしているフラグが立っていれば
							if board[i][j].matched:
                                # マッチした組の番号はそのピースの組の番号とする
								matched_index = board[i][j].matched_index
                            # そのピースにマッチしているフラグが立ってなければ
							else:
                                # マッチした組のグループ数を1増やす
								matched_groups += 1
                                # マッチした組の番号をマッチした組のグループ数とする
								matched_index = matched_groups
                            # その座標のピースにマッチしたフラグを立て、組の番号を割り当て、半透明にする
							board[i][j].make_matched(matched_index)
                            # その座標の右隣のピースも同様にする
							board[i+1][j].make_matched(matched_index)
                            # さらにもう一つ右隣のピースも同様にする
							board[i+2][j].make_matched(matched_index)
                # y軸方向に対しても同様にする
				if j < height - 2:
					if board[i][j+1] != null \
					and board[i][j+2] != null:
						if board[i][j+1].color == current_color \
						and board[i][j+2].color == current_color:
							var matched_index: int
							if board[i][j].matched:
								matched_index = board[i][j].matched_index
							else:
								matched_groups += 1
								matched_index = matched_groups
							board[i][j].make_matched(matched_index)
							board[i][j+1].make_matched(matched_index)
							board[i][j+2].make_matched(matched_index)

###Grid.gd###

# マッチのフラグが立っているピースを削除するメソッド
# 引数 index には削除対象のマッチの組番号を渡す
func delete_matches(index):
    # 盤面の x 軸方向のグリッド数だけループ
	for i in width:
        # 盤面の y 軸方向のグリッド数だけループ
		for j in height:
            # もしそのグリッド座標にピースが存在していれば
			if board[i][j] != null:
                # もしそのグリッド座標のピースにマッチのフラグが立っていたら
				if board[i][j].matched:
                    # もしそのグリッド座標のピースの組番号は削除対象の組番号と一致したら
					if board[i][j].matched_index == index:
                        # そのグリッド座標のピースを解放する
						board[i][j].queue_free()
                        # 二次元配列 board の該当の要素を null にする
						board[i][j] = null

###Grid.gd###

func _on_Grid_waiting_started():
	is_waiting = true

	while check_matches():
		find_matches()
		wait_timer.start()
		yield(wait_timer, "timeout")
		
        # ここを追加
        # マッチしたグループの数が0より大きければ
		if matched_groups > 0:
            # マッチしたグループの数だけループさせる
            # 全て同時に削除せず、マッチした組ごとに削除する
			for index in range(1, matched_groups + 1):
                # マッチしたピースを削除するメソッドを呼ぶ
				delete_matches(index)
                # WaitTimerのタイマースタート(0.3秒)
				wait_timer.start()
                # WaitTimerがタイムアウトするまで待機
				yield(wait_timer, "timeout")
            # マッチしたピースをすべて削除したらマッチしたグループの数を 0 に戻す
			matched_groups = 0

	is_waiting = false

###Grid.gd###

# 空いたグリッドスペースに上のピースを詰める（落とす）メソッド
func collapse_columns():
    # 盤面の x 軸方向のグリッド数だけループ
	for i in width:
        # 盤面の y 軸方向のグリッド数だけループ
		for j in height:
            # もしそのグリッド座標にピースがなければ
			if board[i][j] == null:
                # その y座標より1つ上のグリッドから残りの y軸方向のグリッド数だけループ
				for k in range(j + 1, height):
                    # もしそのグリッド座標にピースが存在していれば
					if board[i][k] != null:
                        # そのグリッド座標のピースを空いたスペースへ移動する
						board[i][k].move(grid_to_pixel(i, j))
                        # 二次元配列 board の要素を入れ替える
						board[i][j] = board[i][k]
						board[i][k] = null
                        # ループ終了
						break

###Grid.gd###

func _on_Grid_waiting_started():
	is_waiting = true

	while check_matches():
		find_matches()
		wait_timer.start()
		yield(wait_timer, "timeout")
		
		if matched_groups > 0:
			for index in range(1, matched_groups + 1):
				delete_matches(index)
				wait_timer.start()
				yield(wait_timer, "timeout")
			matched_groups = 0

        # ここを追加
        # 空いたグリッドスペースに上のピースを詰める（落とす）メソッドを呼ぶ
		collapse_columns()
        # WaitTimerのタイマースタート(0.3秒)
		wait_timer.start()
        # WaitTimerがタイムアウトするまで待機
		yield(wait_timer, "timeout")

	is_waiting = false

###Grid.gd###

func _on_Grid_waiting_started():
	is_waiting = true

	while check_matches():
		find_matches()
		wait_timer.start()
		yield(wait_timer, "timeout")
		
		if matched_groups > 0:
			for index in range(1, matched_groups + 1):
				delete_matches(index)
				wait_timer.start()
				yield(wait_timer, "timeout")
			matched_groups = 0

		collapse_columns()
		wait_timer.start()
		yield(wait_timer, "timeout")

        # ここを追加
        # 空いたスペースにピースを生成するメソッドを呼ぶ
		spawn_pieces()
        # WaitTimerのタイマースタート(0.3秒)
		wait_timer.start()
        # WaitTimerがタイムアウトするまで待機
		yield(wait_timer, "timeout")

	is_waiting = false