Putting All My Hobbies into A Single Project (Boosted: A Propulsion Game)

import {
CognitoIdentityProviderClient,
InitiateAuthCommand,
} from "@aws-sdk/client-cognito-identity-provider";
import crypto from 'crypto';
import { MongoClient } from 'mongodb';

const cognito = new CognitoIdentityProviderClient();

const client = new MongoClient(process.env.MONGODB_URI);

const calculateSecretHash = (username) => {
const message = username + process.env.COGNITO_CLIENT_ID;
const hmac = crypto.createHmac('SHA256', process.env.COGNITO_CLIENT_SECRET);
return hmac.update(message).digest('base64');
};

export const handler = async (event) => {

try {
const body = JSON.parse(event.body);
let { username, password } = body;

if (!username || !password) {
return {
statusCode: 400,
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
message: 'Username and password are required'
})
};
}

const command = new InitiateAuthCommand({
ClientId: process.env.COGNITO_CLIENT_ID,
AuthFlow: 'USER_PASSWORD_AUTH',
AuthParameters: {
'USERNAME': username,
'PASSWORD': password,
'SECRET_HASH': calculateSecretHash(username)
}
});

const response = await cognito.send(command);

const confirmCommand = new AdminConfirmSignUpCommand({
UserPoolId: USER_POOL_ID,
Username: username
});

const result = await collection.aggregate([
{ $match: { username: username } },
{
$project: {
tracks: { $objectToArray: "$tracks" }
}
},
{
$project: {
_id: 0,
keyValues: {
$arrayToObject: {
$map: {
input: "$tracks",
as: "track",
in: {
k: "$$track.k",
v: "$$track.v.time"
}
}
}
}
}
},
{ $replaceRoot: { newRoot: "$keyValues" } }
]).toArray();

if current_request_type == 'signin':
if FileAccess.file_exists(BEST_SCORES_LOCATION):
var dir = DirAccess.open("user://")
dir.remove("*****.save")
var file = FileAccess.open(BEST_SCORES_LOCATION, FileAccess.WRITE)
var trackTimes = response.get('trackTimes')
file.store_line(JSON.stringify(trackTimes))
file.close()

@onready var carousel_container = $CarouselContainer
@onready var track_container = preload('res://scenes/TrackContainer.tscn')
signal carousel_changed(index)

var items = []
var current_index = 0

# Configuration
var spacing = 800
var center_scale = Vector2(1.2, 1.2)
var side_scale = Vector2(0.6, 0.6)
var transition_time = 0.3

func _ready():

GameManager.setup_sound_buttons()

for data in GameManager.tracks_data:
var track = track_container.instantiate()
var best_time = '__'
if GameManager.get_best_time(data['track_identifier']) != -1:
best_time = '%0.2f' %GameManager.get_best_time(data['track_identifier'])
track.get_node('MarginContainer/VBoxContainer/Labels/Best').text = 'Best: ' + best_time
track.get_node('MarginContainer/VBoxContainer/Labels/TrackName').text = data['track_display_name']
track.get_node('MarginContainer/VBoxContainer/Buttons/Play').pressed.connect(func(): SceneManager.change_scene(data['track_identifier']))
track.get_node('MarginContainer/VBoxContainer/Buttons/Leaderboard').pressed.connect(func(): _on_leaderboard_button_pressed(data['track_identifier']))

var preview_image = load(data['preview_image_path'])
track.get_node('TrackPreviewImage').texture = preview_image

var font_color = data['track_name_font_color']
track.get_node('MarginContainer/VBoxContainer/Labels/TrackName').modulate = font_color
carousel_container.add_child(track)

# Get all carousel items
items = carousel_container.get_children()





# Initializing each item
for item in items:

item.size = Vector2(700,420)

# Start all items at normal scale
item.scale = Vector2(1, 1)
# Centering items
item.position = -item.size / 2


