chrisbell/odin-raylib-game
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Fixed a lot of bad math causing issues in negative chunks

Browse Source
This commit is contained in:
Chris Bell
2025-03-02 13:33:43 -06:00
parent cc339b9389
commit bd2130dfa0
5 changed files with 110 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
game/player.odin
View File

@@ -2,6 +2,7 @@ package game
import rl "vendor:raylib"
import "core:fmt"
import "core:math"
CHUNK_UNLOAD_DISTANCE :: 3
@@ -31,57 +32,42 @@ player_update :: proc(p : ^Player, w: ^World) {
handle_player_input(p,w)
handle_player_camera(p)
if rl.IsKeyPressed(.SPACE) {
// set_tile(w, bricks_tile, vec2_to_vec2i(get_player_grid_position(p)))
find_desert(w.seed)
generate_biome_map(w.seed, 100, 100)
}
// if rl.IsKeyPressed(.SPACE) {
// // set_tile(w, bricks_tile, vec2_to_vec2i(get_player_grid_position(p)))
// find_desert(w.seed)
// generate_biome_map(w.seed, 100, 100)
// }
}
@(private="file")
player_update_chunks :: proc(p: ^Player, w: ^World) {
// Configurable view distance (in chunks)
VIEW_DISTANCE :: 2
player_grid_pos := get_player_grid_position(p)
current_player_chunk := get_chunk_from_world_pos(w, player_grid_pos)
directions := [8]Vec2i{
Vec2i{ 1, 0 }, Vec2i{ -1, 0 }, // Right, Left
Vec2i{ 0, 1 }, Vec2i{ 0, -1 }, // Down, Up
Vec2i{ 1, 1 }, Vec2i{ -1, -1 }, // Bottom-right, Top-left
Vec2i{ 1, -1 }, Vec2i{ -1, 1 }, // Top-right, Bottom-left
}
// Always ensure the current chunk is loaded
get_chunk(w, current_player_chunk.position)
// Load adjacent chunks
for dir in directions {
adjacent_pos := Vec2i{
current_player_chunk.position.x + dir.x,
current_player_chunk.position.y + dir.y
// Track which chunks should be loaded
chunks_to_keep := make(map[Vec2i]bool)
defer delete(chunks_to_keep)
// Load chunks in a square around the player's current chunk
for y := -VIEW_DISTANCE; y <= VIEW_DISTANCE; y += 1 {
for x := -VIEW_DISTANCE; x <= VIEW_DISTANCE; x += 1 {
chunk_pos := Vec2i{
current_player_chunk.position.x + x,
current_player_chunk.position.y + y,
}
// Load the chunk and mark it to keep
get_chunk(w, chunk_pos)
chunks_to_keep[chunk_pos] = true
}
get_chunk(w, adjacent_pos)
}
// Unload non-adjacent chunks
// Unload chunks outside the view distance
for chunk_pos in w.chunks {
if chunk_pos == current_player_chunk.position {
continue
}
is_adjacent := false
for dir in directions {
check_pos := Vec2i{
current_player_chunk.position.x + dir.x,
current_player_chunk.position.y + dir.y
}
if chunk_pos == check_pos {
is_adjacent = true
break
}
}
if !is_adjacent {
if !chunks_to_keep[chunk_pos] {
unload_chunk(chunk_pos, w)
}
}
@@ -91,7 +77,7 @@ player_update_chunks :: proc(p: ^Player, w: ^World) {
handle_player_input :: proc(p:^Player, w:^World) {
// Movement
target_pos := get_player_grid_position(p)
dt := rl.GetFrameTime()
move_delay : f32 = 0.2
if p.move_timer > 0 {
@@ -99,9 +85,10 @@ handle_player_input :: proc(p:^Player, w:^World) {
}
if p.move_timer <= 0 {
current_pos := get_player_grid_position(p)
if rl.IsKeyDown(.D) {
target_pos.x += 1
if !will_collide(w, target_pos) {
target_pos := rl.Vector2{current_pos.x + 1, current_pos.y}
if !will_collide(.RIGHT, p, w) {
player.position.x += CELL_SIZE
p.move_timer = move_delay
player_update_chunks(p,w)
@@ -109,8 +96,8 @@ handle_player_input :: proc(p:^Player, w:^World) {
}
if rl.IsKeyDown(.A) {
target_pos.x -= 1
if !will_collide(w, target_pos) {
target_pos := rl.Vector2{current_pos.x - 1, current_pos.y}
if !will_collide(.LEFT, p, w) {
player.position.x -= CELL_SIZE
p.move_timer = move_delay
player_update_chunks(p,w)
@@ -118,8 +105,8 @@ handle_player_input :: proc(p:^Player, w:^World) {
}
if rl.IsKeyDown(.W) {
target_pos.y -= 1
if !will_collide(w, target_pos) {
target_pos := rl.Vector2{current_pos.x, current_pos.y - 1}
if !will_collide(.UP, p, w) {
player.position.y -= CELL_SIZE
p.move_timer = move_delay
player_update_chunks(p,w)
@@ -127,8 +114,8 @@ handle_player_input :: proc(p:^Player, w:^World) {
}
if rl.IsKeyDown(.S) {
target_pos.y += 1
if !will_collide(w, target_pos) {
target_pos := rl.Vector2{current_pos.x, current_pos.y + 1}
if !will_collide(.DOWN, p, w) {
p.move_timer = move_delay
player.position.y += CELL_SIZE
player_update_chunks(p,w)
@@ -194,29 +181,50 @@ get_tile_in_direction :: proc(direction:InteractDirection, p:^Player, w:^World)
}
get_player_grid_position :: proc(player:^Player) -> rl.Vector2 {
grid_pos_x := player.position.x / CELL_SIZE
grid_pos_y := player.position.y / CELL_SIZE
grid_pos_x := math.floor(player.position.x / CELL_SIZE)
grid_pos_y := math.floor(player.position.y / CELL_SIZE)
return {grid_pos_x, grid_pos_y}
}
draw_player :: proc(player:^Player) {
draw_tile({25,0}, player.position, {30,100,120,255})
// Debug: Draw player's grid cell
// player_grid_pos := get_player_grid_position(player)
// world_pos_x := player_grid_pos.x * CELL_SIZE
// world_pos_y := player_grid_pos.y * CELL_SIZE
// rl.DrawRectangleLines(
// i32(world_pos_x),
// i32(world_pos_y),
// i32(CELL_SIZE),
// i32(CELL_SIZE),
// rl.RED
// )
}
will_collide :: proc(direction:InteractDirection, p:^Player, w:^World) -> bool {
tile, pos := get_tile_in_direction(direction, p, w)
will_collide :: proc(w:^World, pos:rl.Vector2) -> bool {
world_grid_pos := vec2_to_vec2i(pos)
chunk_pos := world_pos_to_chunk_pos(pos)
local_pos := get_local_chunk_pos(world_grid_pos)
chunk := get_chunk(w, chunk_pos)
tile := get_chunk_tile(chunk, local_pos)
#partial switch tile.type {
case .SOLID:
return true
}
if tile.type == .SOLID { return true }
return false
}
// will_collide :: proc(w:^World, pos:rl.Vector2) -> bool {
// world_grid_pos := vec2_to_vec2i(pos)
// chunk_pos := world_pos_to_chunk_pos(pos)
// local_pos := get_local_chunk_pos(world_grid_pos)
// chunk := get_chunk(w, chunk_pos)
// tile := get_chunk_tile(chunk, local_pos)
// #partial switch tile.type {
// case .SOLID:
// return true
// }
// return false
// }