fort: correct draw ground tiles if blocked

Author: s.kushnirenko

src/building/building_fort.cpp

@@ -6,23 +6,23 @@
 #include "city/finance.h"
 #include "building/properties.h"
 #include "graphics/view/view.h"
+#include "graphics/view/lookup.h"
 #include "grid/grid.h"
 
 #include "graphics/animation.h"
 #include "js/js_game.h"
 #include "city/labor.h"
 
-constexpr int MAX_TILES = 25;
-
 namespace model {
 
 struct fort_t {
     static constexpr e_building_type type = BUILDING_COURTHOUSE;
     e_labor_category labor_category;
     animations_t anim;
     struct {
-        vec2i main_view_offset[4];
-        vec2i ground_view_offset[4];
+        std::vector<vec2i> main_view_offset;
+        std::vector<vec2i> ground_view_offset;
+        std::vector<vec2i> ground_check_offset;
     } ghost;
 };
 
@@ -37,26 +37,21 @@ void config_load_building_fort() {
         model::fort.anim.load(arch);
 
         arch.r_section("ghost", [] (archive ghost_arch) {
-            model::fort.ghost.main_view_offset[0] = ghost_arch.r_vec2i("main_N");
-            model::fort.ghost.main_view_offset[1] = ghost_arch.r_vec2i("main_W");
-            model::fort.ghost.main_view_offset[2] = ghost_arch.r_vec2i("main_S");
-            model::fort.ghost.main_view_offset[3] = ghost_arch.r_vec2i("main_E");
-            model::fort.ghost.ground_view_offset[0] = ghost_arch.r_vec2i("ground_N");
-            model::fort.ghost.ground_view_offset[1] = ghost_arch.r_vec2i("ground_W");
-            model::fort.ghost.ground_view_offset[2] = ghost_arch.r_vec2i("ground_S");
-            model::fort.ghost.ground_view_offset[3] = ghost_arch.r_vec2i("ground_E");
+            model::fort.ghost.main_view_offset = ghost_arch.r_array_vec2i("main");
+            model::fort.ghost.ground_view_offset = ghost_arch.r_array_vec2i("ground");
+            model::fort.ghost.ground_check_offset = ghost_arch.r_array_vec2i("ground_check");
         });
     });
 
     city_labor_set_category(model::fort);
 }
 
