110 lines
3.4 KiB
GDScript
110 lines
3.4 KiB
GDScript
extends Node
|
|
var nakama_client: NakamaClient
|
|
var nakama_session: NakamaSession
|
|
var nakama_socket: NakamaSocket
|
|
|
|
@export var player: Player
|
|
|
|
var predicted_tick = 0
|
|
var delta_counter = 0
|
|
var current_match_id = ""
|
|
|
|
func _ready() -> void:
|
|
print("Attempting auth.")
|
|
await attempt_auth()
|
|
print("Attempting to create debug match.")
|
|
await create_and_join_debug_match()
|
|
nakama_socket.received_match_state.connect(self._on_match_state)
|
|
|
|
func _process(delta: float) -> void:
|
|
if current_match_id == "":
|
|
return
|
|
|
|
%BulletManager.bullet_intraframe_mov_delta = predict_tick_and_broadcast(delta)
|
|
%BulletManager.predicted_tick = predicted_tick
|
|
|
|
func _on_match_state(p_state : NakamaRTAPI.MatchData):
|
|
match p_state.op_code:
|
|
2:
|
|
var data = JSON.parse_string(p_state.data)
|
|
|
|
# Set player position if server demands a forced position
|
|
if data["forcePlayerPos"]:
|
|
player.set_position_data(
|
|
Vector2(
|
|
float(data["playerHitPos"]["x"]),
|
|
float(data["playerHitPos"]["y"])
|
|
),
|
|
float(data["playerHitPos"]["radius"]),
|
|
float(data["playerGrazePos"]["radius"])
|
|
)
|
|
%GrazeLabel.text = "Graze: " + str(data["graze"])
|
|
|
|
# Handle player death if there is an ongoing death timer
|
|
if int(data["deathTimer"]) > 0:
|
|
%Player.kill()
|
|
elif int(data["deathTimer"]) == 0:
|
|
%Player.resurrect()
|
|
|
|
# Spawn new bullets
|
|
for b in data["newBullets"]:
|
|
var bullet = DanmakuBullet.new()
|
|
bullet.setup_bullet(
|
|
int(b["class"]),
|
|
int(b["tick"]),
|
|
b["x"],
|
|
b["y"],
|
|
b["radius"],
|
|
b["vel_x"],
|
|
b["vel_y"])
|
|
bullet.texture = load("res://test-bullet.png")
|
|
bullet.position = bullet.get_current_pos(int(b["tick"]))
|
|
|
|
# Reimplemented from ScalableSprite2D here atm
|
|
var scale_ratio = (b["radius"] * 2) / bullet.texture.get_width()
|
|
bullet.scale = Vector2(scale_ratio, scale_ratio)
|
|
bullet.z_index = 4
|
|
|
|
%BulletManager.add_child(bullet)
|
|
%BulletManager.bullets.append(bullet)
|
|
predicted_tick = int(b["tick"])
|
|
delta_counter = 0
|
|
|
|
func attempt_auth() -> void:
|
|
nakama_client = Nakama.create_client("defaultkey", "127.0.0.1", 7350, "http")
|
|
nakama_session = await nakama_client.authenticate_device_async(OS.get_unique_id())
|
|
nakama_socket = Nakama.create_socket_from(nakama_client)
|
|
|
|
var connected: NakamaAsyncResult = await nakama_socket.connect_async(nakama_session)
|
|
if connected.is_exception():
|
|
print("An error occured when creating nakama socket: %s" % connected)
|
|
return
|
|
print("Oh baby we're ready.")
|
|
|
|
func create_and_join_debug_match() -> void:
|
|
var response: NakamaAPI.ApiRpc = await nakama_client.rpc_async(nakama_session, "manual_force_create_br_match_rpc")
|
|
|
|
if response.is_exception():
|
|
print("An error occurred when calling manual_force_create_br_match_rpc: %s" % response)
|
|
return
|
|
|
|
var debug_br_match: NakamaRTAPI.Match = await nakama_socket.join_match_async(response.payload)
|
|
|
|
if debug_br_match.is_exception():
|
|
print("An error occurred when joining debug BR match: %s" % response)
|
|
return
|
|
else:
|
|
current_match_id = response.payload
|
|
|
|
func predict_tick_and_broadcast(delta) -> float:
|
|
delta_counter += delta
|
|
|
|
# New tick (60 tick rate), broadcast player inputs
|
|
var tick_time = 0.01666666666
|
|
if delta_counter >= tick_time:
|
|
predicted_tick += 1
|
|
delta_counter -= tick_time
|
|
var pos = %Player.position
|
|
var json_string = JSON.stringify({"x": pos.x, "y": pos.y})
|
|
nakama_socket.send_match_state_async(current_match_id, 0, json_string)
|
|
return delta_counter / tick_time
|