On Friday, 22 March 2024 at 07:34:33 UTC, monkyyy wrote:
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.
Well, none of the stuff you wrote closely resembles the code that
I have.
There are 3 reasons why I put this kind of effort into
optimization:
- I'm obsessive.
- For the learning experience.
- Because things may get more demanding when I get further with
the enemy AI system. One possibility is to have it make multiple
copies of all the game objects which it will use to look ahead to
the next 1-2 turns.
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
I barely understand any of this, though I know what a Manhattan
distance is. Is this about measuring distances? Manhattan
distances appear to be how distances are determined in Fire
Emblem, though I'm using a slightly more intensive `abs(x) +
abs(y) + max(abs(x) + abs(y))` whenever I need a quick estimate
of distance that doesn't account for obstructions.
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:
But objects are reference by default. This means that they don't
really 'live' in the array I put them in, doesn't it? Wouldn't
the the array entries just be references on the same level as any
other?
```d
int[10] foo;
&foo.print;
&foo[1].print;
(&foo[7]-&foo[0]).print;
```
This appears to be a different programming language. It isn't D.
