【Godot4.x】アクションゲームの基本ギミックの実装方法 (Part.2)

## 更新.
func _physics_process(delta: float) -> void:
	if _state == eState.FALLING:
		# 落下
		velocity.y += GRAVITY
		if velocity.y > MAX_SPEED:
			velocity.y = MAX_SPEED
		
		# 上にプレイヤーがいたら位置を調整する.
		var col = move_and_collide(velocity * delta)
		_fit_player(col, delta)
		
		if Common.is_in_camera(global_position, Map.get_tile_size(), 2.0) == false:
			# 画面外で消える.
			_state = eState.HIDE
			visible = false

## 落下時にプレイヤーにフィットさせる.
func _fit_player(col:KinematicCollision2D, delta:float) -> void:
	if col == null:
		return
	var collider = col.get_collider()
	if collider is Player:
		# 対象はプレイヤーのみ.
		var player = collider as Player
		player.position.y += velocity.y * delta

## 更新.
func _physics_process(delta: float) -> void:
		...
		
		# 上にプレイヤーがいたら位置を調整する.
		var col = move_and_collide(velocity * delta)
		_fit_player(col, delta)
		
		...

func _physics_process(delta: float) -> void:
	_spr.scale.y = 1.0
	if is_instance_valid(_player) == false:
		return # プレイヤー領域内にいないので何もしない.
	
	# バネで押し返す.
	## バネの底とプレイヤーの位置との差を求めて弾力を求める.
	var size = Map.get_tile_size() # 1タイルあたりのサイズ.
	var bottom = position.y + (size / 2.0) # 基準位置を底に移動.
	var d = bottom - _player.position.y
	if d <= 0:
		d = 0 # 最大の力.
	
	## 正規化.
	var damp_rate = 1.0 * (size - d) / size
	
	## バネの見た目を伸縮する.
	_spr.scale.y = 1 - damp_rate
	if _spr.scale.y < 0.2:
		_spr.scale.y = 0.2
	# 弾力補正値.
	damp_rate += 0.5
	if Input.is_action_pressed("action"):
		# ジャンプボタンを押していたら弾力を2倍にする.
		damp_rate *= 2.0
	
	# バネ速度を設定.
	var damp_velocity = Vector2.UP * (POWER * damp_rate * delta)
	_player.set_spring_velocity(damp_velocity)

## びっくりスイッチを作る.
func _create_exclamation_block(i:int, j:int) -> void:
	var type = Map.eType.EXCLAMATION_BLOCK # びっくりブロックを探す処理.
	var p = Vector2i(i, j)
	# まずは下を調べる.
	p.y += 1
	if Map.get_floor_type(p) != type:
		return # 下がびっくりブロックでなければ何もしない.
	# 見つかったのタイルを消しておく.
	Map.erase_cell(p)
	
	# びっくりブロックを生成.
	var block = EXCLAMATION_BLOCK_OBJ.instantiate()
	block.position = Map.grid_to_world(p)
	
	# 座標リスト.
	var pos_list = _create_passage_list(p, Map.eType.EXCLAMATION_BLOCK)
	_bg_layer.add_child(block)
	block.setup(pos_list)

## 経路リストを作る.
## @param base 開始位置.
## @param search_type 経路とみなすタイル.
## @param end_point_type 終端とするタイル.
func _create_passage_list(base:Vector2i, search_type:int, end_point_type:int=-1) -> Array:
	var ret = []
	
	var p = base # 基準座標をコピーして使う.
	for idx in range(64): # 最大64としておく.
		# 見つかったかどうか.
		var found = false
		var is_end = false # 終了. 
		# 上下左右を探す.
		for dir in [Vector2i.LEFT, Vector2i.UP, Vector2i.RIGHT, Vector2i.DOWN]:
			var p2 = p + dir
			var type = Map.get_floor_type(p2)
			if type == end_point_type:
				# 終端タイル.
				is_end = true
				# 終端座標を結果に含めたいのでbreakしない.
				# break
			elif type != search_type:
				continue # 検索対象のタイルでない.
				
			# 見つかったタイルを消しておく.
			Map.erase_cell(p2)
			ret.append(p2 - base) # 基準からの相対座標.
			found = true
			# 次の座標から調べる.
			p = p2
			# 1方向だけ見つかれば良いのでbreak.
			break
			
		if is_end:
			# おしまい.
			break
		if found == false:
			# おしまい.
			break
	
	return ret

## びっくりスイッチを作る.
func _create_exclamation_block(i:int, j:int) -> void:
	...

	# 座標リスト.
	var pos_list = _create_passage_list(p, Map.eType.EXCLAMATION_BLOCK)
	_bg_layer.add_child(block)
	block.setup(pos_list)

## 更新.
func _process(delta: float) -> void:
	var pressed = _is_pressed_switch()
	
	match _state:
		eState.NOT_PRESS:
			if pressed:
				# スイッチを踏んだ.
				Common.play_se("switch")
				_create_blocks()
		eState.PRESS:
			if pressed == false:
				# スイッチから離れたら時間経過.
				_state = eState.PRESS_TO_RELEASE
				_count_timer = TIMER_COUNT_DOWN
		eState.PRESS_TO_RELEASE:
			if pressed:
				# 再び押したらカウントやり直し.
				if _count_timer != TIMER_COUNT_DOWN:
					Common.play_se("switch", 4)
				_count_timer = TIMER_COUNT_DOWN
			else:
				_count_timer -= delta
			
			if _count_timer <= 0:
				# 時間切れ.
				_erase_blocks()
	
	# アニメ更新.
	_update_anim()

