On Friday, 22 March 2024 at 02:19:07 UTC, Liam McGillivray wrote:
In the [game I am currently
making](https://github.com/LiamM32/Open_Emblem/blob/master/oe-raylib/source/app.d), I have a `Map` class (actually a combination of an interface & class template, but I'll call it a "class" for simplicity), in which there will probably be only one instance running at a time. In that map class is a 2-dimensional dynamic array of `Tile` objects called `grid`. What these `Tile` objects represent are like squares on a chessboard. Their placement in `grid` represents their location on the map.
```d
enum tile{wall,field....}
bool ispassable(tile t)=>...
alias grid_=tile[maxhieght][maxwidth];
grid_ grid;
```
your not simplifying anything here with all them oo terms
Is one option more efficient than the other?
You should probaly do the lazyest thing, factor out your
"ispassable" logic, like what your walking n of 3, n of 8, n of
15? so long as you dont do something insane it will be fast on a
modern computer; allocating several dynamic array that are the
size of your game world every frame could easily be not very sane.
and if you really really wanted to care, you could precompute the
"connected compoints" by flood filling across passable tiles with
a "color" of 0, then finding an empty cell, flood filling with 1,
etc.; and when you draw the overlay for where you can move you
can do a heuristic check for a) they are in the same component,
and b) the manhattan distances before c) doing a greedy check
Is there a memory allocation technique that would make each
tile's location in grid inferrable based on it's memory address?
Yes its called an array
theres some details you need to know and you need to cast
pointers; just try some trial and error with code like:
```d
int[10] foo;
&foo.print;
&foo[1].print;
(&foo[7]-&foo[0]).print;
```
with whatever casts you need to make it just work