# Set initial positions
update_carousel()
func _process(_delta) -> void:
if Input.is_action_just_pressed('left_button'):
previous_item()
if Input.is_action_just_pressed('right_button'):
next_item()

func _on_leaderboard_button_pressed(track_name: String):
var leaderboard_scene = preload('res://scenes/ui/Leaderboard.tscn').instantiate()
leaderboard_scene.track_name = track_name
OverlayManager.push_overlay_node(leaderboard_scene)
print(leaderboard_scene.track_name)

func update_carousel():
for i in range(items.size()):
var item = items[i]
var relative_index = i - current_index

# Calculating target position
var target_position = Vector2(
relative_index * spacing - item.size.x / 2,
-item.size.y / 2
)

# Center item is scaled to be larger, rest are scaled down
var target_scale
if relative_index == 0:
target_scale = center_scale
item.z_index = 1
else:
target_scale = side_scale
item.z_index = 0


var tween = create_tween()
tween.set_parallel(true) # To play the transitions together, more natural

# Position tween
tween.tween_property(item, "position", target_position, transition_time)\
.set_trans(Tween.TRANS_CUBIC)\
.set_ease(Tween.EASE_OUT)

# Scale tween
tween.tween_property(item, "scale", target_scale, transition_time)\
.set_trans(Tween.TRANS_CUBIC)\
.set_ease(Tween.EASE_OUT)

# The further the item, the more faded it should be (may need improving)
var distance = abs(relative_index)
var target_alpha = 1.0 if distance <= 1 else 0.5
tween.tween_property(item, "modulate:a", target_alpha, transition_time)
carousel_changed.emit(current_index)

func next_item():
if current_index < items.size() - 1:
current_index += 1
update_carousel()

func previous_item():
if current_index > 0:
current_index -= 1
update_carousel()

func _on_next_track_button_pressed():
next_item()

func _on_previous_track_button_pressed():
previous_item()

func _setup_country_options():
var countries = GameManager.country_codes.keys()
for country in countries:
var flag = load("res://assets/flags/%s.png" % GameManager.country_codes[country])

signup_country.add_icon_item(flag, country)

func createTimeHash(time: float) -> String:
var combined = str(time) + track_name + env.TIME_HASH_SECRET
var timeHash = combined.sha256_text()
return timeHash

func upload_score():
var access_token = AuthManager.access_token
var id_token = AuthManager.id_token

if !access_token or !id_token:
return

var headers = [
"Content-Type: application/json",
"Authorization: Bearer " + access_token
]
var time = formatTime(time_elapsed)
track_name = track_name.to_lower()
var body = {

"id_token": id_token,
"trackName": track_name,
"time": time,
"timeHash": createTimeHash(time)
}

var json_body = JSON.stringify(body)

var error = http_request.request(
API_URL + "/leaderboard",
headers,
HTTPClient.METHOD_POST,
json_body
)

const verifyTimeHash = (receivedHash, time, trackName) => {
const combined = `${time}${trackName}${process.env.TIME_HASH_SECRET}`;
const checkHash = crypto.createHash('sha256').update(combined).digest('hex');
return checkHash === receivedHash;
};

const isHashValid = verifyTimeHash(timeHash, time, trackName);
if (!isHashValid) {
return {
statusCode: 400,
body: JSON.stringify({ message: "Invalid score" }),
};
}

var sfx_enabled: bool
var sounds = {
"button_sfx_1": preload("res://assets/audio/sfx/button/button_sfx_1.wav"),
"button_sfx_2": preload("res://assets/audio/sfx/button/button_sfx_2.wav"),
"button_sfx_3": preload("res://assets/audio/sfx/button/button_sfx_3.wav"),

}

func play_button_sfx():
if not sfx_enabled:
return
var audio = AudioStreamPlayer.new()
var sound_name = sounds.keys()[randi_range(0, sounds.size() - 1)]
audio.stream = sounds[sound_name]
add_child(audio)
audio.play()
audio.finished.connect(audio.queue_free)