-static const int FORT_GROUND_GRID_OFFSETS_PH[4][4] = {
-    {GRID_OFFSET(3, -1), GRID_OFFSET(4, -1), GRID_OFFSET(4, 0), GRID_OFFSET(3, 0)},
-    {GRID_OFFSET(-1, -4), GRID_OFFSET(0, -4), GRID_OFFSET(0, -3), GRID_OFFSET(-1, -3)},
-    {GRID_OFFSET(-4, 0), GRID_OFFSET(-3, 0), GRID_OFFSET(-3, 1), GRID_OFFSET(-4, 1)},
-    {GRID_OFFSET(0, 3), GRID_OFFSET(1, 3), GRID_OFFSET(1, 4), GRID_OFFSET(0, 4)}
-};
+void draw_partially_blocked(painter &ctx, int fully_blocked, const std::vector<blocked_tile> &blocked_tiles) {
+    for (auto &tile: blocked_tiles) {
+        vec2i pixel = tile_to_pixel(tile.tile);
+        draw_flat_tile(ctx, pixel.x, pixel.y, (fully_blocked || tile.blocked) ? COLOR_MASK_RED : COLOR_MASK_GREEN);
+    }
+}
 
 void draw_fort_ghost(painter &ctx, e_building_type build_type, tile2i &tile, vec2i pixel) {
     bool fully_blocked = false;
@@ -66,38 +61,37 @@ void draw_fort_ghost(painter &ctx, e_building_type build_type, tile2i &tile, vec
         blocked = true;
     }
 
-    int num_tiles_fort = building_properties_for_type(BUILDING_FORT_ARCHERS)->size;
-    num_tiles_fort *= num_tiles_fort;
-    int num_tiles_ground = building_properties_for_type(BUILDING_FORT_GROUND)->size;
-    num_tiles_ground *= num_tiles_ground;
+    int fort_size = building_properties_for_type(BUILDING_FORT_ARCHERS)->size;
+    int ground_size = building_properties_for_type(BUILDING_FORT_GROUND)->size;
 
     //    int grid_offset_fort = tile->grid_offset;
     int global_rotation = building_rotation_global_rotation();
-    int grid_offset_ground = tile.grid_offset() + FORT_GROUND_GRID_OFFSETS_PH[global_rotation][city_view_orientation() / 2];
+    vec2i tile_ground_offset = model::fort.ghost.ground_check_offset[global_rotation * 4 + (city_view_orientation() / 2)];
+    tile2i tile_ground = tile.shifted(tile_ground_offset.x, tile_ground_offset.y);
 
-    int blocked_tiles_fort[MAX_TILES];
-    int blocked_tiles_ground[MAX_TILES];
+    std::vector<blocked_tile> blocked_tiles_fort;
+    std::vector<blocked_tile> blocked_tiles_ground;
 
-    blocked += is_blocked_for_building(tile.grid_offset(), num_tiles_fort, blocked_tiles_fort);
-    blocked += is_blocked_for_building(grid_offset_ground, num_tiles_ground, blocked_tiles_ground);
+    blocked += is_blocked_for_building(tile, fort_size, blocked_tiles_fort);
+    blocked += is_blocked_for_building(tile_ground, ground_size, blocked_tiles_ground);
 
     int orientation_index = building_rotation_get_storage_fort_orientation(global_rotation) / 2;
-    vec2i main = pixel + model::fort.ghost.main_view_offset[orientation_index];
-    vec2i ground = pixel + model::fort.ghost.ground_view_offset[orientation_index];
+    vec2i main_pixel = pixel + model::fort.ghost.main_view_offset[orientation_index];
+    vec2i ground_pixel = pixel + model::fort.ghost.ground_view_offset[orientation_index];
 
     if (blocked) {
-        draw_partially_blocked(ctx, pixel, fully_blocked, num_tiles_fort, blocked_tiles_fort);
-        draw_partially_blocked(ctx, ground, fully_blocked, num_tiles_ground, blocked_tiles_ground);
+        draw_partially_blocked(ctx, fully_blocked, blocked_tiles_fort);
+        draw_partially_blocked(ctx, fully_blocked, blocked_tiles_ground);
     } else {
         int image_id = image_id_from_group(GROUP_BUILDING_FORT);
         if (orientation_index == 0 || orientation_index == 3) {
             // draw fort first, then ground
-            draw_building_ghost(ctx, image_id, main);
-            draw_building_ghost(ctx, image_id + 1, ground);
+            draw_building_ghost(ctx, image_id, main_pixel);
+            draw_building_ghost(ctx, image_id + 1, ground_pixel);
         } else {
             // draw ground first, then fort
-            draw_building_ghost(ctx, image_id + 1, ground);
-            draw_building_ghost(ctx, image_id, main);
+            draw_building_ghost(ctx, image_id + 1, ground_pixel);
+            draw_building_ghost(ctx, image_id, main_pixel);
         }
     }
 }

src/core/archive.cpp

@@ -94,6 +94,24 @@ std::vector<std::string> archive::r_array_str(pcstr name) {
     return result;
 }
 
