Added NTween as submodule

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "ntween"]
+	path = ntween
+	url = https://git.nefrace.ru/nefrace/ntween.git

gameover.odin

@@ -1,8 +1,9 @@
 package main
 
-import rl "vendor:raylib"
-import "core:math/ease"
 import "core:fmt"
+import "core:math/ease"
+import "ntween"
+import rl "vendor:raylib"
 
 
 GameOver :: struct {
@@ -22,7 +23,15 @@ gameover_init :: proc(prev: ^GameState = nil) -> ^GameState {
 	state.free = gameover_free
 
 	state.previous = prev
-	tween_to(&state.position.y, WSize.y / 2, 1, ease.Ease.Back_Out, state, gameover_ready)
+	ntween.animate(
+		&vec2_tweens,
+		&state.position,
+		WSize / 2,
+		1,
+		ease.Ease.Back_Out,
+		state,
+		gameover_ready,
+	)
 
 	return state
 }
@@ -33,7 +42,14 @@ gameover_update :: proc(state: ^GameState, delta: f32) {
 		if rl.IsKeyPressed(rl.KeyboardKey.ESCAPE) {
 			gameover.ready_to_go = false
 			rl.StopMusicStream(current_music)
-			tween_to(&Overlay_Opacity, 1.0, 0.5, ease.Ease.Cubic_Out, state, proc(data: rawptr) {
+			ntween.animate(
+				&f32_tweens,
+				&Overlay_Opacity,
+				1.0,
+				0.5,
+				ease.Ease.Cubic_Out,
+				state,
+				proc(data: rawptr) {
 					state := transmute(^GameState)data
 					stack_pop()
 					game := transmute(^Game)state.previous
@@ -41,8 +57,9 @@ gameover_update :: proc(state: ^GameState, delta: f32) {
 					menu := menu_init(game)
 					stack_push(menu)
 					free(state)
-				tween_to(&Overlay_Opacity, 0, 0.5, ease.Ease.Cubic_Out)
+					ntween.animate(&f32_tweens, &Overlay_Opacity, 0, 0.5, ease.Ease.Cubic_Out)
-			})
+				},
+			)
 		}
 	}
 }
@@ -66,9 +83,23 @@ gameover_draw :: proc(state: ^GameState) {
 
 	// rl.DrawRectangleV(gameover.position - gameover.size / 2, gameover.size, rl.Color{90, 30, 150, 10})
 
-	draw_text_centered(Res.Fonts.Title, TitleText, gameover.position - {0, 100}, TitleFontSize, 1, rl.WHITE)
+	draw_text_centered(
+		Res.Fonts.Title,
+		TitleText,
+		gameover.position - {0, 100},
+		TitleFontSize,
+		1,
+		rl.WHITE,
+	)
 	for c, i in SubtitleText {
-		draw_text_centered(Res.Fonts.UI, c, gameover.position - {0, f32(10 - i * 50)}, SubtitleFontSize, 1, rl.WHITE)
+		draw_text_centered(
+			Res.Fonts.UI,
+			c,
+			gameover.position - {0, f32(10 - i * 50)},
+			SubtitleFontSize,
+			1,
+			rl.WHITE,
+		)
 		// rl.DrawTextPro(Res.Fonts.UI, c, winning.position - {0, f32(10 - i * 50)}, SubtitleSizes[i] / 2, 0, SubtitleFontSize, SubtitleSpacing, rl.WHITE)
 	}
 

main.odin

@@ -1,11 +1,15 @@
 package main
 
-import rl "vendor:raylib"
+import "core:fmt"
 import "core:path/filepath"
 import "core:strings"
+import "ntween"
+import rl "vendor:raylib"
 
 vec3 :: [3]f32
+vec3i :: [3]i32
 vec2 :: [2]f32
+vec2i :: [2]i32
 vec3right := vec3{1, 0, 0}
 vec3left := vec3{-1, 0, 0}
 vec3up := vec3{0, 1, 0}
@@ -17,13 +21,15 @@ vec3backward := vec3{0, 0, -1}
 WSize := [2]f32{}
 WSizei := [2]i32{}
 
+WSizeLast := vec2i{}
+
 WindowShouldExit := false
 
 NeedTutorial := true
 KeyboardOnly := false
 
 
-Overlay_Opacity : f32 = 0
+Overlay_Opacity: f32 = 0
 
 Resources :: struct {
 	Fonts:  struct {
@@ -54,18 +60,18 @@ Resources :: struct {
 	Music:  struct {
 		First:  rl.Music,
 		Second: rl.Music,
-    }
+	},
 }
 
-Res : Resources
+Res: Resources
 
-res_paths := map[typeid]string{
+res_paths := map[typeid]string {
 	rl.Music = "music",
 	rl.Sound = "sfx",
 	rl.Model = "models",
 }
 
-get_path :: proc(name: string, $T: typeid) -> cstring{
+get_path :: proc(name: string, $T: typeid) -> cstring {
 	p := filepath.join([]string{"./assets", res_paths[T], name})
 	cstr := strings.clone_to_cstring(p)
 	return cstr
@@ -91,7 +97,7 @@ load_music :: proc(name: string, volume: f32 = 1) -> rl.Music {
 	return snd
 }
 
-current_music : rl.Music
+current_music: rl.Music
 
 change_track :: proc(music: rl.Music) {
 	rl.StopMusicStream(current_music)
@@ -99,9 +105,9 @@ change_track :: proc(music: rl.Music) {
 	rl.PlayMusicStream(current_music)
 }
 
-Cursor : rl.Texture
+Cursor: rl.Texture
 load_resources :: proc() {
-    Res.Fonts.Title = rl.LoadFontEx("./assets/fonts/norse.otf", 96*2, nil, 2048)
+	Res.Fonts.Title = rl.LoadFontEx("./assets/fonts/norse.otf", 96 * 2, nil, 2048)
 	Res.Fonts.UI = rl.LoadFontEx("./assets/fonts/PTSerif-Regular.ttf", 96, nil, 2048)
 
 	Res.Models = {
@@ -131,14 +137,20 @@ load_resources :: proc() {
 	Res.Music.Second = load_music("alexander-nakarada-the-northern-path.mp3", 0.7)
 }
 
-Fullscreen := true
+f32_tweens: ntween.Tween_Map(f32)
+vec2_tweens: ntween.Tween_Map(vec2)
+vec3_tweens: ntween.Tween_Map(vec3)
 
 main :: proc() {
-    rl.SetConfigFlags(rl.ConfigFlags{.MSAA_4X_HINT, .FULLSCREEN_MODE, .VSYNC_HINT, .WINDOW_RESIZABLE})
+	f32_tweens = ntween.init(f32)
+	vec2_tweens = ntween.init(vec2)
+	vec3_tweens = ntween.init(vec3)
+	//    rl.SetConfigFlags(rl.ConfigFlags{.MSAA_4X_HINT, .FULLSCREEN_MODE, .VSYNC_HINT, .WINDOW_RESIZABLE})
+	rl.SetConfigFlags(rl.ConfigFlags{.VSYNC_HINT, .WINDOW_RESIZABLE})
 
-    rl.InitWindow(0, 0, "Ragnarøkkr")
+	rl.InitWindow(800, 600, "Ragnarøkkr")
 	rl.InitAudioDevice()
-    rl.SetWindowMinSize(800, 480)
+	rl.SetWindowMinSize(800, 600)
 
 	rl.HideCursor()
 	Cursor = rl.LoadTexture("./assets/gfx/crosshair.png")
@@ -163,7 +175,9 @@ main :: proc() {
 		state := stack_top()
 		delta := rl.GetFrameTime()
 		timers_process(delta)
-        tweens_process(delta)
+		ntween.process(&f32_tweens, delta)
+		ntween.process(&vec2_tweens, delta)
+		ntween.process(&vec3_tweens, delta)
 		state->update(delta)
 
 		rl.BeginDrawing()
@@ -176,3 +190,16 @@ main :: proc() {
 		rl.EndDrawing()
 	}
 }
+
+Fullscreen := false
+
+toggle_fullscreen :: proc() {
+	monitor := rl.GetCurrentMonitor()
+	rl.ToggleBorderlessWindowed()
+	WSizei = {rl.GetScreenWidth(), rl.GetScreenHeight()}
+	WSize = {f32(WSizei.x), f32(WSizei.y)}
+	Fullscreen = !Fullscreen
+
+
+	//	rl.ToggleFullscreen()
+}

menu.odin

@@ -75,8 +75,8 @@ menu_button_pressed :: proc(state: ^GameState, el: Menu_Buttons) {
 			KeyboardOnly = !KeyboardOnly
 			NeedTutorial = true
 		case .FULLSCREEN:
-			rl.ToggleFullscreen()
+			toggle_fullscreen()
-			Fullscreen = rl.IsWindowFullscreen()
+//			Fullscreen = rl.IsWindowFullscreen()
 
 		case .EXIT:
 			WindowShouldExit = true

menu_list.odin

@@ -1,8 +1,9 @@
 package main
 
-import rl "vendor:raylib"
-import "core:math/ease"
 import "core:fmt"
+import "core:math/ease"
+import "ntween"
+import rl "vendor:raylib"
 
 MenuItemType :: enum {
 	NONE,
@@ -12,10 +13,10 @@ MenuItemType :: enum {
 
 BoolStrings := map[bool]cstring {
 	true  = "вкл",
-	false = "выкл"
+	false = "выкл",
 }
 
-MenuItem :: struct{
+MenuItem :: struct {
 	text:  cstring,
 	param: rawptr,
 	type:  MenuItemType,
@@ -28,7 +29,7 @@ MenuList :: struct($T: typeid) {
 	font_size:      f32,
 	active_element: T,
 	active_marker:  vec2,
-	tween: ^Tween,
+	tween:          ^ntween.Tween(f32),
 	elements:       ^[T]MenuItem,
 	menu_pressed:   proc(state: ^GameState, element: T),
 	background:     rl.Color,
@@ -46,12 +47,10 @@ menu_list_update :: proc(list: ^MenuList($T)) {
 	list.mouse_pos = rl.GetMousePosition()
 
 	size := menu_list_get_size(list)
-	if rl.CheckCollisionPointRec(list.mouse_pos, rl.Rectangle{
+	if rl.CheckCollisionPointRec(
-		x = list.position.x,
+		list.mouse_pos,
-		y = list.position.y,
+		rl.Rectangle{x = list.position.x, y = list.position.y, width = size.x, height = size.y},
-		width = size.x,
+	) {
-		height = size.y,
-	}) {
 		if last_mouse_pos != list.mouse_pos {
 			mouse_relative := list.mouse_pos - list.position
 			cur_element = i8(mouse_relative.y / list.line_size)
@@ -63,7 +62,6 @@ menu_list_update :: proc(list: ^MenuList($T)) {
 	last_mouse_pos = list.mouse_pos
 
 
-
 	if rl.IsKeyPressed(rl.KeyboardKey.DOWN) {
 		cur_element += 1
 	}
@@ -71,13 +69,14 @@ menu_list_update :: proc(list: ^MenuList($T)) {
 		cur_element -= 1
 	}
 	if prev_element != cur_element {
-		if cur_element < 0 { cur_element = len(T) -1 }
+		if cur_element < 0 {cur_element = len(T) - 1}
-		if cur_element == len(T) { cur_element = 0 }
+		if cur_element == len(T) {cur_element = 0}
 		list.active_element = cast(T)cur_element
 		if list.tween != nil {
-			tween_cancel(list.tween)
+			ntween.cancel(list.tween)
 		}
-		list.tween = tween_to(
+		list.tween = ntween.animate(
+			&f32_tweens,
 			&list.active_marker.y,
 			f32(list.active_element) * list.line_size,
 			0.25,
@@ -94,7 +93,14 @@ menu_list_draw :: proc(list: ^MenuList($T)) {
 		size := menu_list_get_size(list)
 		rl.DrawRectangleV(list.position - {40, 40}, size + {80, 80}, list.background)
 	}
-	rl.DrawTextEx(Res.Fonts.UI, ">", list.position + list.active_marker + {-30, 0}, 48, 2, rl.WHITE)
+	rl.DrawTextEx(
+		Res.Fonts.UI,
+		">",
+		list.position + list.active_marker + {-30, 0},
+		48,
+		2,
+		rl.WHITE,
+	)
 	for el, i in list.elements {
 		pos := list.position + {0, f32(i) * list.line_size}
 		text := el.text

ntween

@@ -0,0 +1 @@
+Subproject commit 7136c68f3e63470b9b1c80109dd0904151e08070

pause.odin

@@ -1,43 +1,42 @@
 package main
 
-import rl "vendor:raylib"
 import "core:math/ease"
+import "ntween"
+import rl "vendor:raylib"
 
 
 Pause_Buttons :: enum {
 	CONTINUE,
-	EXIT
+	EXIT,
 }
 
 pause_strings := [Pause_Buttons]cstring {
 	.CONTINUE = "Продолжить",
-	.EXIT = "Прервать игру"
+	.EXIT     = "Прервать игру",
 }
 
 pause_items := [Pause_Buttons]MenuItem {
 	.CONTINUE = {text = pause_strings[.CONTINUE]},
-	.EXIT = {text = pause_strings[.EXIT]}
+	.EXIT = {text = pause_strings[.EXIT]},
 }
 
 Pause :: struct {
 	using state: GameState,
-
 	active:      bool,
 	list:        MenuList(Pause_Buttons),
-
 }
 
 pause_init :: proc(prev: ^GameState = nil) -> ^GameState {
 	state := new(Pause)
 	state.variant = state
-	state.list = MenuList(Pause_Buttons){
+	state.list = MenuList(Pause_Buttons) {
 		state        = state,
 		position     = {-300, WSize.y / 2},
 		line_size    = 60,
 		font_size    = 48,
 		elements     = &pause_items,
 		menu_pressed = pause_button_pressed,
-		background = rl.Color{50, 10, 110, 0}
+		background   = rl.Color{50, 10, 110, 0},
 	}
 	state.update = pause_update
 	state.draw = pause_draw
@@ -45,7 +44,7 @@ pause_init :: proc(prev: ^GameState = nil) -> ^GameState {
 	state.previous = prev
 	state.active = true
 
-	tween_to(&state.list.position.x, 100, 0.5, ease.Ease.Back_Out)
+	ntween.animate(&f32_tweens, &state.list.position.x, 100, 0.5, ease.Ease.Back_Out)
 
 	return state
 }
@@ -59,14 +58,21 @@ pause_update :: proc(state: ^GameState, delta: f32) {
 
 pause_button_pressed :: proc(state: ^GameState, el: Pause_Buttons) {
 	pause := transmute(^Pause)state
-	if !pause.active { return }
+	if !pause.active {return}
 	switch el {
 	case .CONTINUE:
 		stack_pop()
 	case .EXIT:
 		pause.active = false
 		rl.StopMusicStream(current_music)
-			tween_to(&Overlay_Opacity, 1.0, 0.5, ease.Ease.Cubic_Out, state, proc(data: rawptr) {
+		ntween.animate(
+			&f32_tweens,
+			&Overlay_Opacity,
+			1.0,
+			0.5,
+			ease.Ease.Cubic_Out,
+			state,
+			proc(data: rawptr) {
 				state := transmute(^GameState)data
 				stack_pop()
 				game := transmute(^Game)stack_top()
@@ -74,8 +80,9 @@ pause_button_pressed :: proc(state: ^GameState, el: Pause_Buttons) {
 				menu := menu_init(game)
 				stack_push(menu)
 				//free(state)
-				tween_to(&Overlay_Opacity, 0, 0.5, ease.Ease.Cubic_Out)
+				ntween.animate(&f32_tweens, &Overlay_Opacity, 0, 0.5, ease.Ease.Cubic_Out)
-			})
+			},
+		)
 	}
 }
 
@@ -88,7 +95,16 @@ pause_draw :: proc(state: ^GameState) {
 	TitleSpacing :: 3
 	TitleText :: "Ragnarøkkr"
 	TitleSize := rl.MeasureTextEx(Res.Fonts.Title, TitleText, TitleFontSize, TitleSpacing)
-	rl.DrawTextPro(Res.Fonts.Title, TitleText, {WSize.x - 50, 50}, {TitleSize.x, 0}, 0, 96, 3, rl.WHITE)
+	rl.DrawTextPro(
+		Res.Fonts.Title,
+		TitleText,
+		{WSize.x - 50, 50},
+		{TitleSize.x, 0},
+		0,
+		96,
+		3,
+		rl.WHITE,
+	)
 
 	menu_list_draw(&pause.list)
 

player.odin

@@ -1,14 +1,14 @@
 package main
 
+import "core:fmt"
+import "core:math"
+import "core:math/ease"
+import "core:math/rand"
+import "core:slice"
+import "core:strings"
+import "ntween"
 import rl "vendor:raylib"
 import "vendor:raylib/rlgl"
-import "core:math"
-import "core:strings"
-import "core:math/rand"
-import "core:math/ease"
-import "core:fmt"
-import "core:slice"
-
 
 
 // PlayerAnims : [^]rl.ModelAnimation
@@ -41,7 +41,7 @@ Player :: struct {
 player_spawn :: proc(position: vec3) -> Player {
 
 	// PlayerAnims = rl.LoadModelAnimations(PlayerModelPath, &PlayerAnimsCount)
-    return Player{
+	return Player {
 		pos = position,
 		radius = 1,
 		max_speed = 40,
@@ -63,12 +63,13 @@ player_update :: proc(player: ^Player, game: ^Game, delta: f32) {
 
 
 	mouse_ray := rl.GetMouseRay(rl.GetMousePosition(), game.camera)
-    mouse_pos : vec3
+	mouse_pos: vec3
-    hit := rl.GetRayCollisionQuad(mouse_ray,
+	hit := rl.GetRayCollisionQuad(
+		mouse_ray,
 		{-1000, -1000, 0},
 		{-1000, 1000, 0},
 		{1000, 1000, 0},
-        {1000, -1000, 0}
+		{1000, -1000, 0},
 	)
 	if hit.hit {
 		mouse_pos = hit.point
@@ -81,10 +82,10 @@ player_update :: proc(player: ^Player, game: ^Game, delta: f32) {
 		pos += vel * delta
 		if pos.y < radius {
 			pos.y = radius
-            vel.y = - vel.y
+			vel.y = -vel.y
 		}
 		if !is_dodging {
-            dir_vector : vec3
+			dir_vector: vec3
 			if intro_timer <= 0 {
 				thrust_key := rl.KeyboardKey.W
 				if !KeyboardOnly {
@@ -144,7 +145,13 @@ player_update :: proc(player: ^Player, game: ^Game, delta: f32) {
 			can_dodge = false
 			rl.StopSound(Res.Sfx.Rocket)
 			rl.PlaySound(Res.Sfx.PlayerSwoosh)
-            tween_to(&player.rolling, math.PI*2, 0.42, ease.Ease.Quadratic_Out)
+			ntween.animate(
+				&f32_tweens,
+				&player.rolling,
+				math.PI * 2,
+				0.42,
+				ease.Ease.Quadratic_Out,
+			)
 			timer_start(0.45, player, proc(data: rawptr) {
 				player := transmute(^Player)data
 				player.is_dodging = false
@@ -167,7 +174,10 @@ player_update :: proc(player: ^Player, game: ^Game, delta: f32) {
 			}
 			if can_shoot {
 				roll := -math.PI / 2 + math.cos(dir) * math.PI / 2
-                b := bullet_spawn(pos + get_vec_from_angle(dir) * 3 + get_vec_from_angle(dir+math.PI/2)*.3, dir)
+				b := bullet_spawn(
+					pos + get_vec_from_angle(dir) * 3 + get_vec_from_angle(dir + math.PI / 2) * .3,
+					dir,
+				)
 				append(&game.bullets, b)
 				can_shoot = false
 				timer_start(0.07, player, proc(data: rawptr) {
@@ -203,9 +213,9 @@ player_update :: proc(player: ^Player, game: ^Game, delta: f32) {
 			got_hit = true
 			break hit
 		}
-        ray := rl.Ray{
+		ray := rl.Ray {
 			position  = Head.pos,
-            direction = get_vec_from_angle(Head.dir)
+			direction = get_vec_from_angle(Head.dir),
 		}
 		if Head.is_shooting && rl.GetRayCollisionSphere(ray, pos, radius + 3).hit {
 			got_hit = true
@@ -248,7 +258,7 @@ player_update :: proc(player: ^Player, game: ^Game, delta: f32) {
 
 player_draw :: proc(player: ^Player) {
 	using player
-    if player.is_dead { return }
+	if player.is_dead {return}
 	dir_vector := get_vec_from_angle(dir)
 	color := rl.WHITE
 	if is_invulnerable {

tween.odin

@@ -1,80 +0,0 @@
-package main
-
-import "core:math"
-import "core:math/ease"
-import "core:math/linalg"
-import "core:slice"
-
-
-Tween :: struct {
-	ptr: ^f32,
-	from: f32,
-	to: f32,
-	time: f32,
-	duration: f32,
-	ease_type: ease.Ease,
-	active: bool,
-	finished: proc(data: rawptr),
-	data: rawptr
-}
-
-
-tweens : [dynamic]^Tween
-
-
-tween_clean :: proc() {
-	for tween, i in tweens {
-		free(tween)
-	}
-}
-
-tween_to :: proc(
-		value: ^f32, to: f32, duration: f32,
-		ease: ease.Ease = ease.Ease.Quartic_In_Out,
-		data: rawptr = nil,
-		callback: proc(data: rawptr) = nil
-		) -> ^Tween {
-
-	tween := new(Tween) 
-	tween.ptr = value
-	tween.from = value^
-	tween.to = to
-	tween.duration = duration
-	tween.ease_type = ease
-	tween.active = true
-	tween.data = data
-	tween.finished = callback
-
-	append(&tweens, tween)
-	return tween
-}
-
-tween_cancel :: proc(t: ^Tween) {
-	t.active = false
-}
-
-tweens_process :: proc(delta: f32) {
-	#reverse for tween, i in tweens {
-
-		tween.time += delta
-		p := clamp(tween.time / tween.duration, 0, 1)
-
-		val := ease.ease(tween.ease_type, p)
-		if tween.ptr != nil {
-			tween.ptr^ = math.lerp(tween.from, tween.to, val)
-		} else {
-			tween.active = false
-		}
-
-		if tween.time >= tween.duration {
-			tween.active = false
-			if tween.finished != nil {
-				tween.finished(tween.data)
-			}
-		}
-		if !tween.active {
-			free(tween)
-			unordered_remove(&tweens, i)
-		}
-	}
-}

winning.odin

@@ -1,8 +1,9 @@
 package main
 
-import rl "vendor:raylib"
-import "core:math/ease"
 import "core:fmt"
+import "core:math/ease"
+import "ntween"
+import rl "vendor:raylib"
 
 
 Winning :: struct {
@@ -22,7 +23,15 @@ winning_init :: proc(prev: ^GameState = nil) -> ^GameState {
 	state.free = winning_free
 
 	state.previous = prev
-	tween_to(&state.position.y, WSize.y / 2, 1, ease.Ease.Back_Out, state, winning_ready)
+	ntween.animate(
+		&vec2_tweens,
+		&state.position,
+		WSize / 2,
+		1,
+		ease.Ease.Back_Out,
+		state,
+		winning_ready,
+	)
 
 	return state
 }
@@ -33,7 +42,14 @@ winning_update :: proc(state: ^GameState, delta: f32) {
 		if rl.IsKeyPressed(rl.KeyboardKey.ESCAPE) {
 			winning.ready_to_go = false
 			rl.StopMusicStream(current_music)
-			tween_to(&Overlay_Opacity, 1.0, 0.5, ease.Ease.Cubic_Out, nil, proc(data: rawptr) {
+			ntween.animate(
+				&f32_tweens,
+				&Overlay_Opacity,
+				1.0,
+				0.5,
+				ease.Ease.Cubic_Out,
+				nil,
+				proc(data: rawptr) {
 					state := transmute(^GameState)data
 					stack_pop()
 					game := transmute(^Game)state.previous
@@ -41,8 +57,9 @@ winning_update :: proc(state: ^GameState, delta: f32) {
 					menu := menu_init(game)
 					stack_push(menu)
 					free(state)
-				tween_to(&Overlay_Opacity, 0, 0.5, ease.Ease.Cubic_Out)
+					ntween.animate(&f32_tweens, &Overlay_Opacity, 0, 0.5, ease.Ease.Cubic_Out)
-			})
+				},
+			)
 		}
 	}
 }
@@ -59,15 +76,33 @@ winning_draw :: proc(state: ^GameState) {
 	TitleSpacing :: 3
 	TitleText :: "GAME OVER"
 
-	SubtitleText := [?]cstring{"Тор смог спасти Асгард", "от Рагнарёка!", "Нажмите Escape чтобы выйти"}
+	SubtitleText := [?]cstring {
+		"Тор смог спасти Асгард",
+		"от Рагнарёка!",
+		"Нажмите Escape чтобы выйти",
+	}
 	SubtitleFontSize :: 48
 
 
 	rl.DrawRectangleV(winning.position - winning.size / 2, winning.size, rl.Color{90, 30, 150, 10})
 
-	draw_text_centered(Res.Fonts.Title, TitleText, winning.position - {0, 100}, TitleFontSize, 1, rl.WHITE)
+	draw_text_centered(
+		Res.Fonts.Title,
+		TitleText,
+		winning.position - {0, 100},
+		TitleFontSize,
+		1,
+		rl.WHITE,
+	)
 	for c, i in SubtitleText {
-		draw_text_centered(Res.Fonts.UI, c, winning.position - {0, f32(10 - i * 50)}, SubtitleFontSize, 1, rl.WHITE)
+		draw_text_centered(
+			Res.Fonts.UI,
+			c,
+			winning.position - {0, f32(10 - i * 50)},
+			SubtitleFontSize,
+			1,
+			rl.WHITE,
+		)
 		// rl.DrawTextPro(Res.Fonts.UI, c, winning.position - {0, f32(10 - i * 50)}, SubtitleSizes[i] / 2, 0, SubtitleFontSize, SubtitleSpacing, rl.WHITE)
 	}