328 lines
9.6 KiB
Odin
328 lines
9.6 KiB
Odin
package main
|
||
|
||
import rl "vendor:raylib"
|
||
import "vendor:raylib/rlgl"
|
||
import "core:math"
|
||
import "core:fmt"
|
||
import "core:math/linalg"
|
||
import "core:math/rand"
|
||
|
||
|
||
Snake_Health := 1000
|
||
|
||
Segments: [dynamic]^SnakeSegment
|
||
|
||
Head: SnakeHead
|
||
|
||
SnakeState :: enum {
|
||
Chasing,
|
||
Chase_to_Dive,
|
||
Dive_to_Chase,
|
||
Diving,
|
||
Hunt,
|
||
Shot
|
||
}
|
||
|
||
SnakeHead :: struct {
|
||
pos: vec3,
|
||
vel: vec3,
|
||
dir: f32,
|
||
radius: f32,
|
||
health: int,
|
||
max_health: int,
|
||
next: ^SnakeSegment,
|
||
state: SnakeState,
|
||
next_state: SnakeState,
|
||
state_timer: f32,
|
||
shot_timer: f32,
|
||
is_shooting: bool,
|
||
is_dead: bool,
|
||
}
|
||
|
||
SnakeSegment :: struct {
|
||
pos: vec3,
|
||
vel: vec3,
|
||
dir: f32,
|
||
radius: f32,
|
||
collider_radius: f32,
|
||
active: bool,
|
||
health: u8,
|
||
head: ^SnakeHead,
|
||
next: ^SnakeSegment,
|
||
prev: ^SnakeSegment
|
||
}
|
||
|
||
|
||
snake_spawn :: proc(pos: vec3, dir: f32, length: int){
|
||
dir_vec := rl.Vector3RotateByAxisAngle(vec3right, vec3backward, dir)
|
||
|
||
Head = SnakeHead{
|
||
pos = pos,
|
||
dir = dir,
|
||
radius = 3,
|
||
state = .Chasing,
|
||
vel = dir_vec * 20,
|
||
health = 100,
|
||
max_health = 100,
|
||
state_timer = 30,
|
||
}
|
||
|
||
for i := 0; i < length; i += 1 {
|
||
segment := new(SnakeSegment)
|
||
segment.active = false
|
||
segment.health = 3
|
||
segment.radius = 2.5
|
||
segment.collider_radius = 2.5
|
||
segment.pos = pos - dir_vec * segment.radius
|
||
segment.dir = dir
|
||
segment.head = &Head
|
||
if i != 0 {
|
||
segment.prev = Segments[i-1]
|
||
Segments[i-1].next = segment
|
||
} else {
|
||
Head.next = segment
|
||
}
|
||
append(&Segments, segment)
|
||
}
|
||
}
|
||
|
||
snake_clear :: proc() {
|
||
for segment in Segments {
|
||
free(segment)
|
||
}
|
||
}
|
||
|
||
snake_process :: proc(game: ^Game, delta: f32) {
|
||
// Head.state = .Shot
|
||
// Head.state_timer = 200
|
||
switch Head.state {
|
||
case .Chasing:
|
||
snake_chase_smooth(game, delta)
|
||
case .Diving:
|
||
snake_dive(game, delta)
|
||
case .Chase_to_Dive,.Dive_to_Chase:
|
||
snake_dropdown(game, delta)
|
||
case .Hunt:
|
||
snake_hunt(game, delta)
|
||
case .Shot:
|
||
snake_shot(game, delta)
|
||
}
|
||
total_health := 0
|
||
for segment in Segments {
|
||
total_health += int(segment.health)
|
||
}
|
||
game.snake_health = total_health
|
||
if game.snake_health == 0 {
|
||
if Head.next != nil {
|
||
Head.next = nil
|
||
Head.state = .Hunt
|
||
Head.state_timer = 20
|
||
change_track(Res.Music.Second)
|
||
return
|
||
}
|
||
trail(Head.pos - get_vec_from_angle(Head.dir) * Head.radius * 0.7, 3, rand.float32_range(0.7, 1.8), rl.RED)
|
||
if Head.health <= 0 && !Head.is_dead {
|
||
Head.is_dead = true
|
||
explode(Head.pos, 9, 0.9, rl.YELLOW)
|
||
rl.PlaySound(Res.Sfx.PlayerDead)
|
||
timer_start(3, game, proc(data: rawptr) {
|
||
state := transmute(^Game)data
|
||
win := winning_init(state)
|
||
stack_push(win)
|
||
})
|
||
}
|
||
}
|
||
for segment, i in Segments {
|
||
if segment.prev == nil && total_health == 0 { // Хвост падает, когда у него не осталось жизней
|
||
segment.vel.y -= 30 * delta
|
||
segment.pos += segment.vel * delta
|
||
continue
|
||
}
|
||
|
||
target_pos := Head.pos
|
||
if segment.prev != nil {
|
||
target_pos = segment.prev.pos
|
||
} else {
|
||
segment.vel = Head.vel
|
||
}
|
||
diff := target_pos - segment.pos
|
||
if rl.Vector3Length(diff) > segment.radius {
|
||
segment.pos = target_pos - rl.Vector3Normalize(diff) * segment.radius
|
||
}
|
||
segment.dir = math.atan2(-diff.y, diff.x)
|
||
}
|
||
}
|
||
|
||
|
||
snake_chase :: proc(game: ^Game, delta: f32) {
|
||
using game
|
||
diff := player.pos - Head.pos
|
||
target_angle := math.atan2(-diff.y, diff.x)
|
||
dir_diff := angle_cycle(target_angle - Head.dir, -math.PI, math.PI)
|
||
Head.dir = angle_rotate(Head.dir, target_angle, min(abs(dir_diff), math.PI) * delta)
|
||
Head.vel = rl.Vector3RotateByAxisAngle(vec3right, vec3backward, Head.dir) * 500
|
||
Head.pos += Head.vel * delta
|
||
}
|
||
|
||
snake_chase_smooth :: proc(game: ^Game, delta: f32) {
|
||
using game
|
||
|
||
if rl.IsKeyPressed(rl.KeyboardKey.K) {
|
||
for segment in Segments {
|
||
segment.health = 0
|
||
}
|
||
}
|
||
|
||
Head.state_timer -= delta
|
||
if Head.state_timer <= 0 {
|
||
Head.state = .Chase_to_Dive
|
||
rl.PlaySound(Res.Sfx.SnakeGrowl)
|
||
Head.next_state = .Diving
|
||
Head.state_timer = 10
|
||
}
|
||
|
||
if Head.pos.y < -3 && Head.vel.y < 0 {
|
||
Head.pos.y = -3
|
||
Head.vel.y = -Head.vel.y
|
||
}
|
||
|
||
diff := player.pos - Head.pos
|
||
norm := rl.Vector3Normalize(diff)
|
||
Head.vel = rl.Vector3MoveTowards(Head.vel, norm * 70, 70 * delta)
|
||
Head.vel = rl.Vector3ClampValue(Head.vel, 30, 50)
|
||
Head.dir = math.atan2(-Head.vel.y, Head.vel.x)
|
||
Head.pos += Head.vel * delta
|
||
}
|
||
|
||
snake_dive :: proc(game: ^Game, delta: f32) {
|
||
Head.state_timer -= delta
|
||
if Head.state_timer <= 0 {
|
||
Head.state = .Chasing
|
||
Head.state_timer = 20
|
||
rl.PlaySound(Res.Sfx.SnakeGrowl)
|
||
}
|
||
if Head.pos.y < 0 && Segments[len(Segments)-1].pos.y < 0 && Head.vel.y < 0 {
|
||
rl.PlaySound(Res.Sfx.SnakeEarthHit)
|
||
Head.pos.x = game.player.pos.x
|
||
Head.pos.y = -5
|
||
Head.vel.x = 0
|
||
Head.vel.y = 70
|
||
} else {
|
||
grav : f32 = 20
|
||
if Head.vel.y < 0 { grav = 30 }
|
||
else if Head.pos.y < game.player.pos.y {
|
||
grav = 7
|
||
}
|
||
Head.vel.y -= grav * delta
|
||
Head.vel.x = (game.player.pos.x - Head.pos.x) * 2
|
||
}
|
||
Head.dir = math.atan2(-Head.vel.y, Head.vel.x)
|
||
Head.pos += Head.vel * delta
|
||
}
|
||
|
||
snake_dropdown :: proc(game: ^Game, delta: f32) {
|
||
Head.vel.y -= 100 * delta
|
||
Head.pos += Head.vel * delta
|
||
Head.dir = math.atan2(-Head.vel.y, Head.vel.x)
|
||
if Segments[len(Segments)-1].pos.y < 0 {
|
||
Head.state = Head.next_state
|
||
Head.state_timer = 20
|
||
}
|
||
}
|
||
|
||
snake_hunt :: proc(game: ^Game, delta: f32) {
|
||
Head.state_timer -= delta
|
||
if Head.state_timer <= 0 {
|
||
Head.state_timer = 10
|
||
Head.state = .Shot
|
||
rl.PlaySound(Res.Sfx.SnakeRoarBlast)
|
||
}
|
||
diff := game.player.pos - Head.pos
|
||
target_pos := game.player.pos + rl.Vector3Normalize(diff) * 10
|
||
target_diff := target_pos - Head.pos
|
||
|
||
Head.vel = rl.Vector3MoveTowards(Head.vel, rl.Vector3Normalize(target_diff) * 50, 40 * delta)
|
||
Head.dir = math.atan2(-Head.vel.y, Head.vel.x)
|
||
Head.pos += Head.vel * delta
|
||
if Head.pos.y < Head.radius {
|
||
Head.pos.y = Head.radius
|
||
Head.vel.y = -Head.vel.y / 2
|
||
}
|
||
}
|
||
|
||
snake_shot :: proc(game: ^Game, delta: f32) {
|
||
Head.state_timer -= delta
|
||
if Head.state_timer <= 0 {
|
||
Head.state_timer = 20
|
||
Head.state = .Hunt
|
||
}
|
||
Head.is_shooting = false
|
||
if Head.state_timer < 8 && Head.state_timer > 3 {
|
||
Head.is_shooting = true
|
||
if !rl.IsSoundPlaying(Res.Sfx.SnakeBeam) {
|
||
rl.PlaySound(Res.Sfx.SnakeBeam)
|
||
}
|
||
}
|
||
|
||
diff := game.player.pos - Head.pos
|
||
target_angle := math.atan2(-diff.y, diff.x)
|
||
dir_diff := angle_cycle(target_angle - Head.dir, -math.PI, math.PI)
|
||
Head.dir = angle_rotate(Head.dir, target_angle, abs(dir_diff) * delta * 1.5)
|
||
Head.vel = rl.Vector3MoveTowards(Head.vel, {}, 30 * delta)
|
||
Head.pos += Head.vel * delta
|
||
}
|
||
|
||
|
||
snake_draw :: proc(game: ^Game) {
|
||
|
||
dir_vector := get_vec_from_angle(Head.dir)
|
||
roll := -math.PI / 2 + math.cos(Head.dir) * math.PI / 2
|
||
rlgl.PushMatrix()
|
||
rlgl.Translatef(Head.pos.x, Head.pos.y, Head.pos.z)
|
||
rlgl.Rotatef(math.to_degrees(Head.dir), 0, 0, -1)
|
||
rlgl.Rotatef(math.to_degrees(roll), 1, 0, 0)
|
||
// rl.DrawCircle3D({}, Head.radius, vec3up, 0, rl.RED)
|
||
// rl.DrawLine3D({}, {-4, 0, 0}, rl.GREEN)
|
||
rl.DrawModel(Res.Models.SnakeHeadTop, {}, 5, rl.WHITE)
|
||
rlgl.PushMatrix()
|
||
if Head.state == .Shot {
|
||
step1 := math.smoothstep(f32(10), f32(8), f32(Head.state_timer))
|
||
step2 := math.smoothstep(f32(0), f32(3), f32(Head.state_timer))
|
||
angle := step1 * step2 * math.PI / 2.5
|
||
fmt.println(Head.state_timer, step1, step2, angle)
|
||
rlgl.Rotatef(math.to_degrees(angle), 0, 0, -1)
|
||
}
|
||
rl.DrawModel(Res.Models.SnakeHeadJaw, {}, 5, rl.WHITE)
|
||
rlgl.PopMatrix()
|
||
rlgl.Translatef(0.5, -1, 0)
|
||
if Head.is_shooting {
|
||
rl.DrawCylinderEx({}, vec3right * 300, 1.4, 1.4, 6, rl.YELLOW)
|
||
}
|
||
rlgl.PopMatrix()
|
||
// rl.DrawCircle3D(Head.pos, Head.radius, vec3up, 0, rl.RED)
|
||
// rl.DrawLine3D(Head.pos, Head.pos + dir_vector * Head.radius, rl.BLACK)
|
||
|
||
|
||
// if game.snake_health == 0 {
|
||
// center := Head.pos + dir_vector * Head.radius * 1.5
|
||
// left := Head.pos + rl.Vector3RotateByAxisAngle(dir_vector, vec3backward, math.PI/3) * Head.radius * 1.5
|
||
// right := Head.pos + rl.Vector3RotateByAxisAngle(dir_vector, vec3backward, -math.PI/3) * Head.radius * 1.5
|
||
// rl.DrawLine3D(left, center, rl.YELLOW)
|
||
// rl.DrawLine3D(right, center, rl.YELLOW)
|
||
// }
|
||
|
||
for segment in Segments {
|
||
dir_vector := get_vec_from_angle(segment.dir)
|
||
col := rl.WHITE
|
||
if segment.health == 0 {
|
||
col = rl.Color{255, 150, 150, 255}
|
||
}
|
||
roll := -math.PI / 2 + math.cos(segment.dir) * math.PI / 2
|
||
rlgl.PushMatrix()
|
||
rlgl.Translatef(segment.pos.x, segment.pos.y, segment.pos.z)
|
||
rlgl.Rotatef(math.to_degrees(segment.dir), 0, 0, -1)
|
||
rlgl.Rotatef(math.to_degrees(roll), 1, 0, 0)
|
||
rl.DrawModel(Res.Models.SnakeBody, {}, 4, col)
|
||
rlgl.PopMatrix()
|
||
}
|
||
} |