Bay 12 Games Forum

Please login or register.

Login with username, password and session length
Advanced search  
Pages: 1 ... 8 9 [10] 11 12 ... 24

Author Topic: DFHack plugin embark-assistant  (Read 100713 times)

PatrikLundell

  • Bay Watcher
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #135 on: October 25, 2019, 12:10:21 pm »

Trying to analyze the geo biome for commonalities isn't a good idea if you want the plugin to work for modded geo biomes. It's true that neighboring tiles usually share the same geo biome, but they may not share their depth cutoff (which is where DF mis-reports deep metals/flux) or the soil erosion level (missing sand/clay/aquifer), and bunching together the geo biome results for multiple tiles more or less leads to re-processing the geo biome, in which case all you need to store is the geo biome index and the top/bottom level info (to account for soil erosion as well as magma sea cutoff). That, however, is expected to trade memory for measurable amounts of repeated processing, which is the current situation (which re-processes the geo biome, including erosion/depth cutoff determination for every mid level tile within every world tile that hasn't failed other criteria if such data is required, and for all tiles in the current world tile, for embark preview display purposes).

I expect the common use case to be a preliminary search with one or more refinements (typically either failing to find exactly what was desired, and so loosen the constraints, or finding lots of hits, allowing for additional conditions), in which case a cache comes in handy. Dual implementation with/without a cache seems like it will result in messy code (complexity that can actually be managed may be justified if the benefits to the users are large enough, though).
Logged

RedDwarfStepper

  • Bay Watcher
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #136 on: October 25, 2019, 06:48:27 pm »

Thanks for your quick feedback!

However, I'm unable to see how you can compress what you mentioned into 200 MB, as my quick calculation results in: ... about 560 MB
Ah, that is the nice thing about Roaring Bitmap: It's an inverted index, so you only add those entries to the index which for example have a river or coal, which results in a lot less total entries than 257*257*256 for every attribute/aspect
See here for a practical explanation
https://medium.com/@amit.desai03/roaring-bitmaps-fast-data-structure-for-inverted-indexes-5490fa4d1b27
and here for more details
https://roaringbitmap.org/about/
and being compressed it allows for sub-bit memory use per entry, depending on the data, see here
https://arxiv.org/pdf/1709.07821.pdf, page 20
Dense, non-random, sorted data produces the best results. During my experiments I used a RoaringBitmap to keep track of which mid level tiles were already processed, each one got an "id" which was calculated by its x,y,i,k-position, starting with 0 (y=0,x=0,i=0,k=0). In the end the bitmap contained all integers from 0 to 16908544 and it would have taken only 3kb to serialize it.

Nevertheless, this might be a useful approach, although the speed impact will have to be investigated
Absolutely, if it is even a little slower during the survey or the match phase it won't make any sense to pursue this approach any further.
But the data structure offers very fast set operations (union, intersect, ...) which allow for some nifty tricks when looking for a certain combination of attributes.
My idea was to sort the bitmap indexes ascending by size once the complete index/survey phase is over and always start by looking for matches in the smallest relevant index (e.g. probably volcanoes, waterfalls or other rare attributes). The fastest case would be no matches, which means the whole process could stop.
If there are any matches we iterate over them and look into the next (bigger) relevant index to see if there are any intersections and so on.

Note, though, that there are currently 3 vectors over the inorganics
I already stored them separately...  :D

Incursion processing is indeed complicated
Yes, I see that now. I had a look at your comments here
https://github.com/DFHack/df-structures/commit/caebec25986228d15a6e1179b0745fec83f97562
and boy is my head spinning. I'll probably have to look at the code again and create some sketches and/or schematic views of the mid level and region tiles and annotate them with my questions and how I think I understood the concept. And then you can hopefully tell me how it really works. ;D

Also, caching search result should probably be a auto-off toggle.
Yes, I also thought that might be a good idea - but for the big (257*257) maps which would benefit the most the users probably have a beefy system with enough ram. Just loading the map needs more than 1 GB ram already.

But I really need to prove all those hunches, theories and ideas, so I'll have to get a minimal example/proof of concept working, which still might result in the discovery that it just won't work for some reason I haven't thought about yet.
« Last Edit: October 25, 2019, 06:54:45 pm by RedDwarfStepper »
Logged

PatrikLundell

  • Bay Watcher
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #137 on: October 26, 2019, 06:20:14 am »

OK, so if I understand it correctly (having read the two first papers and only looked at the last, boringly academic one), you're changing the storage of properties from being per mid level tile bitmaps over properties to be global per property, "indexed" by the mid level tile, in which case I'd expect most of them to be sparse and without significant runs, resulting in storage as arrays of MLT indices, which ought to require significantly less memory (at the expense of binary searches) than retaining the current MLT level data in memory. I'd also expect the metal lists in particular to be short, but also that most of the economics lists to be rather short, although very low "scarcity" world gen values would make the lists a bit longer.
Lists over savagery/evilness would probably be rather dense for the normal (middle) values, resulting in bitmaps that don't compress well, while the other values would result in a lot sparser lists/bitmaps. In any case, every MLT has exactly one of the three values in each range as their primary value, and may have one or both of the other two as incursion contributions.

It can be noted that this implementation strategy change would force the use of storage of all criteria in memory, and great care has to be taken to ensure the memory usage is kept in check: I do not agree with the assumption that a full size world equates the 64 bit version of DF and hence "sufficient" amounts of memory, as you could create a normal sized embark in a full size world before DF provided a 64 bit implementation, and nothing fundamental has happened since then. The main reason to keep away from large worlds in the FPS drain caused by world activities. If a full world uses 1 GB (I haven't checked), that would mean this plugin would be required to stay well below 1 GB to work with the 32 bit Windows DF version.

Incursions: It took quite some time to understand what the original comments in the DF structures meant and figure out how they worked, and I have absolutely no idea how the person who wrote that managed to figure it out. You don't want to know what my initial attempts to code the logic looked like, as it was an absolute mess of cases within cases.
Logged

RedDwarfStepper

  • Bay Watcher
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #138 on: October 29, 2019, 07:34:29 pm »

OK, so if I understand it correctly ...
You are absolutely correct, this would be some kind of database-table or -index design.
I did quite a poor job of explaining it properly: It is kind of a database-table or -index design.
Also I took another look at the memory requirements for a std::vector<bool> and it seems that in many cases it would be cheaper memory-wise to use one of those - even for 257*257*256 entries (~ 2Mb).
The sparse inorganics might be a notable exception, I'll have to test that.
So I have to ask: What do you generally think about the idea to change the way the data is stored?

It can be noted that this implementation strategy change would force the use of storage of all criteria in memory, and great care has to be taken to ensure the memory usage is kept in check: I do not agree with the assumption that a full size world equates the 64 bit version of DF and hence "sufficient" amounts of memory, as you could create a normal sized embark in a full size world before DF provided a 64 bit implementation, and nothing fundamental has happened since then. The main reason to keep away from large worlds in the FPS drain caused by world activities. If a full world uses 1 GB (I haven't checked), that would mean this plugin would be required to stay well below 1 GB to work with the 32 bit Windows DF version.
Again you are right - assuming that everybody has a lot of ram was a misconception.
That's why I'm looking for ways to save as much memory as possible without ruining the performance.

Might I ask you a favor?
I uploaded the save (http://dffd.bay12games.com/file.php?id=14584) and profiles I use for getting an idea how much memory it would take to "index" everything for a large world.
Could you please run an initial "find embark" with the included embark assistant profile once with the current version of the plugin and once with your latest version (it's https://github.com/PatrikLundell/dfhack/tree/embark-assistant isn't it?) and tell me how long it takes to finish the first time and how much additional memory is allocated in each case?
That would help me to better gauge how the plugin performs on another system.

I really would like to make faster progress - but currently I only have the nights to do some coding. While I like it, it's not my most productive time...
I got some refactoring done while reading the code, which resulted in a slightly smaller release dll, if you want to take a look:
https://github.com/bseiller/dfhack/tree/embark-assistant/plugins/embark-assistant

Ah one more thing: I trying to profile the memory consumption with MS VS, but all I see is "unresolved allocations" which really doesn't help a lot. I assume the reason for this is how dfhack is "integrated" with DF, as the profiling works just fine in a test project (exe). Any clue you can give me on how to get the memory profiling working is very much appreciated! Or perhaps you know where or who to ask
Logged

PatrikLundell

  • Bay Watcher
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #139 on: October 30, 2019, 05:56:12 am »

I made the crude measurements (task manager) asked for:

          Old    New
DF only    1076.8 1023.1
EA started 1115.2 1579.0
Max        1139.8 16XX.X
Done       1127.5 1592.3
Time         5:50  26:50

I hadn't expected the memory usage reduction to happen as early as I did for the later version, hence I didn't remember the values when it suddenly shrank, but they were probably low (1607,X?).

I have no experience profiling C(++), and the profiling I have done were on other languages on other platforms. I would assume profiling a DLL as part of a program to differ from profiling a program, though, in particular if there's no symbol information for the hosting program. I'd try to look for something that tried to restrict the profiling to the known part of the executable (i.e. the DLL), or to separate the known locations from the unknown host ones.

Edit:
I had a quick look at the changes, which were a lot lighter than I would have expected when the word "refactoring" is used. I'm a bit surprised that the code would get smaller, though, as I had expected the compiler to be smart enough to factor out common parts.

I have two style comments, though:
- As opposed to the C crowd, I don't have a pathological aversion to typing, so I would have used readable identifiers to a much larger extent than the TLA/FLAC usage. (TLA = Three Letter Acronym, FLAC = Four Letter ACronym, which is not a standard one).
- I find camel case to be extremely ugly and instead separate words using underscores (or, occasionally, use Germanic [and DF!] word mashing [and those languages somehow do just fine without camels]).
« Last Edit: October 30, 2019, 06:52:03 am by PatrikLundell »
Logged

RedDwarfStepper

  • Bay Watcher
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #140 on: October 30, 2019, 05:53:35 pm »

I made the crude measurements (task manager) asked for:

          Old    New
DF only    1076.8 1023.1
EA started 1115.2 1579.0
Max        1139.8 16XX.X
Done       1127.5 1592.3
Time         5:50  26:50

Thank you for taking the time to get these numbers.
Ok, that's interesting - for me the previous version takes around 8 minutes. And the new, unchanged version around 13 -
Memory wise I see pretty much the same, a little more in both cases, but the ratio is about right here

I had a quick look at the changes, which were a lot lighter than I would have expected when the word "refactoring" is used.
Hehe, I'm just starting to pick up speed - I don't want to break something right away. But we'll get there

I'm a bit surprised that the code would get smaller, though, as I had expected the compiler to be smart enough to factor out common parts.
Yeah, me too. Actually changing variable names doesn't make a difference, but it seems function call (like .at()) aren't optimized away with the default project settings.

I have two style comments, though:
- As opposed to the C crowd, I don't have a pathological aversion to typing, so I would have used readable identifiers to a much larger extent than the TLA/FLAC usage. (TLA = Three Letter Acronym, FLAC = Four Letter ACronym, which is not a standard one).
- I find camel case to be extremely ugly and instead separate words using underscores (or, occasionally, use Germanic [and DF!] word mashing [and those languages somehow do just fine without camels]).
Done and done.

Ok, so before I really break something, you don't happen to have a "test world" that helps you to verify any changes?
I looked into "Perfect World" but it seems impossible to just paint the biomes and other stuff exactly like you want it.
A pocket world with some defined rare combinations (like e.g. volcano & waterfall in the desert) in different embark tiles could be a nice tool to check changes.
Speaking about pocket worlds, it seems that at least with my build using embark assistant in pocket worlds crashes the game. Can you reproduce that? If I recall correct it already happened before I started changing stuff...
The crash is provoked around here: https://github.com/PatrikLundell/dfhack/blob/79791505660f3dc55895aa103c8907214ec10afb/plugins/embark-assistant/survey.cpp#L1369
Logged

Pvt. Pirate

  • Bay Watcher
  • Dabbling Linux User
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #141 on: October 31, 2019, 05:43:52 am »

I had a quick look at the changes, which were a lot lighter than I would have expected when the word "refactoring" is used.
Hehe, I'm just starting to pick up speed - I don't want to break something right away. But we'll get there
:D Hehe, it always comes to the point of breaking something eventually and then taking a step back and going slower again and succeeding.
Logged
"dwarves are by definition alcohol powered parasitic beards, which will cling to small caveadapt humanoids." (Chaia)

PatrikLundell

  • Bay Watcher
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #142 on: October 31, 2019, 09:34:17 am »

Thanks for the crash report.

It took a bit of time to find out what was wrong, but it is indeed a bug.
The line should be
Code: [Select]
            tile->region_type[i][k] = world_data->regions[tile->biome_index[mlt->at(i).at(k).biome_offset]]->type;
i.e. "biome" -> "biome_index".
The reason it crashes only on pocket worlds is that the number of regions in those worlds tend to be fewer than the number of biome types, i.e. the index passed in was the biome type, but was interpreted as the index of the region.
The bug should screw up the reasonably (I think) uncommon searches for region types when it doesn't cause a crash.

I use my own tweakmap http://www.bay12forums.com/smf/index.php?topic=161188.msg7228166#msg7228166 tool to create PSV worlds, as I consider the DF vanilla tool to be a serious contender for the worst interface ever and after coming to the conclusion that I'd have to create an image to feed into Perfect World for it to be useful (I originally wanted to feed the PSV values extracted from an existing generated world for tweaking), and if I was going to do that, I could just as well place the actual biomes wanted as the pixels.
However, volcano placement can only be suggested, although I think it would be possible to get close by restricting the number of tiles with high volcanism. Rivers and lakes are completely up to DF (although both can be hacked after world gen, with a lot of patience, but the only ways to save the results are either to do the tweaking during world gen [e.g. by breaking in directly after the generation of those features, but before history, etc.], or by embarking).
Also note that both Salinity and Evilness are missing from the set of PSV values, so there parameters can't be controlled.
Logged

Fleeting Frames

  • Bay Watcher
  • Spooky cart at distance
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #143 on: October 31, 2019, 06:17:42 pm »

You can place volcanoes by exactly 100 volcanism in desired tiles + desired number of volcanoes in min volcanoes. Though that's still just somewhere in world tile, not any more accurate. Rivers&lakes yeah you can only suggest with elevation, not place.

PatrikLundell

  • Bay Watcher
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #144 on: November 01, 2019, 06:01:01 am »

The Mid Level Tile (MLT) placement of volcanoes is calculated by DF when the tiles are generated on the fly, presumably using an RNG seed hidden away somewhere. It's possible to hack the location of a volcano while the world tile is in focus (so you can place it where you want for an immediate embark), but changing the focus away and back causes the volcano to revert to its original MLT location.
Hacking a new volcano into a world tile has DF assign it a "random" MLT location within the tile. As with natural volcanoes, the location remains the same when you change focus and return to the tile.
Logged

RedDwarfStepper

  • Bay Watcher
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #145 on: November 07, 2019, 05:08:44 pm »

Thanks for the explanation concerning the creation of specific region.
I downloaded the scripts (haven't had time to test them) and had a look at https://github.com/PatrikLundell/scripts/tree/own_scripts.
I couldn't find exportmap.lua in the repro - does it have another name there?
Are the dropbox files the latest version?
What does the TLA PSV stand for? - I couldn't find any definition...

Meanwhile I broke something with my refactoring and it took some time to find the error - now it works as expected.
I might refactor more code while I prototype the index and keep it in a separate branch which will allow for easy merging if you feel that the code is up to your standards.

Trying to profile the heap usage I shot myself in the foot with gflags and debug heaps which resulted in a much bigger memory footprint and much slower search times due to the profiling overhead.
I had forgotten that I activated it and the config hides in the registry...
That got me thinking: Could it be that the second column (incursions included) was so slow because it was a "RelWithDebInfo" build?
I made the crude measurements (task manager) asked for:

          Old    New
DF only    1076.8 1023.1
EA started 1115.2 1579.0
Max        1139.8 16XX.X
Done       1127.5 1592.3
Time         5:50  26:50


For now there is one more question: What was the motivation to keep the inorganics in mid_level_tile in three separate vectors?
In my test world there are 265 inorganics (metals + economics + minerals), each with a unique index, no overlap...
Does modding change that?
Logged

PatrikLundell

  • Bay Watcher
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #146 on: November 08, 2019, 07:48:12 am »

I'd missed to add exportmap to own_scripts, and tweakmap wasn't the latest version in either place (fixed now).

PSV = Pre Set Values. That's the specification of temperature, savagery, rainfall, elevation, volcanism, and drainage DF allows advanced world gen to specify per world tile.

RelWithDebInfo may well be a factor in the sluggishness. Unfortunately, my attempts to compile it with Release has met with failures so far (the latest one being a spontaneous reboot of the computer for no apparent reason), so I haven't been able to test it yet.

The reason for keeping inorganic in three vectors is ease of searching with a guess that it ought to be faster than a more complex logic. Also note that once the decision to regenerate/discard info, storage size is much less important than speed. There isn't anything I'm aware of that would stop an inorganic from being both a metal and something that's involved in a non metal related (modded) reaction, and I thought the minerals list was complete, i.e. listed all minerals, regardless of whether they are present in the other lists (with clays showing up in both lists). Metals won't show up in that list because they're never actually present in their metallic form (native gold isn't actually a metal itself, but a source for a reaction that produces the metal) in the vanilla game.
It's quite possible to have a single list of everything found either natively or resulting from a metal production reaction and then have three separate global lists that contain the indices of the inorganics that match the criteria for each list. Thus, to identify the minerals, you'd iterate over the "minerals" list and check whether the corresponding index in the compound list for a tile is true or not, and similarly for the two other (much shorter) lists. Note that to generate the lists of minerals in DF you'd have to figure out a way to determine which inorganics the game can include in all the geo-biome positions, which may be non trivial (when I asked, the forum didn't know how to determine if an area is "alluvial", and some minerals (opals, I think) appear only in those places, but that may not be an issue here: it may well be that just adding "alluvial" ones to those that can readily be identified is sufficient).
There are probably other ways to achieve the same thing, so if trying to save space it's definitely possible to store the info in a single vector and process it to determine where different pieces fit,and you'd only do that for searches if the search criteria look for that specific info. For the embark location overlay you'd have to do the complete processing, but that's only for the tiles in that embark, and that changes at human speed, which means the processing time isn't important.

Edit:
Finally got Release working (it help to try to run the right DF copy...). As you suggested, it showed a dramatically improved performance at 7:30, with the high and final memory usage a 1601.7 MB.

Edit 2:
I've been thinking, and believe it's a mistake to try to massage the current inorganics presence storage. All you really NEED is two bytes to store the first and last layer of the geo biome present for each MLT (in addition to the index of the geo biome itself, which is currently stored), as all the rest of the info is available from the geo biome itself (And since the two values are in the range 0-15, you can actually store both of them in a single byte). To get the first/last layers we could cut away a fair bit of the code from the modified Prospector code of the MLT processing (the removed code would still be needed elsewhere to extract the actual inorganics, though).
With that basic information stored, you can either process the geo biome each time you need the data, or you can try to pre process the geo biomes to speed up the information extraction.
- The layers potentially worn away by erosion are all soil layers, and DF never seems to generate more than 4 of those. It's possible to hack the geo biome to get more soil layers and/or deeper soil, and DF can erode up to 10 Z levels, if I remember correctly. The suggestion below doesn't actually make any use of this info, though.
- DF doesn't use more than 16 layers of the geo biome even if hacking has added more (DF stretches the last one to fill the gap to the magma sea if needed).
This means that one possible approach would be to make a bit array for each layer of each geo biome and then merge the ones you have in each MLT with OR operations (16 layers * 33 byte bit array * X geo biomes). Even if DF doesn't croak at a silly max size PSV world with a checkerboard layout (forcing each world tile to get its own geo biome), you'd still not use more than 35 MB to store the info in a more convenient format than the geo biomes themselves.

Returning to the logic of the 3 lists (as per the current implementation), they don't help with embark matching, as you can just as well check for a True in a merged list as you can in a list dedicated to the category you're checking. The place where it is of some help is when generating the embark location resource lists displayed, but it's a marginal extra effort to iterate over Economics and Metal indices lists to check against a presence in a common list, and that processing happens at human speed anyway. Thus, it could have been implemented better.
« Last Edit: November 10, 2019, 06:21:43 am by PatrikLundell »
Logged

RedDwarfStepper

  • Bay Watcher
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #147 on: November 12, 2019, 06:09:29 pm »

I'd missed to add exportmap to own_scripts, and tweakmap wasn't the latest version in either place (fixed now).
Thanks!

Also thanks for the in-depth explanation on how the inorganics work and on the why the data is structured the way it is!

Edit:
Finally got Release working (it help to try to run the right DF copy...). As you suggested, it showed a dramatically improved performance at 7:30, with the high and final memory usage a 1601.7 MB.
Ah, that sounds more like it - but damn - your system/CPU must be quite a little bit beefier than mine.

I spent some time with profiling the plugin (had to set up a new release-optimized-but-with-symbols config, as the "RelWithDebInfo" performed quite different compared to "Release").
After that I profiled just the pure movement code (embark_assist::matcher::find + embark_assist::matcher::move_cursor) without any real surveying and matching.
And - I had forgotten - as you already had said: a lot of the time is being spent in the movement part of the code

One complication is that DF uses a data structure with "feature shells", i.e. 16*16 world tile blocks, and loading those take a significant amount of time (about half of the total search time), which has caused me to ensure the world is processed one feature shell at a time
After removing all of real logic it still took around 8 minutes to iterate over the whole large map - instead of the 12 minutes with all the logic.
I also played around with threads a little - to no avail as of now.
So speeding up the search logic itself solves only half the problem, as the main-loop/interaction with the DF core takes so much time.
I really had hoped to find an "easy" solution to speed things up.
Any ideas how we could go about to make <screen->feed_key> "faster" or parallelize it?
I'll need to regroup and do a little more work on the index proof of concept to get my spirits up ....

PS: I could upload the profiling report if you want to have a look, assuming that you use MS VS...
Logged

Fleeting Frames

  • Bay Watcher
  • Spooky cart at distance
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #148 on: November 12, 2019, 06:36:35 pm »

I'm not certain if embark-assistant already uses it, but frames are just calls of logic() on dwarfmode viewscreens - this could be helpful maybe?

PatrikLundell

  • Bay Watcher
    • View Profile
Re: DFHack plugin embark-assistant
« Reply #149 on: November 13, 2019, 06:40:58 am »

My PC was a just below the very top off-the-shelf ones when I bought it quite a few years ago, but it's showing its age, actually, by having trouble with graphics intensive games (which obviously doesn't include DF).

I don't think there is anything you can do about the movement code to get any significant improvement, as the bulk of the time spent is waiting for DF to load feature shells and to generate MLT data for the current world tile. The most important thing here is to reduce the number of these calls to the absolute minimum, and I think the current code is close to that for the first pass (I believe every world tile is passed through once, with each feature shell loaded once, except for the initial movement up to the starting position).
You can't parallelize DF feature shell/world tile data loading/generation unless you run multiple copies of DF and somehow synchronize them to process different parts of the world, which seems rather messy.

I can understand that generation of MLT data from seeds takes some time, but I'm still wondering why DF takes so long to generate feature shells as the DFHack mapped data structures aren't that big. It may be that there's some significant file reading involved, but I haven't investigated the cause as I believe it's something we can't do anything about anyway.
In short, I believe the DF MLT data generation and feature shell loading are things we just have to live with, and deal with by ensuring we keep those activities to a minimum.

The big gain would be to remove the need to repeat the actual movements for subsequent searches, i.e. to collect all the info requiring movement on the first pass and then use that info together with what's available statically from DF structures for the matching. That, however, requires intelligent storage of the information that's required, optionally together with that which is costly to collect, while the rest would be collected from the DF data structures available statically when it's needed.

There's also a psychological aspect to the process: we can't collect data for minutes without providing some kind of progress feedback to the user (which is why the feedback used by DF's native search is emulated currently).

I am using MS VC, but I currently wouldn't have any use for the profiling report. I don't think it's a good idea to mess around with trying to optimize code in parallel with someone else trying to revise it. However, it would be useful when you're done with your activities.

I don't understand Fleeting Frames' comment. I don't believe the time it takes to do the actual calling is a great issue, but rather the time DF spends doing what those calls trigger (which is what we need DF to produce, so we can read it). I certainly would like to have a way to move DF's focus directly to a specific world tile rather than go there in steps of 1 or 10 tiles through simulated key presses, as that would be much more convenient to use, but I doubt it would make any significant difference from a performance perspective.
Logged
Pages: 1 ... 8 9 [10] 11 12 ... 24