From ad5328e11904c2a006967c9d7f71aa3c528f7c06 Mon Sep 17 00:00:00 2001 From: PatrikLundell Date: Thu, 21 Jun 2018 20:48:35 +0200 Subject: [PATCH 1/7] Updated evil weather --- plugins/embark-assistant/defs.h | 37 +++++++++++++++++++++++++++------ 1 file changed, 31 insertions(+), 6 deletions(-) diff --git a/plugins/embark-assistant/defs.h b/plugins/embark-assistant/defs.h index 3196bd5ee..31e548b33 100644 --- a/plugins/embark-assistant/defs.h +++ b/plugins/embark-assistant/defs.h @@ -58,9 +58,15 @@ namespace embark_assist { int16_t biome_index[10]; // Indexed through biome_offset; -1 = null, Index of region, [0] not used int16_t biome[10]; // Indexed through biome_offset; -1 = null, df::biome_type, [0] not used uint8_t biome_count; - bool evil_weather[10]; - bool evil_weather_possible; - bool evil_weather_full; + bool blood_rain[10]; + bool blood_rain_possible; + bool blood_rain_full; + bool permanent_syndrome_rain[10]; + bool permanent_syndrome_rain_possible; + bool permanent_syndrome_rain_full; + bool temporary_syndrome_rain[10]; + bool temporary_syndrome_rain_possible; + bool temporary_syndrome_rain_full; bool reanimating[10]; bool reanimating_possible; bool reanimating_full; @@ -204,6 +210,25 @@ namespace embark_assist { Very_Deep }; + enum class syndrome_rain_ranges : int8_t { + NA = -1, + Any, + Permanent, + Temporary, + Not_Permanent, + None + }; + + enum class reanimation_ranges : int8_t { + NA = -1, + Both, + Any, + Thralling, + Reanimation, + Not_Thralling, + None + }; + /* // Future possible enhancement enum class freezing_ranges : int8_t { NA = -1, @@ -232,9 +257,9 @@ namespace embark_assist { all_present_ranges soil_min_everywhere; soil_ranges soil_max; /*freezing_ranges freezing;*/ - yes_no_ranges evil_weather; // Will probably blow up with the magic release arcs... - yes_no_ranges reanimation; - yes_no_ranges thralling; + yes_no_ranges blood_rain; // Will probably blow up with the magic release arcs... + syndrome_rain_ranges syndrome_rain; + reanimation_ranges reanimation; int8_t spire_count_min; // N/A(-1), 0-9 int8_t spire_count_max; // N/A(-1), 0-9 magma_ranges magma_min; From 14b0ea5b985157aa5661ee06c726b2cba571d910 Mon Sep 17 00:00:00 2001 From: PatrikLundell Date: Thu, 21 Jun 2018 20:49:08 +0200 Subject: [PATCH 2/7] Updated evil weather --- plugins/embark-assistant/embark-assistant.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/plugins/embark-assistant/embark-assistant.cpp b/plugins/embark-assistant/embark-assistant.cpp index bd70df06a..728d96f58 100644 --- a/plugins/embark-assistant/embark-assistant.cpp +++ b/plugins/embark-assistant/embark-assistant.cpp @@ -259,7 +259,9 @@ command_result embark_assistant(color_ostream &out, std::vector & for (uint8_t l = 1; l < 10; l++) { embark_assist::main::state->survey_results[i][k].biome_index[l] = -1; embark_assist::main::state->survey_results[i][k].biome[l] = -1; - embark_assist::main::state->survey_results[i][k].evil_weather[l] = false; + embark_assist::main::state->survey_results[i][k].blood_rain[l] = false; + embark_assist::main::state->survey_results[i][k].permanent_syndrome_rain[l] = false; + embark_assist::main::state->survey_results[i][k].temporary_syndrome_rain[l] = false; embark_assist::main::state->survey_results[i][k].reanimating[l] = false; embark_assist::main::state->survey_results[i][k].thralling[l] = false; } From 1382c04696500f02c3aca556bb1b64fa778018f9 Mon Sep 17 00:00:00 2001 From: PatrikLundell Date: Thu, 21 Jun 2018 20:49:49 +0200 Subject: [PATCH 3/7] Updated evil weather --- plugins/embark-assistant/finder_ui.cpp | 123 +++++++++++++++++++++---- 1 file changed, 104 insertions(+), 19 deletions(-) diff --git a/plugins/embark-assistant/finder_ui.cpp b/plugins/embark-assistant/finder_ui.cpp index 3f972635f..4ef93c91b 100644 --- a/plugins/embark-assistant/finder_ui.cpp +++ b/plugins/embark-assistant/finder_ui.cpp @@ -46,9 +46,11 @@ namespace embark_assist { soil_min, soil_min_everywhere, soil_max, - evil_weather, + blood_rain, + syndrome_rain, +//### evil_weather, reanimation, - thralling, +//### thralling, spire_count_min, spire_count_max, magma_min, @@ -451,9 +453,7 @@ namespace embark_assist { case fields::waterfall: case fields::flat: - case fields::evil_weather: - case fields::reanimation: - case fields::thralling: + case fields::blood_rain: { embark_assist::defs::yes_no_ranges k = embark_assist::defs::yes_no_ranges::NA; while (true) { @@ -576,6 +576,91 @@ namespace embark_assist { break; + case fields::syndrome_rain: + { + embark_assist::defs::syndrome_rain_ranges k = embark_assist::defs::syndrome_rain_ranges::NA; + while (true) { + switch (k) { + case embark_assist::defs::syndrome_rain_ranges::NA: + element->list.push_back({ "N/A", static_cast(k) }); + break; + + case embark_assist::defs::syndrome_rain_ranges::Any: + element->list.push_back({ "Any Syndrome", static_cast(k) }); + break; + + case embark_assist::defs::syndrome_rain_ranges::Permanent: + element->list.push_back({ "Permanent Syndrome", static_cast(k) }); + break; + + case embark_assist::defs::syndrome_rain_ranges::Temporary: + element->list.push_back({ "Temporary Syndrome", static_cast(k) }); + break; + + case embark_assist::defs::syndrome_rain_ranges::Not_Permanent: + element->list.push_back({ "Not Permanent Syndrome", static_cast(k) }); + break; + + case embark_assist::defs::syndrome_rain_ranges::None: + element->list.push_back({ "No Syndrome", static_cast(k) }); + break; + + } + + if (k == embark_assist::defs::syndrome_rain_ranges::None) { + break; + } + + k = static_cast (static_cast(k) + 1); + } + } + + break; + + case fields::reanimation: + { + embark_assist::defs::reanimation_ranges k = embark_assist::defs::reanimation_ranges::NA; + while (true) { + switch (k) { + case embark_assist::defs::reanimation_ranges::NA: + element->list.push_back({ "N/A", static_cast(k) }); + break; + + case embark_assist::defs::reanimation_ranges::Both: + element->list.push_back({ "Reanimation & Thralling", static_cast(k) }); + break; + + case embark_assist::defs::reanimation_ranges::Any: + element->list.push_back({ "Reanimation or Thralling", static_cast(k) }); + break; + + case embark_assist::defs::reanimation_ranges::Thralling: + element->list.push_back({ "Thralling", static_cast(k) }); + break; + + case embark_assist::defs::reanimation_ranges::Reanimation: + element->list.push_back({ "Reanimation", static_cast(k) }); + break; + + case embark_assist::defs::reanimation_ranges::Not_Thralling: + element->list.push_back({ "Not Thralling", static_cast(k) }); + break; + + case embark_assist::defs::reanimation_ranges::None: + element->list.push_back({ "None", static_cast(k) }); + break; + } + + if (k == embark_assist::defs::reanimation_ranges::None) { + break; + } + + k = static_cast (static_cast(k) + 1); + } + } + + break; + case fields::spire_count_min: case fields::spire_count_max: for (int16_t k = -1; k <= 9; k++) { @@ -834,16 +919,16 @@ namespace embark_assist { state->finder_list.push_back({ "Min Soil Everywhere", static_cast(i) }); break; - case fields::evil_weather: - state->finder_list.push_back({ "Evil Weather", static_cast(i) }); + case fields::blood_rain: + state->finder_list.push_back({ "Blood Rain", static_cast(i) }); break; - case fields::reanimation: - state->finder_list.push_back({ "Reanimation", static_cast(i) }); + case fields::syndrome_rain: + state->finder_list.push_back({ "Syndrome Rain", static_cast(i) }); break; - case fields::thralling: - state->finder_list.push_back({ "Thralling", static_cast(i) }); + case fields::reanimation: + state->finder_list.push_back({ "Reanimation", static_cast(i) }); break; case fields::clay: @@ -1058,19 +1143,19 @@ namespace embark_assist { static_cast(state->ui[static_cast(i)]->current_value); break; - case fields::evil_weather: - finder.evil_weather = + case fields::blood_rain: + finder.blood_rain = static_cast(state->ui[static_cast(i)]->current_value); break; - case fields::reanimation: - finder.reanimation = - static_cast(state->ui[static_cast(i)]->current_value); + case fields::syndrome_rain: + finder.syndrome_rain = + static_cast(state->ui[static_cast(i)]->current_value); break; - case fields::thralling: - finder.thralling = - static_cast(state->ui[static_cast(i)]->current_value); + case fields::reanimation: + finder.reanimation = + static_cast(state->ui[static_cast(i)]->current_value); break; case fields::clay: From 91aa16216bc486b6e4d08d280157f1e85e6a2e49 Mon Sep 17 00:00:00 2001 From: PatrikLundell Date: Thu, 21 Jun 2018 20:50:30 +0200 Subject: [PATCH 4/7] Updated evil weather --- plugins/embark-assistant/help_ui.cpp | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/plugins/embark-assistant/help_ui.cpp b/plugins/embark-assistant/help_ui.cpp index 32fb28dbb..a686f2e9f 100644 --- a/plugins/embark-assistant/help_ui.cpp +++ b/plugins/embark-assistant/help_ui.cpp @@ -209,6 +209,11 @@ namespace embark_assist{ help_text.push_back("Min/Max soil uses the same terminology as DF for 1-4. The Min Soil"); help_text.push_back("Everywhere toggles the Min Soil parameter between acting as All and"); help_text.push_back("and Present."); + help_text.push_back("Syndrome Rain allows you to search for Permanent and Temporary syndromes,"); + help_text.push_back("where Permanent allows for Temporary ones as well, but not the reverse, as"); + help_text.push_back("Not Permanent matches everything except Permanent syndromes."); + help_text.push_back("Reanimation packages thralling and reanimation into a single search"); + help_text.push_back("criterion. Not Tralling means nothing and just reanimation is matched."); help_text.push_back("The parameters for biomes, regions, etc. all require that the required"); help_text.push_back("feature is Present in the embark, and entering the same value multiple"); help_text.push_back("times does nothing (the first match ticks all requirements off). It can be"); @@ -254,9 +259,9 @@ namespace embark_assist{ help_text.push_back(" emulate the sizing logic exactly."); help_text.push_back("- There's currently a DF bug (#0010267) that causes adamantine spires"); help_text.push_back(" reaching caverns that have been removed at world gen to fail to be"); - help_text.push_back(" generated. It's likely this bug also affects magma pools."); + help_text.push_back(" generated at all. It's likely this bug also affects magma pools."); help_text.push_back(" This plugin does not address this but scripts can correct it."); - help_text.push_back("Version 0.3 2018-02-26"); + help_text.push_back("Version 0.4 2018-06-21"); break; } From f02f4b8bccdc32e6fd1e4b52c8d39c73a8f739a9 Mon Sep 17 00:00:00 2001 From: PatrikLundell Date: Thu, 21 Jun 2018 20:51:05 +0200 Subject: [PATCH 5/7] Updated evil weather --- plugins/embark-assistant/matcher.cpp | 171 ++++++++++++++++++++------- 1 file changed, 126 insertions(+), 45 deletions(-) diff --git a/plugins/embark-assistant/matcher.cpp b/plugins/embark-assistant/matcher.cpp index d4a2f8ee3..96998f43b 100644 --- a/plugins/embark-assistant/matcher.cpp +++ b/plugins/embark-assistant/matcher.cpp @@ -48,7 +48,9 @@ namespace embark_assist { bool flux_found = false; uint8_t max_soil = 0; bool uneven = false; - bool evil_weather_found = false; + bool blood_rain_found = false; + bool permanent_syndrome_rain_found = false; + bool temporary_syndrome_rain_found = false; bool reanimation_found = false; bool thralling_found = false; uint8_t spire_count = 0; @@ -183,21 +185,39 @@ namespace embark_assist { if (finder->soil_max != embark_assist::defs::soil_ranges::NA && mlt->at(i).at(k).soil_depth > static_cast(finder->soil_max)) return false; - // Evil Weather - if (survey_results->at(x).at(y).evil_weather[mlt->at(i).at(k).biome_offset]) { - if (finder->evil_weather == embark_assist::defs::yes_no_ranges::No) return false; - evil_weather_found = true; + // Blood Rain + if (survey_results->at(x).at(y).blood_rain[mlt->at(i).at(k).biome_offset]) { + if (finder->blood_rain == embark_assist::defs::yes_no_ranges::No) return false; + blood_rain_found = true; + } + + // Syndrome Rain, Permanent + if (survey_results->at(x).at(y).permanent_syndrome_rain[mlt->at(i).at(k).biome_offset]) { + if (finder->syndrome_rain == embark_assist::defs::syndrome_rain_ranges::Temporary || + finder->syndrome_rain == embark_assist::defs::syndrome_rain_ranges::Not_Permanent || + finder->syndrome_rain == embark_assist::defs::syndrome_rain_ranges::None) return false; + permanent_syndrome_rain_found = true; + } + + // Syndrome Rain, Temporary + if (survey_results->at(x).at(y).temporary_syndrome_rain[mlt->at(i).at(k).biome_offset]) { + if (finder->syndrome_rain == embark_assist::defs::syndrome_rain_ranges::Permanent || + finder->syndrome_rain == embark_assist::defs::syndrome_rain_ranges::None) return false; + temporary_syndrome_rain_found = true; } // Reanmation if (survey_results->at(x).at(y).reanimating[mlt->at(i).at(k).biome_offset]) { - if (finder->reanimation == embark_assist::defs::yes_no_ranges::No) return false; + if (finder->reanimation == embark_assist::defs::reanimation_ranges::Thralling || + finder->reanimation == embark_assist::defs::reanimation_ranges::None) return false; reanimation_found = true; } // Thralling if (survey_results->at(x).at(y).thralling[mlt->at(i).at(k).biome_offset]) { - if (finder->thralling == embark_assist::defs::yes_no_ranges::No) return false; + if (finder->reanimation == embark_assist::defs::reanimation_ranges::Reanimation || + finder->reanimation == embark_assist::defs::reanimation_ranges::Not_Thralling || + finder->reanimation == embark_assist::defs::reanimation_ranges::None) return false; thralling_found = true; } @@ -303,14 +323,19 @@ namespace embark_assist { finder->soil_min_everywhere == embark_assist::defs::all_present_ranges::Present && max_soil < static_cast(finder->soil_min)) return false; - // Evil Weather - if (finder->evil_weather == embark_assist::defs::yes_no_ranges::Yes && !evil_weather_found) return false; + // Blood Rain + if (finder->blood_rain == embark_assist::defs::yes_no_ranges::Yes && !blood_rain_found) return false; - // Reanimation - if (finder->reanimation == embark_assist::defs::yes_no_ranges::Yes && !reanimation_found) return false; + // Syndrome Rain + if (finder->syndrome_rain == embark_assist::defs::syndrome_rain_ranges::Any && !permanent_syndrome_rain_found && !temporary_syndrome_rain_found) return false; + if (finder->syndrome_rain == embark_assist::defs::syndrome_rain_ranges::Permanent && !permanent_syndrome_rain_found) return false; + if (finder->syndrome_rain == embark_assist::defs::syndrome_rain_ranges::Temporary && !temporary_syndrome_rain_found) return false; - // Thralling - if (finder->thralling == embark_assist::defs::yes_no_ranges::Yes && !thralling_found) return false; + // Reanimation + if (finder->reanimation == embark_assist::defs::reanimation_ranges::Both && !(reanimation_found && thralling_found)) return false; + if (finder->reanimation == embark_assist::defs::reanimation_ranges::Any && !reanimation_found && !thralling_found) return false; + if (finder->reanimation == embark_assist::defs::reanimation_ranges::Thralling && !thralling_found) return false; + if (finder->reanimation == embark_assist::defs::reanimation_ranges::Reanimation && !reanimation_found) return false; // Spires if (finder->spire_count_min != -1 && finder->spire_count_min > spire_count) return false; @@ -597,46 +622,74 @@ namespace embark_assist { break; } - // Evil Weather - switch (finder->evil_weather) { + // Blood Rain + switch (finder->blood_rain) { case embark_assist::defs::yes_no_ranges::NA: break; // No restriction case embark_assist::defs::yes_no_ranges::Yes: - if (!tile->evil_weather_possible) return false; + if (!tile->blood_rain_possible) return false; break; case embark_assist::defs::yes_no_ranges::No: - if (tile->evil_weather_full) return false; + if (tile->blood_rain_full) return false; break; } - // Reanimating - switch (finder->reanimation) { - case embark_assist::defs::yes_no_ranges::NA: + // Syndrome Rain + switch (finder->syndrome_rain) { + case embark_assist::defs::syndrome_rain_ranges::NA: break; // No restriction - case embark_assist::defs::yes_no_ranges::Yes: - if (!tile->reanimating_possible) return false; + case embark_assist::defs::syndrome_rain_ranges::Any: + if (!tile->permanent_syndrome_rain_possible && !tile->temporary_syndrome_rain_possible) return false; break; - case embark_assist::defs::yes_no_ranges::No: - if (tile->reanimating_full) return false; + case embark_assist::defs::syndrome_rain_ranges::Permanent: + if (!tile->permanent_syndrome_rain_possible) return false; + break; + + case embark_assist::defs::syndrome_rain_ranges::Temporary: + if (!tile->temporary_syndrome_rain_possible) return false; + break; + + case embark_assist::defs::syndrome_rain_ranges::Not_Permanent: + if (tile->permanent_syndrome_rain_full) return false; + break; + + case embark_assist::defs::syndrome_rain_ranges::None: + if (tile->permanent_syndrome_rain_full || tile->temporary_syndrome_rain_full) return false; break; } - // Thralling - switch (finder->thralling) { - case embark_assist::defs::yes_no_ranges::NA: + // Reanimating + switch (finder->reanimation) { + case embark_assist::defs::reanimation_ranges::NA: break; // No restriction - case embark_assist::defs::yes_no_ranges::Yes: + case embark_assist::defs::reanimation_ranges::Both: + if (!tile->reanimating_possible || !tile->thralling_possible) return false; + break; + + case embark_assist::defs::reanimation_ranges::Any: + if (!tile->reanimating_possible && !tile->thralling_possible) return false; + break; + + case embark_assist::defs::reanimation_ranges::Thralling: if (!tile->thralling_possible) return false; break; - case embark_assist::defs::yes_no_ranges::No: + case embark_assist::defs::reanimation_ranges::Reanimation: + if (!tile->reanimating_possible) return false; + break; + + case embark_assist::defs::reanimation_ranges::Not_Thralling: if (tile->thralling_full) return false; break; + + case embark_assist::defs::reanimation_ranges::None: + if (tile->reanimating_full || tile->thralling_full) return false; + break; } // Spire Count Min/Max @@ -950,46 +1003,74 @@ namespace embark_assist { // Soil Max // Can't say anything as the preliminary data isn't reliable - // Evil Weather - switch (finder->evil_weather) { + // Blood Rain + switch (finder->blood_rain) { case embark_assist::defs::yes_no_ranges::NA: break; // No restriction case embark_assist::defs::yes_no_ranges::Yes: - if (!tile->evil_weather_possible) return false; + if (!tile->blood_rain_possible) return false; break; case embark_assist::defs::yes_no_ranges::No: - if (tile->evil_weather_full) return false; + if (tile->blood_rain_full) return false; break; } - // Reanimating - switch (finder->reanimation) { - case embark_assist::defs::yes_no_ranges::NA: + // Syndrome Rain + switch (finder->syndrome_rain) { + case embark_assist::defs::syndrome_rain_ranges::NA: break; // No restriction - case embark_assist::defs::yes_no_ranges::Yes: - if (!tile->reanimating_possible) return false; + case embark_assist::defs::syndrome_rain_ranges::Any: + if (!tile->permanent_syndrome_rain_possible && !tile->temporary_syndrome_rain_possible) return false; break; - case embark_assist::defs::yes_no_ranges::No: - if (tile->reanimating_full) return false; + case embark_assist::defs::syndrome_rain_ranges::Permanent: + if (!tile->permanent_syndrome_rain_possible) return false; + break; + + case embark_assist::defs::syndrome_rain_ranges::Temporary: + if (!tile->temporary_syndrome_rain_possible) return false; + break; + + case embark_assist::defs::syndrome_rain_ranges::Not_Permanent: + if (tile->permanent_syndrome_rain_full) return false; + break; + + case embark_assist::defs::syndrome_rain_ranges::None: + if (tile->permanent_syndrome_rain_full || tile->temporary_syndrome_rain_full) return false; break; } - // Thralling - switch (finder->thralling) { - case embark_assist::defs::yes_no_ranges::NA: + // Reanimating + switch (finder->reanimation) { + case embark_assist::defs::reanimation_ranges::NA: break; // No restriction - case embark_assist::defs::yes_no_ranges::Yes: + case embark_assist::defs::reanimation_ranges::Both: + if (!tile->reanimating_possible || !tile->thralling_possible) return false; + break; + + case embark_assist::defs::reanimation_ranges::Any: + if (!tile->reanimating_possible && !tile->thralling_possible) return false; + break; + + case embark_assist::defs::reanimation_ranges::Thralling: if (!tile->thralling_possible) return false; break; - case embark_assist::defs::yes_no_ranges::No: + case embark_assist::defs::reanimation_ranges::Reanimation: + if (!tile->reanimating_possible) return false; + break; + + case embark_assist::defs::reanimation_ranges::Not_Thralling: if (tile->thralling_full) return false; break; + + case embark_assist::defs::reanimation_ranges::None: + if (tile->reanimating_full || tile->thralling_full) return false; + break; } // Spire Count Min/Max From 9a8e2518533a2b8d1f2f471cbf53e8b4f2815228 Mon Sep 17 00:00:00 2001 From: PatrikLundell Date: Thu, 21 Jun 2018 20:51:36 +0200 Subject: [PATCH 6/7] Updated evil weather --- plugins/embark-assistant/survey.cpp | 69 +++++++++++++++++++++++++---- 1 file changed, 61 insertions(+), 8 deletions(-) diff --git a/plugins/embark-assistant/survey.cpp b/plugins/embark-assistant/survey.cpp index b057ff290..b13d9513e 100644 --- a/plugins/embark-assistant/survey.cpp +++ b/plugins/embark-assistant/survey.cpp @@ -265,6 +265,9 @@ namespace embark_assist { for (uint16_t i = 0; i < world->interaction_instances.all.size(); i++) { auto interaction = world->raws.interactions[world->interaction_instances.all[i]->interaction_id]; uint16_t region_index = world->interaction_instances.all[i]->region_index; + bool blood_rain = false; + bool permanent_syndrome_rain = false; + bool temporary_syndrome_rain = false; bool thralling = false; bool reanimating = false; @@ -284,20 +287,50 @@ namespace embark_assist { if (material && DFHack::MaterialInfo(material->mat_type, material->mat_index).isInorganic()) { for (uint16_t l = 0; l < world->raws.inorganics[material->mat_index]->material.syndrome.size(); l++) { for (uint16_t m = 0; m < world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce.size(); m++) { - if (world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::FLASH_TILE) { + if (world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::FLASH_TILE) { // Using this as a proxy. There seems to be a group of 4 effects for thralls: // display symbol, flash symbol, phys att change and one more. thralling = true; } + else if (world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::PAIN || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::SWELLING || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::OOZING || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::BRUISING || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::BLISTERS || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::NUMBNESS || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::PARALYSIS || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::FEVER || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::BLEEDING || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::COUGH_BLOOD || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::VOMIT_BLOOD || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::NAUSEA || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::UNCONSCIOUSNESS || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::NECROSIS || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::IMPAIR_FUNCTION || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::DROWSINESS || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::DIZZINESS || + world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->getType() == df::creature_interaction_effect_type::ERRATIC_BEHAVIOR) { // Doubtful if possible for region. + if (world->raws.inorganics[material->mat_index]->material.syndrome[l]->ce[m]->end == -1) { + permanent_syndrome_rain = true; + } + else { + temporary_syndrome_rain = true; + } + } } } } + else { // If not inorganic it's always blood, as far as known. + blood_rain = true; + } } } } for (uint16_t k = 0; k < world_data->regions[region_index]->region_coords.size(); k++) { - survey_results->at(world_data->regions[region_index]->region_coords[k].x).at(world_data->regions[region_index]->region_coords[k].y).evil_weather[5] = true; + survey_results->at(world_data->regions[region_index]->region_coords[k].x).at(world_data->regions[region_index]->region_coords[k].y).blood_rain[5] = blood_rain; + survey_results->at(world_data->regions[region_index]->region_coords[k].x).at(world_data->regions[region_index]->region_coords[k].y).permanent_syndrome_rain[5] = permanent_syndrome_rain; + survey_results->at(world_data->regions[region_index]->region_coords[k].x).at(world_data->regions[region_index]->region_coords[k].y).temporary_syndrome_rain[5] = temporary_syndrome_rain; survey_results->at(world_data->regions[region_index]->region_coords[k].x).at(world_data->regions[region_index]->region_coords[k].y).reanimating[5] = reanimating; survey_results->at(world_data->regions[region_index]->region_coords[k].x).at(world_data->regions[region_index]->region_coords[k].y).thralling[5] = thralling; } @@ -305,25 +338,45 @@ namespace embark_assist { for (uint16_t i = 0; i < world->worldgen.worldgen_parms.dim_x; i++) { for (uint16_t k = 0; k < world->worldgen.worldgen_parms.dim_y; k++) { - survey_results->at(i).at(k).evil_weather_possible = false; + survey_results->at(i).at(k).blood_rain_possible = false; + survey_results->at(i).at(k).permanent_syndrome_rain_possible = false; + survey_results->at(i).at(k).temporary_syndrome_rain_possible = false; survey_results->at(i).at(k).reanimating_possible = false; survey_results->at(i).at(k).thralling_possible = false; - survey_results->at(i).at(k).evil_weather_full = true; + survey_results->at(i).at(k).blood_rain_full = true; + survey_results->at(i).at(k).permanent_syndrome_rain_full = true; + survey_results->at(i).at(k).temporary_syndrome_rain_full = true; survey_results->at(i).at(k).reanimating_full = true; survey_results->at(i).at(k).thralling_full = true; for (uint8_t l = 1; l < 10; l++) { if (survey_results->at(i).at(k).biome_index[l] != -1) { df::coord2d adjusted = apply_offset(i, k, l); - survey_results->at(i).at(k).evil_weather[l] = survey_results->at(adjusted.x).at(adjusted.y).evil_weather[5]; + survey_results->at(i).at(k).blood_rain[l] = survey_results->at(adjusted.x).at(adjusted.y).blood_rain[5]; + survey_results->at(i).at(k).permanent_syndrome_rain[l] = survey_results->at(adjusted.x).at(adjusted.y).permanent_syndrome_rain[5]; + survey_results->at(i).at(k).temporary_syndrome_rain[l] = survey_results->at(adjusted.x).at(adjusted.y).temporary_syndrome_rain[5]; survey_results->at(i).at(k).reanimating[l] = survey_results->at(adjusted.x).at(adjusted.y).reanimating[5]; survey_results->at(i).at(k).thralling[l] = survey_results->at(adjusted.x).at(adjusted.y).thralling[5]; - if (survey_results->at(i).at(k).evil_weather[l]) { - survey_results->at(i).at(k).evil_weather_possible = true; + if (survey_results->at(i).at(k).blood_rain[l]) { + survey_results->at(i).at(k).blood_rain_possible = true; + } + else { + survey_results->at(i).at(k).blood_rain_full = false; + } + + if (survey_results->at(i).at(k).permanent_syndrome_rain[l]) { + survey_results->at(i).at(k).permanent_syndrome_rain_possible = true; + } + else { + survey_results->at(i).at(k).permanent_syndrome_rain_full = false; + } + + if (survey_results->at(i).at(k).temporary_syndrome_rain[l]) { + survey_results->at(i).at(k).temporary_syndrome_rain_possible = true; } else { - survey_results->at(i).at(k).evil_weather_full = false; + survey_results->at(i).at(k).temporary_syndrome_rain_full = false; } if (survey_results->at(i).at(k).reanimating[l]) { From 8e1a1851bef59756c14e98706acd4dd41ef1ee36 Mon Sep 17 00:00:00 2001 From: PatrikLundell Date: Thu, 21 Jun 2018 21:00:59 +0200 Subject: [PATCH 7/7] Removed temporary comments --- plugins/embark-assistant/finder_ui.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/plugins/embark-assistant/finder_ui.cpp b/plugins/embark-assistant/finder_ui.cpp index 4ef93c91b..b04d6bd06 100644 --- a/plugins/embark-assistant/finder_ui.cpp +++ b/plugins/embark-assistant/finder_ui.cpp @@ -48,9 +48,7 @@ namespace embark_assist { soil_max, blood_rain, syndrome_rain, -//### evil_weather, reanimation, -//### thralling, spire_count_min, spire_count_max, magma_min,