+std::vector<vec2i> archive::r_array_vec2i(pcstr name) {
+    auto vm = (js_State *)state;
+    js_getproperty(vm, -1, name);
+    std::vector<vec2i> result;
+    if (js_isarray(vm, -1)) {
+        int length = js_getlength(vm, -1);
+
+        for (int i = 0; i < length; ++i) {
+            js_getindex(vm, -1, i);
+            vec2i v = r_vec2i_impl("x", "y");
+            result.push_back(v);
+            js_pop(vm, 1);
+        }
+        js_pop(vm, 1);
+    }
+    return result;
+}
+
 int archive::r_int(pcstr name, int def) {
     auto vm = (js_State *)state;
     js_getproperty(vm, -1, name);
@@ -126,10 +144,9 @@ vec2i archive::r_size2i(pcstr name, pcstr w, pcstr h) {
     return r_vec2i(name, w, h);
 }
 
-vec2i archive::r_vec2i(pcstr name, pcstr x, pcstr y) {
+vec2i archive::r_vec2i_impl(pcstr x, pcstr y) {
     auto vm = (js_State *)state;
     vec2i result(0, 0);
-    js_getproperty(vm, -1, name);
     if (js_isobject(vm, -1)) {
         if (js_isarray(vm, -1)) {
             int length = js_getlength(vm, -1);
@@ -144,6 +161,14 @@ vec2i archive::r_vec2i(pcstr name, pcstr x, pcstr y) {
             js_getproperty(vm, -1, y); result.y = !js_isundefined(vm, -1) ? js_tointeger(vm, -1) : 0; js_pop(vm, 1);
         }
     }
+
+    return result;
+}
+
+vec2i archive::r_vec2i(pcstr name, pcstr x, pcstr y) {
+    auto vm = (js_State *)state;
+    js_getproperty(vm, -1, name);
+    vec2i result = r_vec2i_impl(x, y);
     js_pop(vm, 1);
 
     return result;

src/core/archive.h

@@ -22,6 +22,8 @@ struct archive {
     vec2i r_size2i(pcstr name, pcstr w = "w", pcstr h = "h");
     vec2i r_vec2i(pcstr name, pcstr x = "x", pcstr y = "y");
 
+    std::vector<vec2i> r_array_vec2i(pcstr name);
+
     template<class T>
     inline T r_type(pcstr name) { return (T)r_int(name); }
 
@@ -59,6 +61,8 @@ struct archive {
         pop(1);
     }
 
+    vec2i r_vec2i_impl(pcstr x, pcstr y);
+
     template<typename T>
     inline void r_objects(pcstr name, T read_func) {
         this->r_section(name, [this, &read_func] (archive s_arch) {

src/scripts/building_info.js

@@ -55,14 +55,12 @@ building_big_statue = {
 
 building_fort = {
   ghost : {
-    main_N : [-55, -35],
-    main_W : [-55, -35],
-    main_S : [-55, -35],
-    main_E : [-60, -40],
-    ground_N : [35, 35],
-    ground_W : [5, -70],
-    ground_S : [-200, -55],
-    ground_E : [-180, 46],
+    main : [[-55, -35], [-55, -35], [-55, -35], [-60, -40]],
+    ground : [[35, 35], [5, -70], [-200, -55], [-180, 46]],
+    ground_check : [[3, -1], [4, -1], [4, 0], [3, 0],
+                    [-1,-4], [0, -4], [0,-3], [-1,-3],
+                    [-4, 0], [-3, 0], [-3,1], [-4, 1],
+                    [0,  3], [1,  3], [1, 4], [0,  4]],
   },
   labor_category : LABOR_CATEGORY_MILITARY,
 }

src/widget/city/building_ghost.cpp

@@ -27,7 +27,7 @@
 
 #define MAX_TILES 25
 
-const vec2i VIEW_OFFSETS[MAX_TILES] = {          {0, 0},
+const vec2i VIEW_OFFSETS[]          = {          {0, 0},
                                        {-30,15}, {30, 15}, {0,30},
                              {-60,30}, {60, 30}, {-30,45}, {30, 45}, {0,  60},
                   {-90, 45}, {90, 45}, {-60,60}, {60, 60}, {-30,75}, {30, 75},  {0, 90},
@@ -134,42 +134,28 @@ static void get_building_base_xy(int map_x, int map_y, int building_size, int* x
     }
 }
 
-int is_blocked_for_building(int grid_offset, int num_tiles, int* blocked_tiles) {
+int is_blocked_for_building(tile2i tile, int size, std::vector<blocked_tile> &blocked_tiles) {
     int orientation_index = city_view_orientation() / 2;
     int blocked = 0;
+    int num_tiles = pow(size, 2);
     for (int i = 0; i < num_tiles; i++) {
-        int tile_offset = grid_offset; // + TILE_GRID_OFFSETS[orientation_index][i];
-        tile_offset += TILE_GRID_OFFSETS_PH[orientation_index][i];
-        bool tile_blocked = false;
-        if (map_terrain_is(tile_offset, TERRAIN_NOT_CLEAR))
-            tile_blocked = true;
-        if (map_terrain_count_directly_adjacent_with_type(grid_offset, TERRAIN_FLOODPLAIN) > 0
-            || map_terrain_count_diagonally_adjacent_with_type(grid_offset, TERRAIN_FLOODPLAIN) > 0)
-            tile_blocked = true;
-
-        if (map_has_figure_at(tile_offset))
-            tile_blocked = true;
-
-        blocked_tiles[i] = tile_blocked;
+        int offset = TILE_GRID_OFFSETS_PH[orientation_index][i];
+        tile2i check_tile = tile.shifted(offset);
+        bool tile_blocked = map_terrain_is(check_tile, TERRAIN_NOT_CLEAR)
+                            || (map_terrain_count_directly_adjacent_with_type(check_tile.grid_offset(), TERRAIN_FLOODPLAIN) > 0)
+                            || (map_terrain_count_diagonally_adjacent_with_type(check_tile.grid_offset(), TERRAIN_FLOODPLAIN) > 0)
+                            || map_has_figure_at(check_tile);
+
+        blocked_tiles.push_back({check_tile, tile_blocked});
         blocked += (tile_blocked ? 1 : 0);
     }
     return blocked;
 }
 
-static void draw_flat_tile(painter &ctx, int x, int y, color color_mask) {
+void draw_flat_tile(painter &ctx, int x, int y, color color_mask) {
     ImageDraw::img_generic(ctx, image_id_from_group(GROUP_TERRAIN_OVERLAY_COLORED), x, y, color_mask);
 }
 
-void draw_partially_blocked(painter &ctx, vec2i tile, int fully_blocked, int num_tiles, int* blocked_tiles) {
-    for (int i = 0; i < num_tiles; i++) {
-        vec2i offset = tile + VIEW_OFFSETS[i];
-        if (fully_blocked || blocked_tiles[i])
-            draw_flat_tile(ctx, offset.x, offset.y, COLOR_MASK_RED);
-        else
-            draw_flat_tile(ctx, offset.x, offset.y, COLOR_MASK_GREEN);
-    }
-}
-
 void draw_building_ghost(painter &ctx, e_image_id image_id, vec2i tile, color color_mask) {
     int img = image_group(image_id);
     ImageDraw::isometric(ctx, img, tile, color_mask);

src/widget/city/building_ghost.h

@@ -5,10 +5,19 @@
 #include "grid/point.h"
 #include "core/vec2i.h"
 
+#include <vector>
+
 struct painter;
 
+struct blocked_tile {
+    tile2i tile;
+    bool blocked;
+};
+
 void draw_building_ghost(painter &ctx, e_image_id image_id, vec2i tile, color color_mask = COLOR_MASK_GREEN);
 void draw_building_ghost(painter &ctx, int image_id, vec2i tile, color color_mask = COLOR_MASK_GREEN);
-int is_blocked_for_building(int grid_offset, int num_tiles, int *blocked_tiles);
-void draw_partially_blocked(painter &ctx, vec2i tile, int fully_blocked, int num_tiles, int *blocked_tiles);
+int is_blocked_for_building(tile2i tile, int size, std::vector<blocked_tile> &blocked_tiles);
+void draw_flat_tile(painter &ctx, int x, int y, color color_mask);
 bool city_building_ghost_mark_deleting(tile2i tile);
+
+extern const vec2i VIEW_OFFSETS[];

src/widget/map_editor_tool.cpp

@@ -22,7 +22,7 @@ static void offset_to_view_offset(int dx, int dy, int* view_dx, int* view_dy) {
     *view_dy = (dx + dy) * 15;
 }
 
-static void draw_flat_tile(vec2i pos, color color_mask) {
+static void draw_flat_tile_editor(vec2i pos, color color_mask) {
     painter ctx = game.painter();
     if (color_mask == COLOR_MASK_GREEN && scenario_property_climate() != CLIMATE_DESERT)
         ImageDraw::img_generic(ctx, image_id_from_group(GROUP_TERRAIN_OVERLAY_COLORED), pos, ALPHA_MASK_SEMI_TRANSPARENT & color_mask);
@@ -36,9 +36,9 @@ static void draw_partially_blocked_editor(int x, int y, int num_tiles, int* bloc
         int x_offset = x + X_VIEW_OFFSETS[i];
         int y_offset = y + Y_VIEW_OFFSETS[i];
         if (blocked_tiles[i])
-            draw_flat_tile(vec2i{x_offset, y_offset}, COLOR_MASK_RED);
+            draw_flat_tile_editor(vec2i{x_offset, y_offset}, COLOR_MASK_RED);
         else {
-            draw_flat_tile(vec2i{x_offset, y_offset}, COLOR_MASK_GREEN);
+            draw_flat_tile_editor(vec2i{x_offset, y_offset}, COLOR_MASK_GREEN);
         }
     }
 }
@@ -92,7 +92,7 @@ static void draw_road(painter &ctx, tile2i tile, int x, int y) {
         }
     }
     if (blocked)
-        draw_flat_tile(vec2i{x, y}, COLOR_MASK_RED);
+        draw_flat_tile_editor(vec2i{x, y}, COLOR_MASK_RED);
     else {
         draw_building_image(image_id, x, y);
     }
@@ -102,7 +102,7 @@ static void draw_brush_tile(const void* data, int dx, int dy) {
     screen_tile* view = (screen_tile*)data;
     int view_dx, view_dy;
     offset_to_view_offset(dx, dy, &view_dx, &view_dy);
-    draw_flat_tile(vec2i{view->x + view_dx, view->y + view_dy}, COLOR_MASK_GREEN);
+    draw_flat_tile_editor(vec2i{view->x + view_dx, view->y + view_dy}, COLOR_MASK_GREEN);
 }
 
 static void draw_brush(painter &ctx, tile2i tile, int x, int y) {
@@ -122,7 +122,7 @@ static void draw_access_ramp(tile2i tile, int x, int y) {
 }
 
 static void draw_map_flag(int x, int y, int is_ok) {
-    draw_flat_tile(vec2i{x, y}, is_ok ? COLOR_MASK_GREEN : COLOR_MASK_RED);
+    draw_flat_tile_editor(vec2i{x, y}, is_ok ? COLOR_MASK_GREEN : COLOR_MASK_RED);
 }
 
 void map_editor_tool_draw(painter &ctx, tile2i tile) {