## スイッチを踏んでいるかどうか.
func _is_pressed_switch() -> bool:
	if is_instance_valid(_player) == false:
		# プレイヤーが離れていたら踏んでいないことにする.
		return false
	
	if _player.is_landing():
		return true # 着地していたら踏んでいるものとする.
	
	return false

## プレイヤーが衝突.
func _on_exclamation_switch_body_entered(body: Node2D) -> void:
	if not body is Player:
		return # Player以外は除外.
	_player = body

## プレイヤーが離れた.
func _on_exclamation_switch_body_exited(body: Node2D) -> void:
	if not body is Player:
		return # Player以外は除外.
	_player = null

## ブロックを生成する.
func _create_blocks() -> void:
	if _state == eState.PRESS:
		return # すでに押していたら何もしない.
	if _state == eState.PRESS_TO_RELEASE:
		return # すでに押していたら何もしない.
	
	var base = Vector2i.ZERO
	var idx = 1
	for grid_pos in _pos_list:
		var wall = WALL_OBJ.instantiate()
		# 「！ブロック」からの移動経路を作る.
		var p_list = [base]
		for i in range(idx):
			p_list.append(_pos_list[i])
		# 後で消すために "Walls"ノードに登録.
		_walls.add_child(wall)
		wall.setup_moving(p_list)
		
		idx += 1
	
	_state = eState.PRESS

## ブロックを消す.
func _erase_blocks() -> void:
	if _state == eState.NOT_PRESS:
		return # すでに消されていたら何もしない.
	
	for block in _walls.get_children():
		block.vanish()
	_state = eState.NOT_PRESS

## 移動の更新.
func _update_moving(delta:float) -> void:
	# 移動タイマー経過.
	_moving_timer += delta
	
	# タイマーを正規化.
	var rate = _moving_timer / MOVING_TIMER
	# イージングで動かす.
	rate = Ease.cube_out(rate)
	if rate >= 1.0:
		# 次の地点に到達した.
		_moving_timer = 0.0
		rate = 0.0
		_pos_list.pop_front()
		if _pos_list.size() == 1:
			# ゴールした.
			Common.play_se("block")
			position = Map.grid_to_world(_pos_list[0], false)
			_pos_list.clear()
			# 四角エフェクトの発生.
			var p =ParticleUtil.add(global_position, ParticleUtil.eType.RECTLINE, 0, 0, 1.0, 0.5)
			p.color = Color.CHOCOLATE
			return
	
	# _pos_list[0]から[1]へ lerp で動かす.
	var a = Vector2(_pos_list[0])
	var b  = Vector2(_pos_list[1])
	a = a.lerp(b, rate)
	# マップ座標系をワールド座標に変換.
	# 親オブジェクトにぶら下がっている (親からの相対座標) のでこれで良い.
	position = Map.grid_to_world(a, false)

## タイルからオブジェクトを作る.
func _create_obj_from_tile() -> void:
	for j in range(Map.height):
		# ハシゴにフタをするため下から処理する.
		j = Map.height - (j + 1)
		for i in range(Map.width):
			var pos = Map.grid_to_world(Vector2(i, j))
			var type = Map.get_floor_type_from_world(pos)
			if type == Map.eType.NONE:
				continue
			
			# 以下タイルマップの機能では対応できないタイルの処理.
			match type:
				...
					
				Map.eType.VORTEX_WARP:
					# ワープ渦巻き.
					# 終端判定があるので先に消しておく.
					Map.erase_cell_from_world(pos)
					_create_vortex_warp(i, j)
					
				...

## ワープ渦巻きの経路を作る.
func _create_vortex_warp(i:int, j:int) -> void:
	var search_type = Map.eType.VORTEX_PASSAGE # 渦巻き通路を探す処理.
	var end_type = Map.eType.VORTEX_WARP # ワープ渦巻きがゴール.
	var p = Vector2i(i, j)
	
	# ワープ渦巻きを生成.
	var vortex1 = VORTEX_OBJ.instantiate()
	
	# 座標リスト.
	var pos_list = _create_passage_list(p, search_type, end_type)
	pos_list.push_front(Vector2i.ZERO) # 開始地点を入れておく.
	#print(pos_list)
	_bg_layer.add_child(vortex1)
	vortex1.setup(p, pos_list, -8)
	
	# 終端用のワープ渦巻きを作っておく.
	var pos_list2 = pos_list.duplicate() # 複製.
	# 終端を取得.
	var end_pos = pos_list2.back()
	# 終端が開始.
	var p2 = p + end_pos
	var vortex2 = VORTEX_OBJ.instantiate()
	# 逆順にする.
	pos_list2.reverse()
	pos_list2 = pos_list2.map(func(a): return a-end_pos) # end_pos基準に変換.
	#print(pos_list2)
	_bg_layer.add_child(vortex2)
	vortex2.setup(p2, pos_list2, 8)

	# 終端を取得.
	var end_pos = pos_list2.back()
	# 逆順にする.
	pos_list2.reverse()
	# end_pos基準に変換.
	pos_list2 = pos_list2.map(func(a): return a-end_pos)

# pos_list2 = pos_list2.map(func(a): return a-end_pos)
# と同じ処理.

# 結果格納用.
var ret = []

for a in pos_list2:
  # end_posで減算した値を格納.
  ret.append(a - end_pos)

# 結果を代入.
pos_list2 = ret

## プレイヤーとの衝突判定.
func _on_body_entered(body: Node2D) -> void:
	if not body is Player:
		return # プレイヤー以外は何もしない.
	
	var player = body as Player
	# 渦巻きからの相対なので絶対座標に置き換える.
	var p_list = _pos_list.map(func(a): return a + _grid_pos)
	player.start_warp(p_list)