nefrace
/
Ragnarokkr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Moved tweens to NTween

This commit is contained in:
Nefrace 2024-11-04 17:28:34 +03:00
parent 8a9e20f370
commit b251553275
9 changed files with 554 additions and 525 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Ragnarokkr
View File

Binary file not shown.

47
gameover.odin
View File

@ -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)
}

36
main.odin
View File

@ -1,9 +1,10 @@
package main
import rl "vendor:raylib"
import "core:fmt"
import "core:path/filepath"
import "core:strings"
import "core:fmt"
import "ntween"
import rl "vendor:raylib"
vec3 :: [3]f32
vec3i :: [3]i32
@ -28,7 +29,7 @@ NeedTutorial := true
KeyboardOnly := false
Overlay_Opacity : f32 = 0
Overlay_Opacity: f32 = 0
Resources :: struct {
Fonts: struct {
@ -59,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
@ -96,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)
@ -104,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 = {
@ -136,8 +137,15 @@ load_resources :: proc() {
Res.Music.Second = load_music("alexander-nakarada-the-northern-path.mp3", 0.7)
}
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(800, 600, "Ragnarøkkr")
@ -167,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()
@ -191,5 +201,5 @@ toggle_fullscreen :: proc() {
Fullscreen = !Fullscreen
// rl.ToggleFullscreen()
// rl.ToggleFullscreen()
}

40
menu_list.odin
View File

@ -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{
x = list.position.x,
y = list.position.y,
width = size.x,
height = size.y,
}) {
if rl.CheckCollisionPointRec(
list.mouse_pos,
rl.Rectangle{x = list.position.x, y = list.position.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 == len(T) { cur_element = 0 }
if cur_element < 0 {cur_element = len(T) - 1}
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

1
ntween Submodule

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

44
pause.odin
View File

@ -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)

46
player.odin
View File

@ -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
hit := rl.GetRayCollisionQuad(mouse_ray,
mouse_pos: vec3
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 {

80
tween.odin
View File

@ -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)
}
}
}

53
winning.odin
View File

@ -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)
}