From ada87e6adfee1e16fff23ec0b31877ff5f508a35 Mon Sep 17 00:00:00 2001 From: Krzosa Karol Date: Fri, 21 Apr 2023 08:28:44 +0200 Subject: [PATCH] Core: Brought back named loads which are a bit counter intuitive --- build/rtsgame/main.core | 46 +++++++-------- build/rtsgame/map.core | 124 ++++++++++++++++++++-------------------- core_parsing.cpp | 7 ++- core_typechecking.cpp | 14 ++--- 4 files changed, 94 insertions(+), 97 deletions(-) diff --git a/build/rtsgame/main.core b/build/rtsgame/main.core index 61d9b90..c016f83 100644 --- a/build/rtsgame/main.core +++ b/build/rtsgame/main.core @@ -19,10 +19,6 @@ thing := 1 :goto_block: for -@language_todo: Bring back named loads -A :: #load "array.core" - - @reproduction: This kills the compiler due to referencing slice data @@ -68,7 +64,7 @@ Add(&guys, {100, 100}) // Error! Couldn't infer type of compound expression // if Mode == 0 && colliding && IsMouseButtonPressed(MOUSE_BUTTON_RIGHT) ;; GuyP = {x,y} // Error! Couldn't infer type of compound expression -// if Mode == 1 && colliding && IsMouseButtonPressed(MOUSE_BUTTON_LEFT) ;; MAP_CurrentMap.actors.data[0].p = {x,y} +// if Mode == 1 && colliding && IsMouseButtonPressed(MOUSE_BUTTON_LEFT) ;; MAP.CurrentMAP.actors.data[0].p = {x,y} // @compiler_todo: It's possible to have 2 definitions with same name. 1 global, 1 local // Mode := 0 @@ -77,7 +73,7 @@ Add(&guys, {100, 100}) #import "raylib.core" #load "array.core" -#load "map.core" +MAP :: #load "map.core" sqrtf :: #foreign (value: F32): F32 @@ -104,10 +100,10 @@ ANI_SetTiles: Array(ANI_SetTile) MouseSelecting := false MouseSelectionPivot: Vector2 MouseSelectionBox: Rectangle -MouseSelectedActors: Array(*MAP_Actor) // @todo: ids +MouseSelectedActors: Array(*MAP.Actor) // @todo: ids main :: (): int - MAP_Init() + MAP.Init() // InitAudioDevice() // sound := LoadSound("catune - Pass the town, and to the C.mp3") @@ -140,7 +136,7 @@ main :: (): int MouseY = GetMouseY() MouseP = GetMousePosition() Dt = GetFrameTime() - map := &MAP_CurrentMap + map := &MAP.CurrentMap MouseSelecting = false if IsMouseButtonDown(MOUSE_BUTTON_LEFT) @@ -170,11 +166,11 @@ main :: (): int if IsKeyPressed(KEY_F3) for i := 0, i < map.actors.len, i += 1 it := map.actors.data + i - MAP_MoveTowardsTarget(it) - MAP_PathFindUpdate(map) + MAP.MoveTowardsTarget(it) + MAP.PathFindUpdate(map) if IsKeyPressed(KEY_F4) - MAP_RandomizeActors() + MAP.RandomizeActors() BeginDrawing() @@ -227,8 +223,8 @@ main :: (): int if tile_it.t > 1 map_tile := map.data + (tile_it.p.x + tile_it.p.y*map.x) - if tile_it.set ;; *map_tile |= MAP_TILE_BLOCKER - else ;; *map_tile &= ~MAP_TILE_BLOCKER + if tile_it.set ;; *map_tile |= MAP.TILE_BLOCKER + else ;; *map_tile &= ~MAP.TILE_BLOCKER remove = true tile_it.t += Dt*8 @@ -238,36 +234,36 @@ main :: (): int for i := 0, i < map.actors.len, i += 1 actor_it := map.actors.data + i - target_r := MAP_Rectangle(actor_it.target_p) + target_r := MAP.Rect(actor_it.target_p) - main_p := MAP_Circle(actor_it.p) + main_p := MAP.Circle(actor_it.p) DrawCircleV(main_p, RectX/2, actor_color) DrawRectangleRec(target_r, target_color) smaller_the_further: F32 = 0 for tile_i := actor_it.tiles_visited.len - 1, tile_i >= 0, tile_i -= 1 tile_it := actor_it.tiles_visited.data + tile_i - p := MAP_Circle({tile_it.x, tile_it.y}) + p := MAP.Circle({tile_it.x, tile_it.y}) DrawCircleV(p, RectX/2 - smaller_the_further, past_actor_color) smaller_the_further += 0.5 for path_i := 0, path_i < actor_it.open_paths.len, path_i += 1 path_it := actor_it.open_paths.data + path_i - path_r := MAP_Rectangle(path_it.p) + path_r := MAP.Rect(path_it.p) DrawRectangleRec(path_r, orange) s := TextFormat("%d", sqrtf(path_it.value_to_sort_by->F32)->int) DrawText(s, path_r.x->int, path_r.y->int, 1, RAYWHITE) for path_i := 0, path_i < actor_it.close_paths.len, path_i += 1 path_it := actor_it.close_paths.data + path_i - path_r := MAP_Rectangle(path_it.p) + path_r := MAP.Rect(path_it.p) DrawRectangleRec(path_r, brown) for path_i := 0, path_i < actor_it.history.len, path_i += 1 path_it := actor_it.history.data + path_i - p0 := MAP_Circle(path_it.came_from) - p1 := MAP_Circle(path_it.p) + p0 := MAP.Circle(path_it.came_from) + p1 := MAP.Circle(path_it.p) DrawLineEx(p0, p1, 5, LIGHTGRAY) DrawCircleV(p0, 4, LIGHTGRAY) @@ -276,12 +272,12 @@ main :: (): int if Mode == 1 for actor_i := 0, actor_i < MouseSelectedActors.len, actor_i += 1 actor_it := MouseSelectedActors.data[actor_i] - actor_box := MAP_Rectangle(actor_it.p) + actor_box := MAP.Rect(actor_it.p) DrawRectangleRec(actor_box, GREEN) if IsMouseButtonPressed(MOUSE_BUTTON_RIGHT) - p := MAP_ScreenToMap(MouseP) - MAP_SetTargetP(actor_it, p) + p := MAP.ScreenToMap(MouseP) + MAP.SetTargetP(actor_it, p) if MouseSelecting Reset(&MouseSelectedActors) @@ -290,7 +286,7 @@ main :: (): int for actor_i := 0, actor_i < map.actors.len, actor_i += 1 actor_it := map.actors.data + actor_i - actor_box := MAP_Rectangle(actor_it.p) + actor_box := MAP.Rect(actor_it.p) if CheckCollisionRecs(actor_box, MouseSelectionBox) Add(&MouseSelectedActors, actor_it) diff --git a/build/rtsgame/map.core b/build/rtsgame/map.core index ce62e52..66bc7f6 100644 --- a/build/rtsgame/map.core +++ b/build/rtsgame/map.core @@ -1,65 +1,65 @@ -MAP_CurrentMap: MAP_Map +CurrentMap: Map -MAP_PATH_SEARCHING :: 0 -MAP_PATH_REACHED :: 1 -MAP_PATH_UNREACHABLE :: 2 +PATH_SEARCHING :: 0 +PATH_REACHED :: 1 +PATH_UNREACHABLE :: 2 -MAP_TILE_BLOCKER :: 1 -MAP_TILE_ACTOR_IS_STANDING :: 2 +TILE_BLOCKER :: 1 +TILE_ACTOR_IS_STANDING :: 2 -MAP_Tile :: int -MAP_Map :: struct - data: *MAP_Tile +Tile :: int +Map :: struct + data: *Tile x: int y: int - actors: Array(MAP_Actor) + actors: Array(Actor) -MAP_Actor :: struct +Actor :: struct p: V2I target_p: V2I - map: *MAP_Map + map: *Map - open_paths: Array(MAP_Path) - close_paths: Array(MAP_Path) + open_paths: Array(Path) + close_paths: Array(Path) tiles_visited: Array(V2I) - history: Array(MAP_Path) + history: Array(Path) -MAP_Path :: struct +Path :: struct value_to_sort_by: int // distance from target p: V2I came_from: V2I -MAP_Rectangle :: (p: V2I): Rectangle +Rect :: (p: V2I): Rectangle result := Rectangle{p.x->F32 * RectX, p.y->F32 * RectY, RectX, RectY} return result -MAP_Circle :: (p: V2I): Vector2 +Circle :: (p: V2I): Vector2 result := Vector2{p.x->F32 * RectX + RectX/2, p.y->F32 * RectY + RectY/2} return result -MAP_ScreenToMap :: (p: Vector2): V2I +ScreenToMap :: (p: Vector2): V2I p0 := p.x / RectX p1 := p.y / RectY result := V2I{p0->int, p1->int} return result -MAP_AddActor :: (map: *MAP_Map, p: V2I): *MAP_Actor +AddActor :: (map: *Map, p: V2I): *Actor Add(&map.actors, {p, p, map}) Assert(map.data[p.x + p.y * map.x] == 0) - map.data[p.x + p.y * map.x] |= MAP_TILE_ACTOR_IS_STANDING - actor := GetLast(&MAP_CurrentMap.actors) + map.data[p.x + p.y * map.x] |= TILE_ACTOR_IS_STANDING + actor := GetLast(&CurrentMap.actors) return actor -MAP_ActorSetP :: (actor: *MAP_Actor, p: V2I) +ActorSetP :: (actor: *Actor, p: V2I) map := actor.map new_tile := map.data + p.x + p.y * map.x if *new_tile != 0 ;; return tile := map.data + actor.p.x + actor.p.y * map.x - Assert((*tile & MAP_TILE_ACTOR_IS_STANDING) != 0) - *tile &= ~MAP_TILE_ACTOR_IS_STANDING + Assert((*tile & TILE_ACTOR_IS_STANDING) != 0) + *tile &= ~TILE_ACTOR_IS_STANDING - *new_tile |= MAP_TILE_ACTOR_IS_STANDING + *new_tile |= TILE_ACTOR_IS_STANDING actor.p = p Reset(&actor.tiles_visited) @@ -67,48 +67,48 @@ MAP_ActorSetP :: (actor: *MAP_Actor, p: V2I) Reset(&actor.open_paths) Reset(&actor.close_paths) -MAP_SetTargetP :: (s: *MAP_Actor, p: V2I) +SetTargetP :: (s: *Actor, p: V2I) s.target_p = p Reset(&s.tiles_visited) Reset(&s.history) Reset(&s.open_paths) Reset(&s.close_paths) -MAP_GetRandomP :: (m: *MAP_Map): V2I - result := V2I{GetRandomValue(0, MAP_CurrentMap.x - 1), GetRandomValue(0, MAP_CurrentMap.y - 1)} +GetRandomP :: (m: *Map): V2I + result := V2I{GetRandomValue(0, CurrentMap.x - 1), GetRandomValue(0, CurrentMap.y - 1)} return result -MAP_GetRandomUnblockedP :: (m: *MAP_Map): V2I +GetRandomUnblockedP :: (m: *Map): V2I for i := 0, i < 128, i += 1 - p := MAP_GetRandomP(m) + p := GetRandomP(m) if m.data[p.x + p.y * m.x] == 0 return p Assert(false, "Invalid codepath") r: V2I; return r -MAP_Init :: () - MAP_CurrentMap.x = WinX / RectX - MAP_CurrentMap.y = WinY / RectY - bytes := sizeof(MAP_Tile) * MAP_CurrentMap.x->U64 * MAP_CurrentMap.y->U64 - MAP_CurrentMap.data = malloc(bytes) - memset(MAP_CurrentMap.data, 0, bytes) +Init :: () + CurrentMap.x = WinX / RectX + CurrentMap.y = WinY / RectY + bytes := sizeof(Tile) * CurrentMap.x->U64 * CurrentMap.y->U64 + CurrentMap.data = malloc(bytes) + memset(CurrentMap.data, 0, bytes) - actor := MAP_AddActor(&MAP_CurrentMap, MAP_GetRandomUnblockedP(&MAP_CurrentMap)) - actor.target_p = MAP_GetRandomUnblockedP(&MAP_CurrentMap) + actor := AddActor(&CurrentMap, GetRandomUnblockedP(&CurrentMap)) + actor.target_p = GetRandomUnblockedP(&CurrentMap) - actor2 := MAP_AddActor(&MAP_CurrentMap, MAP_GetRandomUnblockedP(&MAP_CurrentMap)) - actor2.target_p = MAP_GetRandomUnblockedP(&MAP_CurrentMap) + actor2 := AddActor(&CurrentMap, GetRandomUnblockedP(&CurrentMap)) + actor2.target_p = GetRandomUnblockedP(&CurrentMap) -MAP_RandomizeActors :: () - map := &MAP_CurrentMap +RandomizeActors :: () + map := &CurrentMap for i := 0, i < map.actors.len, i += 1 it := map.actors.data + i - p := MAP_GetRandomUnblockedP(&MAP_CurrentMap) - MAP_ActorSetP(it, p) - it.target_p = MAP_GetRandomUnblockedP(&MAP_CurrentMap) + p := GetRandomUnblockedP(&CurrentMap) + ActorSetP(it, p) + it.target_p = GetRandomUnblockedP(&CurrentMap) -MAP_InsertOpenPath :: (s: *MAP_Actor, p: V2I, came_from: V2I, ignore_blocks: bool = false) +InsertOpenPath :: (s: *Actor, p: V2I, came_from: V2I, ignore_blocks: bool = false) if p.x < 0 || p.x >= s.map.x ;; return if p.y < 0 || p.y >= s.map.y ;; return if ignore_blocks == false && s.map.data[p.x + p.y * s.map.x] != 0 ;; return @@ -126,7 +126,7 @@ MAP_InsertOpenPath :: (s: *MAP_Actor, p: V2I, came_from: V2I, ignore_blocks: boo d := dx*dx + dy*dy InsertSortedDecreasing(&s.open_paths, {d, p, came_from}) -MAP_GetCloseP :: (s: *MAP_Actor, p: V2I): *MAP_Path +GetCloseP :: (s: *Actor, p: V2I): *Path for i := 0, i < s.close_paths.len, i += 1 it := s.close_paths.data + i if it.p.x == p.x && it.p.y == p.y ;; return it @@ -134,7 +134,7 @@ MAP_GetCloseP :: (s: *MAP_Actor, p: V2I): *MAP_Path Assert(false, "Invalid codepath") return 0 -MAP_RecomputeHistory :: (s: *MAP_Actor) +RecomputeHistory :: (s: *Actor) if s.close_paths.len > 1 Reset(&s.history) it := GetLast(&s.close_paths) @@ -144,11 +144,11 @@ MAP_RecomputeHistory :: (s: *MAP_Actor) if i > 512 Reset(&s.history) break - it = MAP_GetCloseP(s, it.came_from) + it = GetCloseP(s, it.came_from) Add(&s.history, *it) Pop(&s.history) -MAP_MoveTowardsTarget :: (s: *MAP_Actor) +MoveTowardsTarget :: (s: *Actor) tile := s.map.data + s.p.x + s.p.y * s.map.x if s.history.len > 0 step := Pop(&s.history) @@ -156,10 +156,10 @@ MAP_MoveTowardsTarget :: (s: *MAP_Actor) if *new_tile == 0 Add(&s.tiles_visited, s.p) s.p = step.p - *tile &= ~MAP_TILE_ACTOR_IS_STANDING - *new_tile |= MAP_TILE_ACTOR_IS_STANDING + *tile &= ~TILE_ACTOR_IS_STANDING + *new_tile |= TILE_ACTOR_IS_STANDING -MAP_PathFindUpdate :: (map: *MAP_Map) +PathFindUpdate :: (map: *Map) for actor_i := 0, actor_i < map.actors.len, actor_i += 1 s := map.actors.data + actor_i for i := 0, i < s.history.len, i += 1 @@ -172,9 +172,9 @@ MAP_PathFindUpdate :: (map: *MAP_Map) Reset(&s.history) break - MAP_PathFind(s) + PathFind(s) -MAP_PathFindStep :: (s: *MAP_Actor, compute_history: bool = true): bool +PathFindStep :: (s: *Actor, compute_history: bool = true): bool if s.open_paths.len == 0 // Reset if we didnt find solution if s.close_paths.len != 0 @@ -185,7 +185,7 @@ MAP_PathFindStep :: (s: *MAP_Actor, compute_history: bool = true): bool Reset(&s.close_paths) Reset(&s.history) - MAP_InsertOpenPath(s, s.p, s.p, ignore_blocks = true) + InsertOpenPath(s, s.p, s.p, ignore_blocks = true) if s.close_paths.len != 0 last := GetLast(&s.close_paths) @@ -201,13 +201,13 @@ MAP_PathFindStep :: (s: *MAP_Actor, compute_history: bool = true): bool for x := -1, x <= 1, x += 1 if x == 0 && y == 0 ;; continue p := V2I{it.p.x + x, it.p.y + y} - MAP_InsertOpenPath(s, p, it.p) + InsertOpenPath(s, p, it.p) - if compute_history ;; MAP_RecomputeHistory(s) + if compute_history ;; RecomputeHistory(s) return false -MAP_PathFind :: (s: *MAP_Actor) +PathFind :: (s: *Actor) for i := 0, i < 32, i += 1 - done := MAP_PathFindStep(s, false) + done := PathFindStep(s, false) if done ;; break - MAP_RecomputeHistory(s) + RecomputeHistory(s) diff --git a/core_parsing.cpp b/core_parsing.cpp index d65f003..91bdf82 100644 --- a/core_parsing.cpp +++ b/core_parsing.cpp @@ -920,7 +920,12 @@ parse_decl(B32 is_global) { result = parse_enum(tname); } - else if (token_match_pound(pctx->intern("import"_s))) { + else if (token_match_pound(pctx->intern_load)) { + Ast_File *file = parse_load(false); + result = ast_namespace(tname, file, tname->intern_val); + } + + else if (token_match_pound(pctx->intern_import)) { Ast_Module *module = parse_import(false); result = ast_namespace(tname, module, tname->intern_val); } diff --git a/core_typechecking.cpp b/core_typechecking.cpp index b055807..ae39f0d 100644 --- a/core_typechecking.cpp +++ b/core_typechecking.cpp @@ -1155,23 +1155,19 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str Ast_Scope *scope = field_access_scope ? field_access_scope : node->parent_scope; Search_Flag flag = field_access_scope ? SEARCH_ONLY_CURRENT_SCOPE : 0; - if (!string_compare(ast->pos->file.s, "Language.core"_s)) { // @debug - int a = 10; - } - // @consider: Maybe instead of using AST_IDENT another case should be // added like AST_RESOLVED or something because currently the identifier // is a bit bogus. + // if (node->intern_val == pctx->intern("MAP"_s)) { + // __debugbreak(); + // } + // When copying polymorphs we fill out resolved_decl in // identifiers, so it can happen that we have already resolved the name Ast_Decl *decl = node->resolved_decl; if (!decl) decl = resolve_name(scope, node->pos, node->intern_val, flag | RESOLVE_NAME_MAKE_SURE_OPERATOR_OVERLOAD_IS_NOT_EVER_CALLED); - // if (decl->type_val && decl->type_val->kind == TYPE_POLYMORPH) { - // compiler_error(ast->pos, "Trying to use a polymorphic in an invalid way"); - // } - // Substitute lambda alias if (decl->kind == AST_CONST && decl->resolved_decl && decl->resolved_decl->kind == AST_LAMBDA) { decl = decl->resolved_decl; @@ -1181,7 +1177,7 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str node->resolved_type = node->resolved_decl->type; Operand result = operand(node->resolved_decl); - if (result.is_const) { + if (result.is_const && decl->kind != AST_NAMESPACE) { rewrite_into_const(node, Ast_Atom, node->resolved_decl->value); node->resolved_decl = decl; }