openboe/oboe
2
0
Fork 0
Code Issues 146 Pull Requests 4 Actions Packages Projects Releases Wiki Activity
Files
f609711e273686cd71a69b9384af6f4c0e4500cb
oboe/src/scenedit/scen.core.cpp

3264 lines
118 KiB
C++
Raw Blame History

#include <cstdio>
#include <cstring>
#include <functional>
#include <numeric>
#include <algorithm>
#include <boost/lexical_cast.hpp>
#include "scen.global.h"
#include "scenario.h"
#include "regtown.h"
#include "graphtool.hpp"
#include "scen.graphics.h"
#include "scen.core.h"
#include "scen.keydlgs.h"
#include "scen.townout.h"
#include "scen.fileio.h"
#include "scen.actions.h"
#include "scen.menus.h"
#include "dialog.hpp"
#include "dlogutil.hpp"
#include "fileio.hpp"
#include "field.hpp"
#include "restypes.hpp"
#include "stack.hpp"
#include "spell.hpp"
#include "mathutil.hpp"
extern short cen_x, cen_y,cur_town;
extern bool mouse_button_held;
extern bool editing_town;
extern short cur_viewing_mode;
extern cTown* town;
extern cOutdoors* current_terrain;
extern short mode_count,to_create;
extern ter_num_t template_terrain[64][64];
extern cScenario scenario;
extern cCustomGraphics spec_scen_g;
extern location cur_out;
extern const std::multiset<eItemType> equippable;
const std::set<eItemAbil> items_no_strength = {
eItemAbil::NONE, eItemAbil::HEALING_WEAPON, eItemAbil::RETURNING_MISSILE, eItemAbil::SEEKING_MISSILE, eItemAbil::DRAIN_MISSILES,
eItemAbil::LIGHTER_OBJECT, eItemAbil::HEAVIER_OBJECT, eItemAbil::LIFE_SAVING, eItemAbil::POISON_AUGMENT,
eItemAbil::QUICKFIRE,
};
static bool save_ter_info(cDialog& me, cTerrain& ter) {
eTerSpec prop = eTerSpec(boost::lexical_cast<short>(dynamic_cast<cLedGroup&>(me["prop"]).getSelected().substr(4)));
int spec_type = me["flag2"].getTextAsNum();
int num_town = (**std::min_element(scenario.towns.begin(), scenario.towns.end(), [](cTown* a,cTown* b){
return a->specials.size() < b->specials.size();
})).specials.size();
int num_out = (**std::min_element(scenario.outdoors.begin(), scenario.outdoors.end(), [](cOutdoors* a,cOutdoors* b){
return a->specials.size() < b->specials.size();
})).specials.size();
int num_loc = std::min(num_town, num_out);
int num_glob = scenario.scen_specials.size();
switch(prop) {
case eTerSpec::CHANGE_WHEN_STEP_ON:
case eTerSpec::CHANGE_WHEN_USED:
if(!check_range(me, "flag1", true, 0, scenario.ter_types.size() - 1, "Terrain to change to")) return false;
if(!check_range(me, "flag2", true, 0, 99, "Sound to play")) return false;
break;
case eTerSpec::DAMAGING:
if(!check_range(me, "flag1", true, 0, 100, "Sides per die")) return false;
if(!check_range(me, "flag2", true, 0, 100, "Number of sides")) return false;
if(!check_range(me, "flag3", true, 0, 8, "Damage type")) return false;
break;
case eTerSpec::DANGEROUS:
if(!check_range(me, "flag1", true, 0, 8, "Strength")) return false;
if(!check_range(me, "flag2", true, 0, 100, "Percentage chance")) return false;
if(!check_range(me, "flag3", true, 0, 14, "Status type")) return false;
break;
case eTerSpec::CRUMBLING:
if(!check_range_msg(me, "flag2", true, 0, 2, "Method", "1 - Move Mountains, 2 - quickfire, 0 - either")) return false;
if(false) // Prevent next line from executing if it's crumbling
case eTerSpec::UNLOCKABLE:
if(!check_range(me, "flag2", true, 0, 10, "Difficulty")) return false;
case eTerSpec::LOCKABLE:
case eTerSpec::TOWN_ENTRANCE:
if(!check_range(me, "flag1", true, 0, scenario.ter_types.size() - 1,
prop == eTerSpec::TOWN_ENTRANCE ? "Terrain when hidden" : "Terrain to change to"))
return false;
break;
case eTerSpec::WATERFALL_CAVE:
case eTerSpec::WATERFALL_SURFACE:
case eTerSpec::CONVEYOR:
if(!check_range(me, "flag1", true, 0, 7, "Direction")) return false;
break;
case eTerSpec::CALL_SPECIAL:
case eTerSpec::CALL_SPECIAL_WHEN_USED:
if(spec_type < 0 || spec_type > 1) {
giveError("Special type must be either 0 or 1.", &me);
return false;
}
if(!check_range(me, "flag1", true, 0, (spec_type == 0 ? num_glob : num_loc) - 1, "Special to call")) return false;
break;
case eTerSpec::BRIDGE: case eTerSpec::BED: case eTerSpec::IS_A_SIGN: case eTerSpec::IS_A_CONTAINER: case eTerSpec::BLOCKED_TO_MONSTERS:
case eTerSpec::WILDERNESS_CAVE: case eTerSpec::WILDERNESS_SURFACE: case eTerSpec::NONE:
case eTerSpec::UNUSED1: case eTerSpec::UNUSED2: case eTerSpec::UNUSED3:
break;
}
ter.picture = me["pict"].getTextAsNum();
// TODO: Should somehow verify the pict number is valid
std::string blockage = dynamic_cast<cLedGroup&>(me["blockage"]).getSelected();
if(blockage == "clear") ter.blockage = eTerObstruct::CLEAR;
else if(blockage == "curtain") ter.blockage = eTerObstruct::BLOCK_SIGHT;
else if(blockage == "special") ter.blockage = eTerObstruct::BLOCK_MONSTERS;
else if(blockage == "window") ter.blockage = eTerObstruct::BLOCK_MOVE;
else if(blockage == "obstructed") ter.blockage = eTerObstruct::BLOCK_MOVE_AND_SHOOT;
else if(blockage == "opaque") ter.blockage = eTerObstruct::BLOCK_MOVE_AND_SIGHT;
ter.special = prop;
ter.flag1 = me["flag1"].getTextAsNum();
ter.flag2 = me["flag2"].getTextAsNum();
ter.flag3 = me["flag3"].getTextAsNum();
ter.trans_to_what = me["trans"].getTextAsNum();
ter.fly_over = dynamic_cast<cLed&>(me["flight"]).getState() == led_red;
ter.boat_over = dynamic_cast<cLed&>(me["boat"]).getState() == led_red;
ter.block_horse = dynamic_cast<cLed&>(me["horse"]).getState();
ter.light_radius = me["light"].getTextAsNum();
std::string sound = dynamic_cast<cLedGroup&>(me["sound"]).getSelected();
// TODO: Offer the option of a custom sound?
if(sound == "step") ter.step_sound = eStepSnd::STEP;
else if(sound == "squish") ter.step_sound = eStepSnd::SQUISH;
else if(sound == "crunch") ter.step_sound = eStepSnd::CRUNCH;
else if(sound == "nosound") ter.step_sound = eStepSnd::NONE;
else if(sound == "splash") ter.step_sound = eStepSnd::SPLASH;
std::string shortcut = me["key"].getText();
if(shortcut.length() > 0) ter.shortcut_key = shortcut[0];
else ter.shortcut_key = 0;
ter.name = me["name"].getText();
ter.ground_type = me["ground"].getTextAsNum();
ter.trim_ter = me["trimter"].getTextAsNum();
ter.trim_type = (eTrimType) me["trim"].getTextAsNum();
ter.combat_arena = me["arena"].getTextAsNum();
ter.map_pic = me["map"].getTextAsNum();
return true;
}
// TODO: It would probably be good to use these for other dialogs, instead of the monolithic event filters
bool check_range_msg(cDialog& me,std::string id,bool losing,long min_val,long max_val,std::string fld_name,std::string xtra){
if(!losing) return true;
cTextField& fld_ctrl = dynamic_cast<cTextField&>(me[id]);
long n = fld_ctrl.getTextAsNum();
if(n < min_val || n > max_val){
std::ostringstream sout;
sout << fld_name << " must be from " << min_val << " to " << max_val;
if(!xtra.empty()) sout << ' ' << '(' << xtra << ')';
giveError(sout.str(), "", &me);
return false;
}
return true;
}
bool check_range(cDialog& me,std::string id,bool losing,long min_val,long max_val,std::string fld_name) {
return check_range_msg(me, id, losing, min_val, max_val, fld_name, "");
}
// TODO: I have two functions that do this. (The other one is choose_graphic.)
static bool pick_picture(ePicType type, cDialog& parent, std::string result_fld, std::string pic_fld){
pic_num_t cur_sel = 0;
if(result_fld != ""){
cControl& fld_ctrl = parent[result_fld];
cur_sel = fld_ctrl.getTextAsNum();
}else if(pic_fld != ""){
cPict& pic_ctrl = dynamic_cast<cPict&>(parent[pic_fld]);
if(pic_ctrl.getPicType() == type)
cur_sel = pic_ctrl.getPicNum();
}
pic_num_t pic = choose_graphic(cur_sel, type, &parent);
if(pic != NO_PIC){
if(result_fld != ""){
cTextField& fld_ctrl = dynamic_cast<cTextField&>(parent[result_fld]);
fld_ctrl.setTextToNum(pic);
}
if(pic_fld != ""){
cPict& pic_ctrl = dynamic_cast<cPict&>(parent[pic_fld]);
if(type == PIC_TER_ANIM && pic < 1000)
pic += 960;
if(type == PIC_ITEM && pic_ctrl.getPicType() == PIC_TINY_ITEM)
type = PIC_TINY_ITEM;
pic_ctrl.setPict(pic,type);
}
}
return true;
}
bool pick_string(std::string from_file, cDialog& parent, std::string result_fld, std::string str_fld){
size_t cur_sel = 0;
if(result_fld != ""){
cTextField& fld_ctrl = dynamic_cast<cTextField&>(parent[result_fld]);
cur_sel = fld_ctrl.getTextAsNum();
}
StringRsrc strings = *ResMgr::get<StringRsrc>(from_file);
// TODO: Does it need a title?
cStringChoice str_dlg(strings, "", &parent);
size_t result = str_dlg.show(cur_sel);
if(result < strings.size()){
if(result_fld != ""){
cTextField& fld_ctrl = dynamic_cast<cTextField&>(parent[result_fld]);
fld_ctrl.setTextToNum(result);
}
if(str_fld != ""){
parent[str_fld].setText(strings[result]);
}
}
return true;
}
static bool show_help(std::string from_file, cDialog& parent, pic_num_t pic){
StringRsrc strings = *ResMgr::get<StringRsrc>(from_file);
cThreeChoice help(strings,basic_buttons[63],pic,PIC_DLOG,&parent);
help.show();
return true;
}
static bool pick_ter_flag(cDialog& me, std::string id, eKeyMod) {
if(id == "editspec") {
int which_type = me["flag2"].getTextAsNum();
if(which_type == 1) {
std::string choice = cChoiceDlog("pick-spec-type", {"town", "out", "cancel"}).show();
if(choice == "cancel") return true;
else if(choice == "town") which_type = 2;
}
short spec = me["flag1"].getTextAsNum();
if(spec < 0)
spec = get_fresh_spec(which_type);
if(edit_spec_enc(spec,which_type,&me))
me["flag1"].setTextToNum(spec);
return true;
} else if(id == "picktrans") {
int i = me["trans"].getTextAsNum();
i = choose_text(STRT_TER, i, &me, "Transform to what terrain?");
me["trans"].setTextToNum(i);
return true;
}
int which = id[8] - '0';
std::string fld = id.substr(4);
int i = me[fld].getTextAsNum();
eTerSpec prop;
cLedGroup& led_ctrl = dynamic_cast<cLedGroup&>(me["prop"]);
std::istringstream sel(led_ctrl.getSelected().substr(4));
sel >> prop;
switch(prop) {
case eTerSpec::NONE:
// TODO: Could have a pick graphic dialog for the editor icon, but that requires adding a new graphic type
return true;
case eTerSpec::CHANGE_WHEN_STEP_ON: case eTerSpec::CHANGE_WHEN_USED:
if(which == 1)
i = choose_text(STRT_TER, i, &me, "Change to what terrain?");
else if(which == 2)
i = choose_text(STRT_SND, i, &me, "Select the sound to play when it changes:");
else return true;
break;
case eTerSpec::DAMAGING:
if(which == 3)
i = choose_damage_type(i, &me);
else return true;
break;
case eTerSpec::DANGEROUS:
if(which == 3)
i = choose_status_effect(i, false, &me);
else return true;
break;
case eTerSpec::BED:
if(which == 1)
i = choose_graphic(i, PIC_TER, &me);
else return true;
break;
case eTerSpec::WATERFALL_CAVE: case eTerSpec::WATERFALL_SURFACE: case eTerSpec::CONVEYOR:
if(which == 1)
i = choose_text(STRT_DIR, i, &me, "Which direction?");
else return true;
break;
case eTerSpec::CRUMBLING: case eTerSpec::LOCKABLE: case eTerSpec::UNLOCKABLE: case eTerSpec::TOWN_ENTRANCE:
if(which == 1)
i = choose_text(STRT_TER, i, &me, prop == eTerSpec::TOWN_ENTRANCE ? "Terrain type when hidden:" : "Terrain to change to:");
else return true;
break;
case eTerSpec::CALL_SPECIAL: case eTerSpec::CALL_SPECIAL_WHEN_USED:
case eTerSpec::UNUSED1: case eTerSpec::UNUSED2: case eTerSpec::UNUSED3:
case eTerSpec::WILDERNESS_CAVE: case eTerSpec::WILDERNESS_SURFACE:
case eTerSpec::BRIDGE: case eTerSpec::IS_A_SIGN: case eTerSpec::IS_A_CONTAINER: case eTerSpec::BLOCKED_TO_MONSTERS:
return true;
}
me[fld].setTextToNum(i);
return true;
}
static bool fill_ter_flag_info(cDialog& me, std::string id, bool losing){
if(losing) return true;
eTerSpec prop;
cLedGroup& led_ctrl = dynamic_cast<cLedGroup&>(me[id]);
std::istringstream sel(led_ctrl.getSelected().substr(4));
sel >> prop;
me["flag1text"].setText(get_str("ter-flag1",int(prop) + 1));
me["flag2text"].setText(get_str("ter-flag2",int(prop) + 1));
me["flag3text"].setText(get_str("ter-flag3",int(prop) + 1));
me["pickflag1"].hide();
me["pickflag2"].hide();
me["pickflag3"].hide();
me["editspec"].hide();
switch(prop) {
case eTerSpec::NONE:
me["pickflag1"].hide(); // TODO: Could have a pick graphic dialog for the editor icon, but that requires adding a new graphic type
break;
case eTerSpec::CHANGE_WHEN_STEP_ON: case eTerSpec::CHANGE_WHEN_USED:
me["pickflag1"].show();
me["pickflag2"].show();
break;
case eTerSpec::DAMAGING: case eTerSpec::DANGEROUS:
me["pickflag3"].show();
break;
case eTerSpec::BED: case eTerSpec::WATERFALL_CAVE: case eTerSpec::WATERFALL_SURFACE: case eTerSpec::CONVEYOR:
case eTerSpec::CRUMBLING: case eTerSpec::LOCKABLE: case eTerSpec::UNLOCKABLE: case eTerSpec::TOWN_ENTRANCE:
me["pickflag1"].show();
break;
case eTerSpec::CALL_SPECIAL: case eTerSpec::CALL_SPECIAL_WHEN_USED:
me["editspec"].show();
break;
case eTerSpec::UNUSED1: case eTerSpec::UNUSED2: case eTerSpec::UNUSED3:
case eTerSpec::WILDERNESS_CAVE: case eTerSpec::WILDERNESS_SURFACE:
case eTerSpec::BRIDGE: case eTerSpec::IS_A_SIGN: case eTerSpec::IS_A_CONTAINER: case eTerSpec::BLOCKED_TO_MONSTERS:
break;
}
return true;
}
static void fill_ter_info(cDialog& me, short ter){
cTerrain& ter_type = scenario.ter_types[ter];
{
cPict& pic_ctrl = dynamic_cast<cPict&>(me["graphic"]);
pic_num_t pic = ter_type.picture;
if(pic < 960)
pic_ctrl.setPict(pic, PIC_TER);
else if(pic < 1000)
pic_ctrl.setPict(pic - 960, PIC_TER_ANIM);
else if(pic < 2000)
pic_ctrl.setPict(pic % 1000, PIC_CUSTOM_TER);
else
pic_ctrl.setPict(pic % 2000, PIC_CUSTOM_TER_ANIM);
me["pict"].setTextToNum(pic);
}{
cPict& pic_ctrl = dynamic_cast<cPict&>(me["seemap"]);
pic_num_t pic = ter_type.map_pic;
if(pic < 1000)
pic_ctrl.setPict(pic, PIC_TER_MAP);
else pic_ctrl.setPict(pic, PIC_CUSTOM_TER_MAP);
me["map"].setTextToNum(pic);
}
me["number"].setTextToNum(ter);
me["name"].setText(ter_type.name);
if(ter_type.shortcut_key > ' ')
me["key"].setText(std::string(1, ter_type.shortcut_key));
else me["key"].setText("");
me["light"].setTextToNum(ter_type.light_radius);
me["trans"].setTextToNum(ter_type.trans_to_what);
me["ground"].setTextToNum(ter_type.ground_type);
me["trimter"].setTextToNum(ter_type.trim_ter);
// TODO: Replace edit text box for trim with a framed name and Select button
me["trim"].setTextToNum((int)ter_type.trim_type);
std::string propid = "prop" + std::to_string((int)ter_type.special);
dynamic_cast<cLedGroup&>(me["prop"]).setSelected(propid);
fill_ter_flag_info(me, "prop", false);
{
cLedGroup& led_ctrl = dynamic_cast<cLedGroup&>(me["blockage"]);
switch(ter_type.blockage){
case eTerObstruct::CLEAR:
led_ctrl.setSelected("clear");
break;
case eTerObstruct::BLOCK_SIGHT:
led_ctrl.setSelected("curtain");
break;
case eTerObstruct::BLOCK_MONSTERS:
led_ctrl.setSelected("special");
break;
case eTerObstruct::BLOCK_MOVE:
led_ctrl.setSelected("window");
break;
case eTerObstruct::BLOCK_MOVE_AND_SHOOT:
led_ctrl.setSelected("obstructed");
break;
case eTerObstruct::BLOCK_MOVE_AND_SIGHT:
led_ctrl.setSelected("opaque");
break;
}
}{
cLedGroup& led_ctrl = dynamic_cast<cLedGroup&>(me["sound"]);
switch(ter_type.step_sound){
case eStepSnd::STEP:
led_ctrl.setSelected("step");
break;
case eStepSnd::SQUISH:
led_ctrl.setSelected("squish");
break;
case eStepSnd::CRUNCH:
led_ctrl.setSelected("crunch");
break;
case eStepSnd::NONE:
led_ctrl.setSelected("nosound");
break;
case eStepSnd::SPLASH:
led_ctrl.setSelected("splash");
break;
}
}
if(ter_type.fly_over){
cLed& led_ctrl = dynamic_cast<cLed&>(me["flight"]);
led_ctrl.setState(led_red);
}
if(ter_type.boat_over){
cLed& led_ctrl = dynamic_cast<cLed&>(me["boat"]);
led_ctrl.setState(led_red);
}
if(ter_type.block_horse){
cLed& led_ctrl = dynamic_cast<cLed&>(me["horse"]);
led_ctrl.setState(led_red);
}
me["flag1"].setTextToNum(ter_type.flag1);
me["flag2"].setTextToNum(ter_type.flag2);
me["flag3"].setTextToNum(ter_type.flag3);
me["arena"].setTextToNum(ter_type.combat_arena);
}
static bool finish_editing_ter(cDialog& me, std::string id, ter_num_t& which) {
if(!save_ter_info(me, scenario.ter_types[which])) return true;
if(!me.toast(true)) return true;
if(id == "left") {
me.untoast();
if(which == 0)
which = scenario.ter_types.size() - 1;
else which--;
fill_ter_info(me, which);
} else if(id == "right") {
me.untoast();
which++;
if(which >= scenario.ter_types.size())
which = 0;
fill_ter_info(me, which);
}
return true;
}
static bool edit_ter_obj(cDialog& me, ter_num_t which_ter) {
cTerrain& ter = scenario.ter_types[which_ter];
const pic_num_t pic = ter.picture;
cDialog obj_dlg("edit-ter-obj", &me);
obj_dlg.attachFocusHandlers([&pic](cDialog& me, std::string fld, bool losing) -> bool {
if(!losing) return true;
int id = me["id"].getTextAsNum();
if(fld != "id") {
int i = me[fld].getTextAsNum();
if(i > 4 || (i == 4 && (fld == "x" || fld == "y"))) {
giveError("Terrain objects cannot be larger than 4x4 tiles.", &me);
return false;
} else if(id > 0 && i == 0 && (fld == "w" || fld == "h")) {
giveError("Width and height cannot be zero.", &me);
return false;
}
} else {
// Check if the object already exists and, if so, import the size data
for(cTerrain& check : scenario.ter_types) {
if(check.obj_num == id) {
me["w"].setTextToNum(check.obj_size.x);
me["h"].setTextToNum(check.obj_size.y);
break;
}
}
}
pic_num_t obj[4][4] = {{74,74,74,74},{74,74,74,74},{74,74,74,74},{74,74,74,74}};
for(cTerrain& check : scenario.ter_types) {
if(check.obj_num != id) continue;
obj[check.obj_pos.x][check.obj_pos.y] = check.picture;
}
obj[me["x"].getTextAsNum()][me["y"].getTextAsNum()] = pic;
for(int x = 0; x < 4; x++) {
for(int y = 0; y < 4; y++) {
std::string id = "x" + std::to_string(x) + "y" + std::to_string(y);
dynamic_cast<cPict&>(me[id]).setPict(obj[x][y]);
}
}
return true;
}, {"w", "h", "x", "y", "id"});
obj_dlg["okay"].attachClickHandler([](cDialog& me, std::string, eKeyMod) -> bool {
if(!me.toast(true)) return true;
int x = me["x"].getTextAsNum(), y = me["y"].getTextAsNum();
int w = me["w"].getTextAsNum(), h = me["h"].getTextAsNum();
if(x >= w || y >= h) {
giveError("X and Y must be less than width and height, respectively.", &me);
me.untoast();
return true;
}
return true;
});
obj_dlg["cancel"].attachClickHandler(std::bind(&cDialog::toast, &obj_dlg, false));
obj_dlg["w"].setTextToNum(ter.obj_size.x);
obj_dlg["h"].setTextToNum(ter.obj_size.y);
obj_dlg["x"].setTextToNum(ter.obj_pos.x);
obj_dlg["y"].setTextToNum(ter.obj_pos.y);
obj_dlg["id"].setTextToNum(ter.obj_num);
obj_dlg["id"].triggerFocusHandler(obj_dlg, "w", true);
obj_dlg.run();
if(obj_dlg.accepted()) {
ter.obj_num = obj_dlg["id"].getTextAsNum();
ter.obj_pos.x = obj_dlg["x"].getTextAsNum();
ter.obj_pos.y = obj_dlg["y"].getTextAsNum();
ter.obj_size.x = obj_dlg["w"].getTextAsNum();
ter.obj_size.y = obj_dlg["h"].getTextAsNum();
// If you changed the size, propagate it to other terrains in the same object.
// If the position is the same as an existing terrain in that object, remove that terrain from the object.
for(cTerrain update : scenario.ter_types) {
if(update.obj_num == ter.obj_num) {
if(update.obj_pos == ter.obj_pos) {
update.obj_pos = update.obj_size = loc();
update.obj_num = 0;
} else {
update.obj_size = ter.obj_size;
}
}
}
}
return true;
}
void edit_ter_type(ter_num_t which) {
using namespace std::placeholders;
cDialog ter_dlg("edit-terrain");
// Attach handlers
ter_dlg["pict"].attachFocusHandler(std::bind(check_range,_1,_2,_3,0,2999,"terrain graphic"));
ter_dlg["pickpict"].attachClickHandler(std::bind(pick_picture,PIC_TER,_1,"pict","graphic"));
ter_dlg["pickanim"].attachClickHandler(std::bind(pick_picture,PIC_TER_ANIM,_1,"pict","graphic"));
ter_dlg["light"].attachFocusHandler(std::bind(check_range,_1,_2,_3,0,10,"light radius"));
ter_dlg["trans"].attachFocusHandler(std::bind(check_range,_1,_2,_3,0,scenario.ter_types.size() - 1,"\"transform to what?\""));
ter_dlg["ground"].attachFocusHandler(std::bind(check_range,_1,_2,_3,0,255,"ground type"));
ter_dlg["trimter"].attachFocusHandler(std::bind(check_range,_1,_2,_3,0,scenario.ter_types.size() - 1,"trim terrain"));
ter_dlg["trim"].attachFocusHandler(std::bind(check_range,_1,_2,_3,0,18,"trim type"));
ter_dlg["prop"].attachFocusHandler(fill_ter_flag_info);
ter_dlg["cancel"].attachClickHandler(std::bind(&cDialog::toast, &ter_dlg, false));
ter_dlg["arena"].attachFocusHandler(std::bind(check_range,_1,_2,_3,0,999 + scenario.towns.size(),"combat areana"));
// TODO: Add focus handler for key
ter_dlg["object"].attachClickHandler(std::bind(edit_ter_obj, _1, std::ref(which)));
ter_dlg.attachClickHandlers(std::bind(finish_editing_ter,_1,_2,std::ref(which)), {"left", "right", "done"});
ter_dlg["picktrim"].attachClickHandler(std::bind(pick_string,"trim-names", _1, "trim", ""));
ter_dlg["pickarena"].attachClickHandler(std::bind(pick_string,"arena-names", _1, "arena", ""));
ter_dlg["help"].attachClickHandler(std::bind(show_help, "ter-type-help", _1, 16));
ter_dlg.attachClickHandlers(pick_ter_flag, {"pickflag1", "pickflag2", "pickflag3", "editspec", "picktrans"});
ter_dlg["picktown"].attachClickHandler([](cDialog& me, std::string, eKeyMod) -> bool {
int i = me["arena"].getTextAsNum();
if(i < 1000) i = -1; else i -= 1000;
i = choose_text(STRT_TOWN, i, &me, "Select a town to base the combat arena on:");
if(i >= 0) me["arena"].setTextToNum(i + 1000);
return true;
});
fill_ter_info(ter_dlg,which);
ter_dlg.run();
}
static void put_monst_info_in_dlog(cDialog& me, cMonster& monst, mon_num_t which) {
std::ostringstream strb;
if(monst.picture_num < 1000)
dynamic_cast<cPict&>(me["icon"]).setPict(monst.picture_num,PIC_MONST);
else {
ePicType type_g = PIC_CUSTOM_MONST;
short size_g = monst.picture_num / 1000;
switch(size_g){
case 2:
type_g += PIC_WIDE;
break;
case 3:
type_g += PIC_TALL;
break;
case 4:
type_g += PIC_LARGE;
break;
}
dynamic_cast<cPict&>(me["icon"]).setPict(monst.picture_num,type_g);
}
dynamic_cast<cPict&>(me["talkpic"]).setPict(monst.default_facial_pic, PIC_TALK);
me["num"].setTextToNum(which);
me["name"].setText(monst.m_name);
me["pic"].setTextToNum(monst.picture_num);
strb << "Width = " << int(monst.x_width);
me["w"].setText(strb.str());
strb.str("");
strb << "Height = " << int(monst.y_width);
me["h"].setText(strb.str());
me["level"].setTextToNum(monst.level);
me["health"].setTextToNum(monst.m_health);
me["armor"].setTextToNum(monst.armor);
me["skill"].setTextToNum(monst.skill);
me["speed"].setTextToNum(monst.speed);
me["mage"].setTextToNum(monst.mu);
me["priest"].setTextToNum(monst.cl);
me["dice1"].setTextToNum(monst.a[0].dice);
me["sides1"].setTextToNum(monst.a[0].sides);
me["dice2"].setTextToNum(monst.a[1].dice);
me["sides2"].setTextToNum(monst.a[1].sides);
me["dice3"].setTextToNum(monst.a[2].dice);
me["sides3"].setTextToNum(monst.a[2].sides);
me["talk"].setTextToNum(short(monst.default_facial_pic));
me["treas"].setTextToNum(monst.treasure);
cLedGroup& attitude = dynamic_cast<cLedGroup&>(me["attitude"]);
switch(monst.default_attitude) {
case 0:
attitude.setSelected("docile");
break;
case 1:
attitude.setSelected("A");
break;
case 2:
attitude.setSelected("friendly");
break;
case 3:
attitude.setSelected("B");
break;
}
me["type"].setText(get_str("traits",35 + int(monst.m_type) * 2));
me["type1"].setText(get_str("monster-abilities",130 + int(monst.a[0].type)));
me["type2"].setText(get_str("monster-abilities",130 + int(monst.a[1].type)));
me["type3"].setText(get_str("monster-abilities",130 + int(monst.a[2].type)));
// Summoning!
std::vector<eSpell> summoned_by;
// General summon spells
switch(monst.summon_type) {
case 1: summoned_by.push_back(eSpell::SUMMON_BEAST); summoned_by.push_back(eSpell::SUMMON_WEAK); break;
case 2: summoned_by.push_back(eSpell::SUMMON); break;
case 3: summoned_by.push_back(eSpell::SUMMON_MAJOR); break;
}
// Special summon spells
switch(which) {
case 85: summoned_by.push_back(eSpell::DEMON); break;
case 80: summoned_by.push_back(eSpell::SUMMON_RAT); break;
case 125: summoned_by.push_back(eSpell::SUMMON_SPIRIT); // deliberate fallthrough
case 126: summoned_by.push_back(eSpell::SUMMON_HOST); break;
case 99: case 100: summoned_by.push_back(eSpell::STICKS_TO_SNAKES); break;
case 122: summoned_by.push_back(eSpell::SUMMON_GUARDIAN); break;
}
strb.str("");
bool first = true;
if(summoned_by.empty())
strb << "None";
else for(eSpell spell : summoned_by) {
if(!first) strb << ", ";
first = false;
strb << (*spell).name();
}
me["summons"].setText(strb.str());
}
static bool check_monst_pic(cDialog& me, std::string id, bool losing, cMonster& monst) {
if(!losing) return true;
static size_t max_preset = m_pic_index.size() - 1;
static const std::string error = "Non-customized monster pic must be from 0 to " + std::to_string(max_preset) + ".";
if(check_range(me, id, losing, 0, 4999, "Monster pic")) {
pic_num_t pic = me[id].getTextAsNum();
monst.picture_num = pic;
cPict& icon = dynamic_cast<cPict&>(me["icon"]);
switch(pic / 1000) {
case 0:
if(cre(pic,0,max_preset,error,"",&me)) return false;
monst.x_width = m_pic_index[monst.picture_num].x;
monst.y_width = m_pic_index[monst.picture_num].y;
icon.setPict(pic, PIC_MONST);
break;
case 1:
monst.x_width = 1;
monst.y_width = 1;
icon.setPict(pic, PIC_MONST);
break;
case 2:
monst.x_width = 2;
monst.y_width = 1;
icon.setPict(pic, PIC_MONST_WIDE);
break;
case 3:
monst.x_width = 1;
monst.y_width = 2;
icon.setPict(pic, PIC_MONST_TALL);
break;
case 4:
monst.x_width = 2;
monst.y_width = 2;
icon.setPict(pic, PIC_MONST_LG);
break;
}
std::ostringstream strb;
strb << "Width = " << int(monst.x_width);
me["w"].setText(strb.str());
strb.str("");
strb << "Height = " << int(monst.y_width);
me["h"].setText(strb.str());
}
return true;
}
static bool save_monst_info(cDialog& me, cMonster& monst) {
monst.m_name = me["name"].getText();
monst.picture_num = me["pic"].getTextAsNum();
monst.level = me["level"].getTextAsNum();
monst.m_health = me["health"].getTextAsNum();
monst.armor = me["armor"].getTextAsNum();
monst.skill = me["skill"].getTextAsNum();
monst.speed = me["speed"].getTextAsNum();
monst.mu = me["mage"].getTextAsNum();
monst.cl = me["priest"].getTextAsNum();
monst.a[0].dice = me["dice1"].getTextAsNum();
monst.a[1].dice = me["dice2"].getTextAsNum();
monst.a[2].dice = me["dice3"].getTextAsNum();
monst.a[0].sides = me["sides1"].getTextAsNum();
monst.a[1].sides = me["sides2"].getTextAsNum();
monst.a[2].sides = me["sides3"].getTextAsNum();
monst.default_facial_pic = me["talk"].getTextAsNum();
monst.treasure = me["treas"].getTextAsNum();
std::string def_att = dynamic_cast<cLedGroup&>(me["attitude"]).getSelected();
if(def_att == "docile") monst.default_attitude = 0;
else if(def_att == "friendly") monst.default_attitude = 2;
else if(def_att == "A") monst.default_attitude = 1;
else if(def_att == "B") monst.default_attitude = 3;
return true;
}
static bool edit_monst_type_event_filter(cDialog& me,std::string hit,cMonster& monst,short& which) {
short i;
cMonster temp_monst;
if(hit == "okay") {
if(save_monst_info(me,monst)) {
scenario.scen_monsters[which] = monst;
me.toast(true);
}
} else if(hit == "abils") {
if(!save_monst_info(me,monst)) return false;
temp_monst = edit_monst_abil(monst,which,me);
if(temp_monst.level < 255)
monst = temp_monst;
put_monst_info_in_dlog(me,monst,which);
} else if(hit == "left") {
if(!save_monst_info(me,monst)) return false;
scenario.scen_monsters[which] = monst;
which--;
// TODO: Use size() once scen_monsters becomes a vector
if(which < 1) which = 255;
monst = scenario.scen_monsters[which];
put_monst_info_in_dlog(me,monst,which);
} else if(hit == "right") {
if(!save_monst_info(me,monst)) return false;
scenario.scen_monsters[which] = monst;
which++;
if(which > 255) which = 1;
monst = scenario.scen_monsters[which];
put_monst_info_in_dlog(me,monst,which);
} else if(hit == "picktype") {
if(!save_monst_info(me,monst)) return false;
i = choose_text(STRT_RACE,int(monst.m_type),&me,"Choose Monster Type:");
if(i >= 0) {
monst.m_type = (eRace) i;
put_monst_info_in_dlog(me,monst,which);
}
} else if(hit == "picktype1") {
if(!save_monst_info(me,monst)) return false;
i = choose_text_res("monster-abilities",130,139,int(monst.a[0].type),&me,"Choose Attack 1 Type:");
if(i >= 0) {
monst.a[0].type = eMonstMelee(i);
put_monst_info_in_dlog(me,monst,which);
}
} else if(hit == "picktype2") {
if(!save_monst_info(me,monst)) return false;
i = choose_text_res("monster-abilities",130,139,int(monst.a[1].type),&me,"Choose Attack 2 & 3 Type:");
if(i >= 0) {
monst.a[1].type = monst.a[2].type = eMonstMelee(i);
put_monst_info_in_dlog(me,monst,which);
}
} else if(hit == "picktype3") {
if(!save_monst_info(me,monst)) return false;
i = choose_text_res("monster-abilities",130,139,int(monst.a[2].type),&me,"Choose Attack 3 Type:");
if(i >= 0) {
monst.a[2].type = eMonstMelee(i);
put_monst_info_in_dlog(me,monst,which);
}
}
return true;
}
static bool check_monst_dice(cDialog& me, std::string fld, bool losing) {
if(fld[0] == 'd') return check_range_msg(me, fld, losing, 0, 20, "attack number of dice", "0 means no attack");
char dice[] = {'d', 'i', 'c', 'e', fld.back(), 0};
if(me[dice].getTextAsNum() == 0) return true;
return check_range(me, fld, losing, 1, 50, "attack damage per die");
}
static bool pick_monst_picture(cDialog& me) {
bool result = pick_picture(PIC_MONST, me, "pic", "icon");
me["pic"].triggerFocusHandler(me, "pic", true);
return result;
}
short edit_monst_type(short which) {
using namespace std::placeholders;
cMonster monst = scenario.scen_monsters[which];
cDialog monst_dlg("edit-monster");
monst_dlg["pickicon"].attachClickHandler(std::bind(pick_monst_picture,_1));
monst_dlg["picktalk"].attachClickHandler(std::bind(pick_picture,PIC_TALK,_1,"talk","talkpic"));
monst_dlg["cancel"].attachClickHandler(std::bind(&cDialog::toast, &monst_dlg, false));
monst_dlg["pic"].attachFocusHandler(std::bind(check_monst_pic, _1, _2, _3, std::ref(monst)));
monst_dlg["level"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 40, "level"));
monst_dlg["health"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 2500, "health"));
monst_dlg["armor"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 50, "armor"));
monst_dlg["skill"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 40, "skill"));
monst_dlg["speed"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 2, 12, "speed"));
monst_dlg["mage"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 7, "magic spells"));
monst_dlg["priest"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 7, "priest spells"));
monst_dlg["treas"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 4, "treasure"));
monst_dlg.attachFocusHandlers(check_monst_dice,{"dice1","dice2","dice3","sides1","sides2","sides3"});
monst_dlg.attachClickHandlers(std::bind(edit_monst_type_event_filter,_1,_2,std::ref(monst),std::ref(which)),{"okay","abils","left","right","picktype","picktype1","picktype2","picktype3"});
put_monst_info_in_dlog(monst_dlg, monst, which);
monst_dlg.run();
return 0;
}
static void put_monst_abils_in_dlog(cDialog& me, cMonster& monst) {
me["loot-item"].setTextToNum(monst.corpse_item);
me["loot-chance"].setTextToNum(monst.corpse_item_chance);
me["magic-res"].setTextToNum(monst.magic_res);
me["fire-res"].setTextToNum(monst.fire_res);
me["cold-res"].setTextToNum(monst.cold_res);
me["poison-res"].setTextToNum(monst.poison_res);
me["onsee"].setTextToNum(monst.see_spec);
me["snd"].setTextToNum(monst.ambient_sound);
if(monst.mindless)
dynamic_cast<cLed&>(me["mindless"]).setState(led_red);
if(monst.invuln)
dynamic_cast<cLed&>(me["invuln"]).setState(led_red);
if(monst.invisible)
dynamic_cast<cLed&>(me["invis"]).setState(led_red);
if(monst.guard)
dynamic_cast<cLed&>(me["guard"]).setState(led_red);
dynamic_cast<cLedGroup&>(me["summon"]).setSelected("s" + boost::lexical_cast<std::string,short>(monst.summon_type));
cStack& abils = dynamic_cast<cStack&>(me["abils"]);
abils.setPageCount(0); // This clears out any data still in the stack
abils.setPageCount(1);
int i = 0;
for(auto& abil : monst.abil) {
if(!abil.second.active) continue;
std::string id = std::to_string((i % 4) + 1);
if(i % 4 == 0) {
abils.setPage(i / 4);
for(int j = 0; j < 4; j++) {
std::string id = std::to_string(j + 1);
me["abil-name" + id].setText("");
me["abil-edit" + id].setText("Add");
}
} else if(i % 4 == 3) abils.addPage();
me["abil-name" + id].setText(abil.second.to_string(abil.first));
me["abil-edit" + id].setText("Edit");
i++;
}
if(i % 4 == 0) {
abils.setPage(i / 4);
for(int j = 0; j < 4; j++) {
std::string id = std::to_string(j + 1);
me["abil-name" + id].setText("");
me["abil-edit" + id].setText("Add");
}
}
abils.setPage(0);
if(abils.getPageCount() <= 1) {
me["abil-up"].hide();
me["abil-down"].hide();
} else {
me["abil-up"].show();
me["abil-down"].show();
}
}
static bool save_monst_abils(cDialog& me, cMonster& monst) {
monst.summon_type = boost::lexical_cast<short>(dynamic_cast<cLedGroup&>(me["summon"]).getSelected().substr(1));
monst.corpse_item = me["loot-item"].getTextAsNum();
monst.corpse_item_chance = me["loot-chance"].getTextAsNum();
monst.magic_res = me["magic-res"].getTextAsNum();
monst.fire_res = me["fire-res"].getTextAsNum();
monst.cold_res = me["cold-res"].getTextAsNum();
monst.poison_res = me["poison-res"].getTextAsNum();
monst.see_spec = me["onsee"].getTextAsNum();
monst.ambient_sound = me["snd"].getTextAsNum();
monst.mindless = dynamic_cast<cLed&>(me["mindless"]).getState() != led_off;
monst.invuln = dynamic_cast<cLed&>(me["invuln"]).getState() != led_off;
monst.invisible = dynamic_cast<cLed&>(me["invis"]).getState() != led_off;
monst.guard = dynamic_cast<cLed&>(me["guard"]).getState() != led_off;
return true;
}
static bool edit_monst_abil_event_filter(cDialog& me,std::string hit,cMonster& monst) {
using namespace std::placeholders;
if(hit == "cancel") {
monst.level = 255;
me.toast(false);
} else if(hit == "okay") {
if(save_monst_abils(me, monst))
me.toast(true);
} else if(hit == "abil-up") {
cStack& abils = dynamic_cast<cStack&>(me["abils"]);
if(abils.getPage() == 0) abils.setPage(abils.getPageCount() - 1);
else abils.setPage(abils.getPage() - 1);
} else if(hit == "abil-down") {
cStack& abils = dynamic_cast<cStack&>(me["abils"]);
if(abils.getPage() >= abils.getPageCount() - 1) abils.setPage(0);
else abils.setPage(abils.getPage() + 1);
} else if(hit == "edit-see") {
short spec = me["onsee"].getTextAsNum();
if(spec < 0)
spec = get_fresh_spec(0);
if(edit_spec_enc(spec,0,&me))
me["onsee"].setTextToNum(spec);
} else if(hit == "pick-snd") {
int i = me["snd"].getTextAsNum();
i = choose_text(STRT_SND, i, &me, "Select monster vocalization sound:");
me["snd"].setTextToNum(i);
}
return true;
}
static short get_monst_abil_num(std::string prompt, int min, int max, cDialog& parent, int cur = -1) {
cDialog numPanel("get-mabil-num", &parent);
numPanel["okay"].attachClickHandler(std::bind(&cDialog::toast, &numPanel, false));
numPanel["prompt"].setText(prompt + " (" + std::to_string(min) + "-" + std::to_string(max) + ") ");
numPanel["number"].setTextToNum(minmax(min,max,cur));
numPanel.run();
int result = numPanel["number"].getTextAsNum();
if(result < min) return min;
if(result > max) return max;
return result;
}
static void fill_monst_abil_detail(cDialog& me, cMonster& monst, eMonstAbil abil, uAbility detail) {
eMonstAbilCat cat = getMonstAbilCategory(abil);
me["monst"].setText(monst.m_name);
me["name"].setText(detail.to_string(abil));
// These names start at line 80 in the strings file, but the first valid ability is ID 1, so add 79.
me["type"].setText(get_str("monster-abilities", 79 + int(abil)));
// Action points
if(cat == eMonstAbilCat::MISSILE) {
if(detail.missile.type == eMonstMissile::ARROW || detail.missile.type == eMonstMissile::BOLT || detail.missile.type == eMonstMissile::SPINE)
me["ap"].setTextToNum(3);
else me["ap"].setTextToNum(2);
} else if(cat == eMonstAbilCat::GENERAL) {
if(detail.gen.type == eMonstGen::TOUCH)
me["ap"].setText("0 (part of standard attack)");
else if(abil == eMonstAbil::DAMAGE2)
me["ap"].setTextToNum(4);
else me["ap"].setTextToNum(3);
} else if(abil == eMonstAbil::RAY_HEAT)
me["ap"].setTextToNum(1);
else if(abil == eMonstAbil::MISSILE_WEB)
me["ap"].setTextToNum(3);
else if(abil == eMonstAbil::SPECIAL)
me["ap"].setTextToNum(detail.special.extra2);
else if(cat == eMonstAbilCat::SPECIAL)
me["ap"].setText("0 (passive ability)");
// Subtype
if(cat == eMonstAbilCat::MISSILE)
me["subtype"].setText(get_str("monster-abilities", 110 + int(detail.missile.type)));
else if(cat == eMonstAbilCat::GENERAL)
me["subtype"].setText(get_str("monster-abilities", 120 + int(detail.gen.type)));
else if(cat == eMonstAbilCat::SUMMON)
me["subtype"].setText(get_str("monster-abilities", 150 + int(detail.summon.type)));
// Missile and range
if(cat == eMonstAbilCat::MISSILE || cat == eMonstAbilCat::GENERAL) {
if(cat == eMonstAbilCat::GENERAL && detail.gen.type == eMonstGen::TOUCH) {
me["missile"].hide();
me["pick-missile"].hide();
me["missile-pic"].hide();
me["missile-touch"].show();
me["range"].hide();
me["range-touch"].show();
} else {
me["missile"].show();
me["pick-missile"].show();
me["missile-pic"].show();
me["missile-touch"].hide();
me["range"].show();
me["range-touch"].hide();
}
miss_num_t missile;
int range;
if(cat == eMonstAbilCat::GENERAL) {
missile = detail.gen.pic;
range = detail.gen.range;
} else {
missile = detail.missile.pic;
range = detail.missile.range;
}
me["missile"].setTextToNum(missile);
dynamic_cast<cPict&>(me["missile-pic"]).setPict(missile, PIC_MISSILE);
me["range"].setTextToNum(range);
}
// Chance
if(cat != eMonstAbilCat::SPECIAL) {
int odds = 0;
if(cat == eMonstAbilCat::MISSILE) odds = detail.missile.odds;
else if(cat == eMonstAbilCat::GENERAL) odds = detail.gen.odds;
else if(cat == eMonstAbilCat::SUMMON) odds = detail.summon.chance;
else if(cat == eMonstAbilCat::RADIATE) odds = detail.radiate.chance;
me["odds"].setTextToNum(odds);
}
// Field type
if(cat == eMonstAbilCat::RADIATE || abil == eMonstAbil::FIELD) {
if(abil == eMonstAbil::FIELD)
me["extra"].setTextToNum(int(detail.gen.fld));
else me["field"].setTextToNum(int(detail.radiate.type));
}
// Other type-specific fields
if(cat == eMonstAbilCat::MISSILE) {
me["dice"].setTextToNum(detail.missile.dice);
me["sides"].setTextToNum(detail.missile.sides);
me["skill"].setTextToNum(detail.missile.skill);
} else if(cat == eMonstAbilCat::GENERAL) {
me["strength"].setTextToNum(detail.gen.strength);
bool haveExtra = false;
cControl& title = me["extra-title"];
cControl& field = me["extra"];
cControl& pick = me["pick-extra"];
if(abil == eMonstAbil::FIELD) {
haveExtra = true;
title.setText("Field Type:");
field.setTextToNum(int(detail.gen.fld));
} else if(abil == eMonstAbil::DAMAGE || abil == eMonstAbil::DAMAGE2) {
haveExtra = true;
title.setText("Damage Type:");
field.setTextToNum(int(detail.gen.dmg));
} else if(abil == eMonstAbil::STATUS || abil == eMonstAbil::STATUS2 || abil == eMonstAbil::STUN) {
haveExtra = true;
title.setText("Status Effect:");
field.setTextToNum(int(detail.gen.stat));
}
if(haveExtra)
title.show(), field.show(), pick.show();
else title.hide(), field.hide(), pick.hide();
} else if(cat == eMonstAbilCat::SUMMON) {
switch(detail.summon.type) {
case eMonstSummon::TYPE: me["summon"].setText(scenario.scen_monsters[detail.summon.what].m_name); break;
case eMonstSummon::LEVEL: me["summon"].setTextToNum(detail.summon.what); break;
case eMonstSummon::SPECIES: me["summon"].setText(get_str("traits", detail.summon.what * 2 + 35)); break;
}
me["max"].setTextToNum(detail.summon.max);
me["min"].setTextToNum(detail.summon.min);
me["len"].setTextToNum(detail.summon.len);
} else if(cat == eMonstAbilCat::SPECIAL) {
me["extra1"].setTextToNum(detail.special.extra1);
me["extra2"].setTextToNum(detail.special.extra2);
me["extra3"].setTextToNum(detail.special.extra3);
}
}
static void save_monst_abil_detail(cDialog& me, eMonstAbil abil, uAbility& detail) {
eMonstAbilCat cat = getMonstAbilCategory(abil);
if(cat == eMonstAbilCat::MISSILE) {
detail.missile.pic = me["missile"].getTextAsNum();
detail.missile.dice = me["dice"].getTextAsNum();
detail.missile.sides = me["sides"].getTextAsNum();
detail.missile.range = me["range"].getTextAsNum();
detail.missile.odds = me["odds"].getTextAsNum();
detail.missile.skill = me["skill"].getTextAsNum();
} else if(cat == eMonstAbilCat::GENERAL) {
detail.gen.pic = me["missile"].getTextAsNum();
detail.gen.strength = me["strength"].getTextAsNum();
detail.gen.range = me["range"].getTextAsNum();
detail.gen.odds = me["odds"].getTextAsNum();
} else if(cat == eMonstAbilCat::SUMMON) {
detail.summon.max = me["max"].getTextAsNum();
detail.summon.min = me["min"].getTextAsNum();
detail.summon.len = me["len"].getTextAsNum();
detail.summon.chance = me["odds"].getTextAsNum();
} else if(cat == eMonstAbilCat::RADIATE) {
detail.radiate.chance = me["odds"].getTextAsNum();
} else if(cat == eMonstAbilCat::SPECIAL) {
detail.special.extra1 = me["extra1"].getTextAsNum();
detail.special.extra2 = me["extra2"].getTextAsNum();
detail.special.extra3 = me["extra3"].getTextAsNum();
}
}
static bool edit_monst_abil_detail(cDialog& me, std::string hit, cMonster& monst) {
eMonstAbil abil;
uAbility abil_params;
std::map<eMonstAbil,uAbility>::iterator iter;
if(me[hit].getText() == "Add") {
int i = choose_text_res("monster-abilities", 1, 70, 0, &me, "Select an ability to add.");
if(i < 0) return true;
eMonstAbilTemplate tmpl = eMonstAbilTemplate(i);
int param = 0;
switch(tmpl) {
case eMonstAbilTemplate::RADIATE_FIRE:
case eMonstAbilTemplate::RADIATE_ICE:
case eMonstAbilTemplate::RADIATE_SHOCK:
case eMonstAbilTemplate::RADIATE_ANTIMAGIC:
case eMonstAbilTemplate::RADIATE_SLEEP:
case eMonstAbilTemplate::RADIATE_STINK:
case eMonstAbilTemplate::RADIATE_BLADE:
case eMonstAbilTemplate::RADIATE_WEB:
param = get_monst_abil_num("Percentage chance of radiating:", 0, 100, me);
break;
case eMonstAbilTemplate::SUMMON_5:
case eMonstAbilTemplate::SUMMON_20:
case eMonstAbilTemplate::SUMMON_50:
param = choose_text(STRT_MONST, 0, &me, "Summon which monster?");
break;
case eMonstAbilTemplate::SPECIAL:
case eMonstAbilTemplate::HIT_TRIGGERS:
case eMonstAbilTemplate::DEATH_TRIGGERS:
param = get_fresh_spec(0);
if(!edit_spec_enc(param,0,&me))
return true;
break;
case eMonstAbilTemplate::TOUCH_POISON:
param = get_monst_abil_num("Poison strength:", 0, 8, me);
break;
case eMonstAbilTemplate::BREATH_FIRE:
case eMonstAbilTemplate::BREATH_FROST:
case eMonstAbilTemplate::BREATH_ELECTRICITY:
case eMonstAbilTemplate::BREATH_DARKNESS:
param = get_monst_abil_num("Breath weapon strength:", 0, 4, me);
break;
default: break; // None of the other templates take parameters
}
// Protect from overwriting an existing ability.
auto save_abils = monst.abil;
iter = monst.addAbil(tmpl, param);
// Normally it'll never return end(), but if a new template was added and not implemented, it would.
if(iter == monst.abil.end()) {
giveError("Failed to add the new ability. When reporting this, mention which ability you tried to add.", &me);
return true;
}
if(save_abils.find(iter->first) != save_abils.end() && save_abils[iter->first].active) {
// TODO: Warn about overwriting an ability and give a choce between keeping the old or the new
bool overwrite = true;
if(!overwrite) {
monst.abil = save_abils;
return true;
}
}
size_t iShow = std::distance(monst.abil.begin(), iter);
dynamic_cast<cStack&>(me["abils"]).setPage(iShow / 4);
if(tmpl < eMonstAbilTemplate::CUSTOM_MISSILE && tmpl != eMonstAbilTemplate::SPECIAL) {
put_monst_abils_in_dlog(me, monst);
return true;
}
} else {
size_t which = 4 * dynamic_cast<cStack&>(me["abils"]).getPage() + (hit[9] - '1');
iter = monst.abil.begin();
std::advance(iter, which);
}
abil = iter->first;
abil_params = iter->second;
std::string which_dlg = "special";
eMonstAbilCat cat = getMonstAbilCategory(abil);
switch(cat) {
case eMonstAbilCat::MISSILE: which_dlg = "missile"; break;
case eMonstAbilCat::GENERAL: which_dlg = "general"; break;
case eMonstAbilCat::SUMMON: which_dlg = "summon"; break;
case eMonstAbilCat::RADIATE: which_dlg = "radiate"; break;
case eMonstAbilCat::INVALID: return true;
case eMonstAbilCat::SPECIAL: break;
}
using namespace std::placeholders;
cDialog abil_dlg("edit-mabil-" + which_dlg, &me);
abil_dlg["okay"].attachClickHandler(std::bind(&cDialog::toast, _1, true));
abil_dlg["cancel"].attachClickHandler(std::bind(&cDialog::toast, _1, false));
abil_dlg["delete"].attachClickHandler([&monst,iter](cDialog& me,std::string,eKeyMod){
// TODO: Show confirmation first?
return me.toast(false), monst.abil.erase(iter), true;
});
auto onfocus = [&](cDialog& me,std::string,bool losing) -> bool {
if(!losing) return true;
save_monst_abil_detail(me, abil, abil_params);
fill_monst_abil_detail(me, monst, abil, abil_params);
return true;
};
abil_dlg.forEach([&onfocus](std::string, cControl& ctrl){
if(ctrl.getType() == CTRL_FIELD)
ctrl.attachFocusHandler(onfocus);
});
if(cat == eMonstAbilCat::MISSILE || cat == eMonstAbilCat::GENERAL || cat == eMonstAbilCat::SUMMON) {
int first, last;
if(cat == eMonstAbilCat::MISSILE) first = 110, last = 117;
else if(cat == eMonstAbilCat::GENERAL) first = 120, last = 124;
else if(cat == eMonstAbilCat::SUMMON) first = 150, last = 152;
abil_dlg["pick-subtype"].attachClickHandler([&,cat,first,last](cDialog& me,std::string,eKeyMod) -> bool {
save_monst_abil_detail(me, abil, abil_params);
int i = 0;
if(cat == eMonstAbilCat::MISSILE) i = int(abil_params.missile.type);
else if(cat == eMonstAbilCat::GENERAL) i = int(abil_params.gen.type);
else if(cat == eMonstAbilCat::SUMMON) i = int(abil_params.summon.type);
i = choose_text_res("monster-abilities", first, last, i + first, &me, "Select ability subtype:");
if(i < 0) return true;
if(cat == eMonstAbilCat::MISSILE) abil_params.missile.type = eMonstMissile(i);
else if(cat == eMonstAbilCat::GENERAL) abil_params.gen.type = eMonstGen(i);
else if(cat == eMonstAbilCat::SUMMON) abil_params.summon.type = eMonstSummon(i);
fill_monst_abil_detail(me, monst, abil, abil_params);
return true;
});
if(cat != eMonstAbilCat::SUMMON)
abil_dlg["pick-missile"].attachClickHandler(std::bind(pick_picture, PIC_MISSILE, _1, "missile", "missile-pic"));
}
if(cat == eMonstAbilCat::GENERAL) {
abil_dlg["pick-extra"].attachClickHandler([&](cDialog& me,std::string,eKeyMod) -> bool {
save_monst_abil_detail(me, abil, abil_params);
int i = -1;
if(abil == eMonstAbil::FIELD) {
i = int(abil_params.gen.fld);
i = choose_field_type(i, &me, false);
abil_params.gen.fld = eFieldType(i);
} else if(abil == eMonstAbil::DAMAGE || abil == eMonstAbil::DAMAGE2) {
i = int(abil_params.gen.dmg);
i = choose_damage_type(i, &me);
abil_params.gen.dmg = eDamageType(i);
} else if(abil == eMonstAbil::STATUS || abil == eMonstAbil::STATUS2 || abil == eMonstAbil::STUN) {
i = int(abil_params.gen.stat);
i = choose_status_effect(i, false, &me);
abil_params.gen.stat = eStatus(i);
}
fill_monst_abil_detail(me, monst, abil, abil_params);
return true;
});
if(abil == eMonstAbil::FIELD)
abil_dlg["pick-strength"].attachClickHandler([&](cDialog& me,std::string,eKeyMod) -> bool {
save_monst_abil_detail(me, abil, abil_params);
int i = abil_params.gen.strength;
i = choose_text(STRT_SPELL_PAT, i, &me, "Which spell pattern?");
abil_params.gen.strength = i;
fill_monst_abil_detail(me, monst, abil, abil_params);
return true;
});
else abil_dlg["pick-strength"].hide();
} else if(cat == eMonstAbilCat::RADIATE) {
abil_dlg["pick-field"].attachClickHandler([&](cDialog& me,std::string,eKeyMod) -> bool {
save_monst_abil_detail(me, abil, abil_params);
int i = abil_params.radiate.type;
i = choose_field_type(i, &me, false);
abil_params.radiate.type = eFieldType(i);
fill_monst_abil_detail(me, monst, abil, abil_params);
return true;
});
} else if(cat == eMonstAbilCat::SUMMON) {
abil_dlg["pick-summon"].attachClickHandler([&](cDialog& me,std::string,eKeyMod) -> bool {
save_monst_abil_detail(me, abil, abil_params);
int i = abil_params.summon.what;
eStrType type;
switch(abil_params.summon.type) {
case eMonstSummon::TYPE: type = STRT_MONST; break;
case eMonstSummon::LEVEL: type = STRT_SUMMON; break;
case eMonstSummon::SPECIES: type = STRT_RACE; break;
}
i = choose_text(type, i, &me, "Summon what?");
abil_params.summon.what = i;
fill_monst_abil_detail(me, monst, abil, abil_params);
return true;
});
} else if(cat == eMonstAbilCat::SPECIAL) {
if(abil == eMonstAbil::SPECIAL || abil == eMonstAbil::HIT_TRIGGER || abil == eMonstAbil::DEATH_TRIGGER)
abil_dlg["pick-extra1"].attachClickHandler([&](cDialog& me,std::string,eKeyMod) -> bool {
short spec = me["extra1"].getTextAsNum();
if(spec < 0)
spec = get_fresh_spec(0);
if(edit_spec_enc(spec,0,&me))
me["extra1"].setTextToNum(spec);
return true;
});
else abil_dlg["pick-extra1"].hide();
int iStr = int(abil) - int(eMonstAbil::SPLITS);
for(int i = 0; i < 3; i++) {
std::string id = "extra" + std::to_string(i + 1);
std::string title = get_str("monster-abilities", 160 + iStr * 3 + i);
if(title.empty()) {
abil_dlg[id].hide();
abil_dlg[id + "-title"].hide();
} else abil_dlg[id + "-title"].setText(title + ":");
}
}
fill_monst_abil_detail(abil_dlg, monst, abil, abil_params);
abil_dlg.run();
save_monst_abil_detail(abil_dlg, abil, abil_params);
if(abil_dlg.accepted())
iter->second = abil_params;
put_monst_abils_in_dlog(me, monst);
return true;
}
cMonster edit_monst_abil(cMonster initial,short which,cDialog& parent) {
using namespace std::placeholders;
cDialog monst_dlg("edit-monster-abils",&parent);
monst_dlg["loot-item"].attachFocusHandler(std::bind(check_range_msg, _1, _2, _3, -1, 399, "Item To Drop", "-1 for no item"));
monst_dlg["loot-chance"].attachFocusHandler(std::bind(check_range_msg, _1, _2, _3, -1, 100, "Dropping Chance", "-1 for no item"));
monst_dlg.attachClickHandlers(std::bind(edit_monst_abil_detail, _1, _2, std::ref(initial)), {"abil-edit1", "abil-edit2", "abil-edit3", "abil-edit4"});
monst_dlg.attachClickHandlers(std::bind(edit_monst_abil_event_filter, _1, _2, std::ref(initial)), {"okay", "cancel", "abil-up", "abil-down", "edit-see", "pick-snd"});
monst_dlg["num"].setTextToNum(which);
put_monst_abils_in_dlog(monst_dlg, initial);
monst_dlg.run();
return initial;
}
static void put_item_info_in_dlog(cDialog& me, cItem& item, short which) {
me["num"].setTextToNum(which);
me["full"].setText(item.full_name);
me["short"].setText(item.name);
if(item.graphic_num >= 1000) // was 150
dynamic_cast<cPict&>(me["pic"]).setPict(item.graphic_num, PIC_CUSTOM_ITEM);
else dynamic_cast<cPict&>(me["pic"]).setPict(item.graphic_num, PIC_ITEM);
me["picnum"].setTextToNum(item.graphic_num);
bool missile = false, weapon = false;
cLedGroup& variety = dynamic_cast<cLedGroup&>(me["variety"]);
switch(item.variety) {
case eItemType::NO_ITEM:
variety.setSelected("none");
break;
case eItemType::ONE_HANDED:
variety.setSelected("weap1");
weapon = true;
break;
case eItemType::TWO_HANDED:
variety.setSelected("weap2");
weapon = true;
break;
case eItemType::GOLD:
variety.setSelected("gold");
break;
case eItemType::BOW:
variety.setSelected("bow");
weapon = true;
break;
case eItemType::ARROW:
variety.setSelected("arrow");
missile = true;
break;
case eItemType::THROWN_MISSILE:
variety.setSelected("thrown");
missile = true;
weapon = true;
break;
case eItemType::POTION:
variety.setSelected("potion");
break;
case eItemType::SCROLL:
variety.setSelected("scroll");
break;
case eItemType::WAND:
variety.setSelected("wand");
break;
case eItemType::TOOL:
variety.setSelected("tool");
break;
case eItemType::FOOD:
variety.setSelected("food");
break;
case eItemType::SHIELD:
variety.setSelected("shield");
break;
case eItemType::ARMOR:
variety.setSelected("armor");
break;
case eItemType::HELM:
variety.setSelected("helm");
break;
case eItemType::GLOVES:
variety.setSelected("gloves");
break;
case eItemType::SHIELD_2:
variety.setSelected("shield2");
break;
case eItemType::BOOTS:
variety.setSelected("boots");
break;
case eItemType::RING:
variety.setSelected("ring");
break;
case eItemType::NECKLACE:
variety.setSelected("necklace");
break;
case eItemType::WEAPON_POISON:
variety.setSelected("poison");
break;
case eItemType::NON_USE_OBJECT:
variety.setSelected("nonuse");
break;
case eItemType::PANTS:
variety.setSelected("pants");
break;
case eItemType::CROSSBOW:
variety.setSelected("xbow");
weapon = true;
break;
case eItemType::BOLTS:
variety.setSelected("bolt");
missile = true;
break;
case eItemType::MISSILE_NO_AMMO:
variety.setSelected("missile");
missile = true;
weapon = true;
break;
case eItemType::UNUSED1:
variety.setSelected("unused1");
break;
case eItemType::SPECIAL:
variety.setSelected("special");
break;
}
if(missile) {
me["missile"].show();
me["missile-pic"].show();
me["missile-pic"].show();
me["choosemiss"].show();
me["missile"].setTextToNum(item.missile);
dynamic_cast<cPict&>(me["missile-pic"]).setPict(item.missile);
} else {
me["missile"].hide();
me["missile-title"].hide();
me["missile-pic"].hide();
me["choosemiss"].hide();
me["missile"].setText("0");
}
if(weapon) {
me["skill-title"].show();
me["weap-type"].show();
me["choosetp"].show();
me["weap-type"].setTextToNum(int(item.weap_type));
} else {
me["skill-title"].hide();
me["weap-type"].hide();
me["choosetp"].hide();
me["weap-type"].setText("0");
}
me["level"].setTextToNum(item.item_level);
me["awkward"].setTextToNum(item.awkward);
me["bonus"].setTextToNum(item.bonus);
me["prot"].setTextToNum(item.protection);
me["charges"].setTextToNum(item.charges);
me["flag"].setTextToNum(item.type_flag);
me["value"].setTextToNum(item.value);
me["weight"].setTextToNum(item.weight);
me["class"].setTextToNum(item.special_class);
me["abilname"].setText(item.getAbilName());
}
static void save_item_info(cDialog& me, cItem& item) {
item.full_name = me["full"].getText();
item.name = me["short"].getText();
item.graphic_num = me["picnum"].getTextAsNum();
std::string variety = dynamic_cast<cLedGroup&>(me["variety"]).getSelected();
if(variety == "none") item.variety = eItemType::NO_ITEM;
else if(variety == "weap1") item.variety = eItemType::ONE_HANDED;
else if(variety == "weap2") item.variety = eItemType::TWO_HANDED;
else if(variety == "gold") item.variety = eItemType::GOLD;
else if(variety == "bow") item.variety = eItemType::BOW;
else if(variety == "arrow") item.variety = eItemType::ARROW;
else if(variety == "thrown") item.variety = eItemType::THROWN_MISSILE;
else if(variety == "potion") item.variety = eItemType::POTION;
else if(variety == "scroll") item.variety = eItemType::SCROLL;
else if(variety == "wand") item.variety = eItemType::WAND;
else if(variety == "tool") item.variety = eItemType::TOOL;
else if(variety == "food") item.variety = eItemType::FOOD;
else if(variety == "shield") item.variety = eItemType::SHIELD;
else if(variety == "armor") item.variety = eItemType::ARMOR;
else if(variety == "helm") item.variety = eItemType::HELM;
else if(variety == "gloves") item.variety = eItemType::GLOVES;
else if(variety == "shield2") item.variety = eItemType::SHIELD_2;
else if(variety == "boots") item.variety = eItemType::BOOTS;
else if(variety == "ring") item.variety = eItemType::RING;
else if(variety == "necklace") item.variety = eItemType::NECKLACE;
else if(variety == "poison") item.variety = eItemType::WEAPON_POISON;
else if(variety == "nonuse") item.variety = eItemType::NON_USE_OBJECT;
else if(variety == "pants") item.variety = eItemType::PANTS;
else if(variety == "xbow") item.variety = eItemType::CROSSBOW;
else if(variety == "bolt") item.variety = eItemType::BOLTS;
else if(variety == "missile") item.variety = eItemType::MISSILE_NO_AMMO;
else if(variety == "unused1") item.variety = eItemType::UNUSED1;
else if(variety == "special") item.variety = eItemType::SPECIAL;
item.weap_type = eSkill(me["weap-type"].getTextAsNum());
item.missile = me["missile"].getTextAsNum();
item.item_level = me["level"].getTextAsNum();
if((item.variety == eItemType::GOLD || item.variety == eItemType::FOOD) && item.item_level == 0)
item.item_level = 1;
item.awkward = me["awkward"].getTextAsNum();
item.bonus = me["bonus"].getTextAsNum();;
item.protection = me["prot"].getTextAsNum();
item.charges = me["charges"].getTextAsNum();
item.type_flag = me["flag"].getTextAsNum();
item.value = me["value"].getTextAsNum();
item.weight = me["weight"].getTextAsNum();
item.special_class = me["class"].getTextAsNum();
int was_charges = item.charges;
if(item.type_flag > 0 && item.charges == 0)
item.charges = 1;
eItemAbilCat cat = getItemAbilCategory(item.ability);
if((cat == eItemAbilCat::USABLE || cat == eItemAbilCat::REAGENT) && item.charges == 0)
item.charges = 1;
if(was_charges != item.charges)
giveError("Due to either the selected special ability or the presence of a type flag, this item's charges have been set to 1.", &me);
}
static bool edit_item_type_event_filter(cDialog& me, std::string hit, cItem& item, short& which) {
short i;
cItem temp_item;
std::string variety = dynamic_cast<cLedGroup&>(me["variety"]).getSelected();
bool valid = true;
if(variety.substr(0,6) == "unused") valid = false;
if(!valid && hit != "cancel" && hit.substr(0,6) != "choose") {
giveError("The Unused item varieties are reserved for later expansions, and can't be used now.","",&me);
return true;
}
if(hit == "cancel") {
me.toast(false);
} else if(hit == "okay") {
save_item_info(me, item);
if(!me.toast(true)) return true;
scenario.scen_items[which] = item;
} else if(hit == "prev") {
save_item_info(me, item);
scenario.scen_items[which] = item;
which--;
if(which < 0) which = 399;
item = scenario.scen_items[which];
put_item_info_in_dlog(me, item, which);
} else if(hit == "next") {
save_item_info(me, item);
scenario.scen_items[which] = item;
which++;
if(which > 399) which = 0;
item = scenario.scen_items[which];
put_item_info_in_dlog(me, item, which);
} else if(hit == "choosepic") {
save_item_info(me, item);
i = pick_picture(PIC_ITEM, me, "picnum", "pic");
if(i < 0) return true;
item.graphic_num = i;
} else if(hit == "choosetp") {
save_item_info(me, item);
i = choose_text(STRT_SKILL, int(item.weap_type), &me, "Select the weapon's key skill:");
item.weap_type = eSkill(i);
me["weap-type"].setTextToNum(i);
} else if(hit == "choosemiss") {
save_item_info(me, item);
i = pick_picture(PIC_MISSILE, me, "missile", "missile-pic");
if(i < 0) return true;
item.missile = i;
} else if(hit == "desc") {
cDialog desc_dlg("edit-text", &me);
desc_dlg["left"].hide();
desc_dlg["right"].hide();
desc_dlg["okay"].attachClickHandler(std::bind(&cDialog::toast, &desc_dlg, true));
desc_dlg["text"].setText(item.desc);
desc_dlg["num-lbl"].setText(item.full_name);
desc_dlg.run();
item.desc = desc_dlg["text"].getText();
} else if(hit == "abils") {
save_item_info(me, item);
if(item.variety == eItemType::NO_ITEM) {
giveError("You must give the item a type (weapon, armor, etc.) before you can choose its abilities.","",&me);
return true;
}
if(item.variety == eItemType::GOLD || item.variety == eItemType::FOOD || item.variety == eItemType::SPECIAL) {
giveError("Gold, Food, and Special Items cannot be given special abilities.","",&me);
return true;
}
temp_item = edit_item_abil(item,which,me);
if(temp_item.variety != eItemType::NO_ITEM)
item = temp_item;
}
return true;
}
static bool change_item_variety(cDialog& me, std::string group, const cItem& item) {
std::string hit = dynamic_cast<cLedGroup&>(me[group]).getSelected();
if(hit == "arrow" || hit == "thrown" || hit == "bolt" || hit == "missile") {
me["missile"].show();
me["missile-pic"].show();
me["missile-pic"].show();
me["choosemiss"].show();
me["missile"].setTextToNum(item.missile);
dynamic_cast<cPict&>(me["missile-pic"]).setPict(item.missile);
} else {
me["missile"].hide();
me["missile-title"].hide();
me["missile-pic"].hide();
me["choosemiss"].hide();
me["missile"].setText("0");
}
if(hit.substr(0,4) == "weap" || hit == "bow" || hit == "xbow" || hit == "missile" || hit == "thrown") {
me["skill-title"].show();
me["weap-type"].show();
me["choosetp"].show();
me["weap-type"].setTextToNum(int(item.weap_type));
} else {
me["skill-title"].hide();
me["weap-type"].hide();
me["choosetp"].hide();
me["weap-type"].setText("0");
}
return true;
}
short edit_item_type(short which) {
using namespace std::placeholders;
cItem item = scenario.scen_items[which];
cDialog item_dlg("edit-item");
item_dlg["level"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 50, "Item Level"));
item_dlg["awkward"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 20, "Awkward"));
item_dlg["bonus"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 60, "Bonus"));
item_dlg["prot"].attachFocusHandler(std::bind(check_range, _1, _2, _3, -10, 20, "Protection"));
item_dlg["charges"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 100, "Charges"));
item_dlg["flag"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 1000, "Type Flag"));
item_dlg["value"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 10000, "Value"));
item_dlg["weight"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 250, "Weight"));
item_dlg["class"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 100, "Special Class"));
item_dlg["variety"].attachFocusHandler(std::bind(change_item_variety, _1, _2, std::ref(item)));
item_dlg.attachClickHandlers(std::bind(edit_item_type_event_filter, _1, _2, std::ref(item), std::ref(which)), {"okay", "cancel", "prev", "next", "abils", "choosepic", "choosetp", "choosemiss", "desc"});
put_item_info_in_dlog(item_dlg, item, which);
item_dlg.run();
return 0;
}
static void put_item_abils_in_dlog(cDialog& me, cItem& item, short which) {
me["num"].setTextToNum(which);
me["name"].setText(item.full_name.c_str());
me["variety"].setText(get_str("item-types", int(item.variety) + 1));
if(item.ability == eItemAbil::NONE)
me["abilname"].setText("No ability");
else me["abilname"].setText(get_str("item-abilities", int(item.ability)));
dynamic_cast<cLedGroup&>(me["use-type"]).setSelected("use" + std::to_string(int(item.magic_use_type)));
dynamic_cast<cLedGroup&>(me["treasure"]).setSelected("type" + std::to_string(item.treas_class));
me["str1"].setTextToNum(item.abil_data[0]);
me["str2"].setTextToNum(item.abil_data[1]);
if(item.ability == eItemAbil::CALL_SPECIAL || item.ability == eItemAbil::WEAPON_CALL_SPECIAL || item.ability == eItemAbil::HIT_CALL_SPECIAL) {
me["str1-choose"].show();
me["str1-title"].setText("Special to call");
} else {
me["str1-choose"].hide();
if(getItemAbilCategory(item.ability) == eItemAbilCat::REAGENT || items_no_strength.count(item.ability) > 0)
me["str1-title"].setText("Unused");
else me["str1-title"].setText("Ability strength");
}
me["str2-choose1"].show();
me["str2-choose1"].setText("Choose");
me["str2-choose2"].hide();
switch(item.ability) {
case eItemAbil::DAMAGING_WEAPON:
case eItemAbil::EXPLODING_WEAPON:
case eItemAbil::DAMAGE_PROTECTION:
me["str2-title"].setText("Type of damage");
break;
case eItemAbil::STATUS_WEAPON:
case eItemAbil::STATUS_PROTECTION:
case eItemAbil::OCCASIONAL_STATUS:
case eItemAbil::AFFECT_STATUS:
case eItemAbil::AFFECT_PARTY_STATUS:
me["str2-title"].setText("Which status effect");
break;
case eItemAbil::SLAYER_WEAPON:
case eItemAbil::PROTECT_FROM_SPECIES:
me["str2-title"].setText("Which species");
break;
case eItemAbil::BOOST_STAT:
me["str2-title"].setText("Which statistic");
break;
case eItemAbil::CAST_SPELL:
me["str2-title"].setText("Which spell");
me["str2-choose1"].setText("Mage");
me["str2-choose2"].show();
break;
case eItemAbil::SUMMONING:
case eItemAbil::MASS_SUMMONING:
me["str2-title"].setText("Which monster");
break;
default:
me["str2-title"].setText("Unused");
me["str2-choose1"].hide();
break;
}
if((item.ability >= eItemAbil::BLISS_DOOM && item.ability <= eItemAbil::HEALTH_POISON) || item.ability == eItemAbil::AFFECT_STATUS || item.ability == eItemAbil::OCCASIONAL_STATUS) {
me["use-title"].show();
me["use-type"].show();
} else {
me["use-title"].hide();
me["use-type"].hide();
}
dynamic_cast<cLed&>(me["always-id"]).setState(item.ident ? led_red : led_off);
dynamic_cast<cLed&>(me["magic"]).setState(item.magic ? led_red : led_off);
dynamic_cast<cLed&>(me["cursed"]).setState(item.cursed ? led_red : led_off);
dynamic_cast<cLed&>(me["conceal"]).setState(item.concealed ? led_red : led_off);
dynamic_cast<cLed&>(me["no-sell"]).setState(item.unsellable ? led_red : led_off);
}
static void save_item_abils(cDialog& me, cItem& item) {
item.magic_use_type = boost::lexical_cast<eItemUse>(dynamic_cast<cLedGroup&>(me["use-type"]).getSelected().substr(3));
item.treas_class = boost::lexical_cast<short>(dynamic_cast<cLedGroup&>(me["treasure"]).getSelected().substr(4));
item.abil_data[0] = me["str1"].getTextAsNum();
item.abil_data[1] = me["str2"].getTextAsNum();
item.property = item.enchanted = item.contained = false;
item.ident = dynamic_cast<cLed&>(me["always-id"]).getState() != led_off;
item.magic = dynamic_cast<cLed&>(me["magic"]).getState() != led_off;
item.cursed = dynamic_cast<cLed&>(me["cursed"]).getState() != led_off;
item.unsellable = dynamic_cast<cLed&>(me["no-sell"]).getState() != led_off;
item.concealed = dynamic_cast<cLed&>(me["conceal"]).getState() != led_off;
}
static bool edit_item_abil_event_filter(cDialog& me, std::string hit, cItem& item, short which) {
short i;
if(hit == "cancel") {
item.variety = eItemType::NO_ITEM;
me.toast(false);
return true;
} else if(hit == "okay") {
save_item_abils(me, item);
me.toast(true);
} else if(hit == "str1-choose") {
save_item_abils(me, item);
short spec = me["str1"].getTextAsNum();
if(spec < 0)
spec = get_fresh_spec(0);
if(edit_spec_enc(spec,0,&me)) {
item.abil_data[0] = spec;
me["str1"].setTextToNum(spec);
}
} else if(hit == "str2-choose1") {
save_item_abils(me, item);
i = item.abil_data[1];
switch(item.ability) {
case eItemAbil::DAMAGING_WEAPON:
case eItemAbil::EXPLODING_WEAPON:
case eItemAbil::DAMAGE_PROTECTION:
i = choose_damage_type(i, &me);
break;
case eItemAbil::STATUS_WEAPON:
case eItemAbil::STATUS_PROTECTION:
case eItemAbil::OCCASIONAL_STATUS:
case eItemAbil::AFFECT_STATUS:
case eItemAbil::AFFECT_PARTY_STATUS:
i = choose_status_effect(i, item.ability == eItemAbil::AFFECT_PARTY_STATUS, &me);
break;
case eItemAbil::SLAYER_WEAPON:
case eItemAbil::PROTECT_FROM_SPECIES:
i = choose_text(STRT_RACE, i, &me, "Which species?");
break;
case eItemAbil::BOOST_STAT:
i = choose_text(STRT_SKILL, i, &me, "Boost which skill?");
break;
case eItemAbil::CAST_SPELL:
i = choose_text_res("magic-names", 1, 78, i + 1, &me, "Which mage spell?");
if(i < 0) return true;
break;
case eItemAbil::SUMMONING:
case eItemAbil::MASS_SUMMONING:
i = choose_text(STRT_MONST, i, &me, "Summon which monster type?");
break;
default: return true;
}
item.abil_data[1] = i;
me["str2"].setTextToNum(i);
} else if(hit == "str2-choose2") {
save_item_abils(me, item);
i = 100 + choose_text_res("magic-names", 101, 168, item.abil_data[1] + 1, &me, "Which priest spell?");
if(i < 100) return true;
item.abil_data[1] = i;
me["str2"].setTextToNum(i);
} else if(hit == "clear") {
save_item_abils(me, item);
item.ability = eItemAbil::NONE;
put_item_abils_in_dlog(me, item, which);
} else if(hit == "weapon") {
save_item_abils(me, item);
if(!isWeaponType(item.variety)) {
giveError("You can only give an ability of this sort to a weapon.","",&me);
return true;
}
i = choose_text_res("item-abilities", 1, 14, int(item.ability), &me, "Choose Weapon Ability (inherent)");
if(i < 0) return true;
eItemAbil abil = eItemAbil(i + 1);
if(abil >= eItemAbil::RETURNING_MISSILE && abil <= eItemAbil::SEEKING_MISSILE) {
if(item.variety != eItemType::THROWN_MISSILE && item.variety != eItemType::ARROW &&
item.variety != eItemType::BOLTS && item.variety != eItemType::MISSILE_NO_AMMO) {
giveError("You can only give this ability to a missile.",&me);
return true;
}
}
item.ability = abil;
put_item_abils_in_dlog(me, item, which);
} else if(hit == "general") {
save_item_abils(me, item);
if(equippable.count(item.variety) == 0 || item.variety == eItemType::ARROW || item.variety == eItemType::THROWN_MISSILE || item.variety == eItemType::BOLTS){
giveError("You can only give an ability of this sort to an non-missile item which can be equipped (like armor, or a ring).",&me);
return true;
}
i = choose_text_res("item-abilities", 30, 58, int(item.ability), &me, "Choose General Ability (inherent)");
if(i < 0) return true;
item.ability = eItemAbil(i + 30);
put_item_abils_in_dlog(me, item, which);
} else if(hit == "usable") {
save_item_abils(me, item);
if((item.variety == eItemType::ARROW) || (item.variety == eItemType::THROWN_MISSILE) || (item.variety == eItemType::BOLTS)){
giveError("You can't give an ability of this sort to a missile.",&me);
return true;
}
i = choose_text_res("item-abilities", 70, 84, int(item.ability), &me, "Choose Usable Ability");
if(i < 0) return true;
item.ability = eItemAbil(i + 70);
put_item_abils_in_dlog(me, item, which);
} else if(hit == "reagent") {
save_item_abils(me, item);
if(item.variety != eItemType::NON_USE_OBJECT){
giveError("You can only give an ability of this sort to an item of type Non-Use Object.",&me);
return true;
}
i = choose_text_res("item-abilities", 150, 160, int(item.ability), &me, "Choose Reagent Ability");
if(i < 0) return true;
item.ability = eItemAbil(i + 150);
put_item_abils_in_dlog(me, item, which);
}
return true;
}
cItem edit_item_abil(cItem initial,short which_item,cDialog& parent) {
using namespace std::placeholders;
cDialog item_dlg("edit-item-abils",&parent);
item_dlg.attachClickHandlers(std::bind(edit_item_abil_event_filter, _1, _2, std::ref(initial), which_item), {
"okay", "cancel",
"clear", "weapon", "general", "usable", "reagent",
"str1-choose", "str2-choose1", "str2-choose2",
});
put_item_abils_in_dlog(item_dlg, initial, which_item);
item_dlg.run();
return initial;
}
static void put_spec_item_in_dlog(cDialog& me, cSpecItem& item, short which) {
me["num"].setTextToNum(which);
me["name"].setText(item.name);
me["descr"].setText(item.descr);
me["spec"].setTextToNum(item.special);
dynamic_cast<cLed&>(me["start-with"]).setState(item.flags >= 10 ? led_red : led_off);
dynamic_cast<cLed&>(me["usable"]).setState(item.flags % 10 > 0 ? led_red : led_off);
}
static bool save_spec_item(cDialog& me, cSpecItem& item, short which) {
item.name = me["name"].getText().substr(0,25);
item.descr = me["descr"].getText();
item.special = me["spec"].getTextAsNum();
item.flags = 0;
if(dynamic_cast<cLed&>(me["start-with"]).getState() != led_off)
item.flags += 10;
if(dynamic_cast<cLed&>(me["usable"]).getState() != led_off)
item.flags += 1;
scenario.special_items[which] = item;
return true;
}
static bool edit_spec_item_event_filter(cDialog& me, std::string hit, cSpecItem& item, short& which) {
if(hit == "cancel") {
me.toast(false);
} else if(hit == "okay") {
if(save_spec_item(me, item, which)) me.toast(true);
} else if(hit == "left") {
if(!save_spec_item(me, item, which)) return true;
which--;
if(which < 0) which = 49;
item = scenario.special_items[which];
put_spec_item_in_dlog(me, item, which);
} else if(hit == "right") {
if(!save_spec_item(me, item, which)) return true;
which++;
if(which > 49) which = 0;
item = scenario.special_items[which];
put_spec_item_in_dlog(me, item, which);
} else if(hit == "edit-spec") {
if(!save_spec_item(me, item, which)) return true;
short spec = me["spec"].getTextAsNum();
if(spec < 0)
spec = get_fresh_spec(0);
if(edit_spec_enc(spec,0,&me))
me["spec"].setTextToNum(spec);
save_spec_item(me, item, which);
}
return true;
}
void edit_spec_item(short which_item) {
using namespace std::placeholders;
cSpecItem item = scenario.special_items[which_item];
cDialog item_dlg("edit-special-item");
item_dlg["spec"].attachFocusHandler(std::bind(check_range_msg, _1, _2, _3, -1, 255, "Scenario special node called", "-1 for no special"));
item_dlg.attachClickHandlers(std::bind(edit_spec_item_event_filter, _1, _2, std::ref(item), std::ref(which_item)), {"okay", "cancel", "clear", "edit-spec", "left", "right"});
put_spec_item_in_dlog(item_dlg, item, which_item);
item_dlg["clear"].hide();
item_dlg.run();
}
static void put_quest_in_dlog(cDialog& me, const cQuest& quest, size_t which_quest) {
me["num"].setText(std::to_string(which_quest) + " of " + std::to_string(scenario.quests.size()));
me["name"].setText(quest.name);
me["descr"].setText(quest.descr);
me["chop"].setTextToNum(quest.deadline);
me["evt"].setTextToNum(quest.event);
me["xp"].setTextToNum(quest.xp);
me["gold"].setTextToNum(quest.gold);
me["bank1"].setTextToNum(quest.bank1);
me["bank2"].setTextToNum(quest.bank2);
dynamic_cast<cLed&>(me["rel"]).setState(quest.flags % 10 == 1 ? led_red : led_off);
dynamic_cast<cLed&>(me["start"]).setState(quest.flags >= 10 ? led_red : led_off);
dynamic_cast<cLed&>(me["inbank"]).setState(quest.bank1 >= 0 || quest.bank2 >= 0 ? led_red : led_off);
if(quest.bank1 < 0 && quest.bank2 < 0) {
me["bank1"].hide();
me["bank2"].hide();
} else {
me["bank1"].show();
me["bank2"].show();
}
}
static bool save_quest_from_dlog(cDialog& me, cQuest& quest, size_t which_quest, bool close) {
if(!me.toast(true)) return false;
quest.name = me["name"].getText();
quest.descr = me["descr"].getText();
quest.deadline = me["chop"].getTextAsNum();
quest.event = me["evt"].getTextAsNum();
quest.xp = me["xp"].getTextAsNum();
quest.gold = me["gold"].getTextAsNum();
quest.flags = dynamic_cast<cLed&>(me["rel"]).getState() == led_red;
if(dynamic_cast<cLed&>(me["start"]).getState() == led_red)
quest.flags += 10;
if(dynamic_cast<cLed&>(me["inbank"]).getState() == led_red) {
quest.bank1 = me["bank1"].getTextAsNum();
quest.bank2 = me["bank2"].getTextAsNum();
} else quest.bank1 = quest.bank2 = -1;
scenario.quests[which_quest] = quest;
if(!close) me.untoast();
return true;
}
static bool change_quest_dlog_page(cDialog& me, std::string dir, cQuest& quest, size_t& which_quest) {
if(!save_quest_from_dlog(me, quest, which_quest, false))
return true;
if(dir == "left") {
if(which_quest == 0)
which_quest = scenario.quests.size();
which_quest--;
} else if(dir == "right") {
which_quest++;
if(which_quest == scenario.quests.size())
which_quest = 0;
}
quest = scenario.quests[which_quest];
put_quest_in_dlog(me, quest, which_quest);
return true;
}
void edit_quest(size_t which_quest) {
using namespace std::placeholders;
if(which_quest == scenario.quests.size()) {
scenario.quests.resize(which_quest + 1);
scenario.quests[which_quest].name = "New Quest";
}
cQuest quest = scenario.quests[which_quest];
cDialog quest_dlg("edit-quest");
quest_dlg["cancel"].attachClickHandler(std::bind(&cDialog::toast, _1, false));
quest_dlg["okay"].attachClickHandler(std::bind(save_quest_from_dlog, _1, std::ref(quest), std::ref(which_quest), true));
quest_dlg["inbank"].attachFocusHandler([](cDialog& me, std::string, bool losing) -> bool {
if(losing) {
me["bank1"].hide();
me["bank2"].hide();
} else {
me["bank1"].show();
me["bank2"].show();
}
return true;
});
// TODO: Some focus handlers
if(scenario.quests.size() == 1) {
quest_dlg["left"].hide();
quest_dlg["right"].hide();
} else {
quest_dlg.attachClickHandlers(std::bind(change_quest_dlog_page, _1, _2, std::ref(quest), std::ref(which_quest)), {"left", "right"});
}
put_quest_in_dlog(quest_dlg, quest, which_quest);
quest_dlg.run();
}
static bool put_shop_item_in_dlog(cPict& pic, cControl& num, cControl& title, const cShop& shop, int which) {
cShopItem entry = shop.getItem(which);
num.setTextToNum(which);
pic.setPict(entry.item.graphic_num);
if(entry.type == eShopItemType::EMPTY) {
title.setText("");
return false;
}
std::string name = entry.item.full_name;
int amount = entry.quantity;
if(entry.type == eShopItemType::OPTIONAL) {
name += " [" + std::to_string(amount / 1000) + "% chance]";
amount %= 1000;
}
if(amount > 0) {
name = std::to_string(amount) + "x " + name;
}
title.setText(name);
return true;
}
static void put_shop_in_dlog(cDialog& me, const cShop& shop, size_t which_shop) {
me["num"].setText(std::to_string(which_shop) + " of " + std::to_string(scenario.shops.size()));
me["name"].setText(shop.getName());
dynamic_cast<cPict&>(me["face"]).setPict(shop.getFace());
dynamic_cast<cLedGroup&>(me["type"]).setSelected("t" + std::to_string(int(shop.getType()) + 1));
dynamic_cast<cLedGroup&>(me["prompt"]).setSelected("p" + std::to_string(int(shop.getPrompt()) + 1));
cStack& items = dynamic_cast<cStack&>(me["items"]);
for(int i = 0; i < 6; i++) {
items.setPage(i);
for(int j = 0; j < 5; j++) {
std::string id = std::to_string(j + 1);
if(put_shop_item_in_dlog(dynamic_cast<cPict&>(me["pict" + id]), me["n" + id], me["item" + id], shop, i * 5 + j)) {
if(i == 0) {
me["ed" + id].show();
me["del" + id].show();
}
} else if(i == 0) {
me["ed" + id].hide();
me["del" + id].hide();
}
}
}
items.setPage(0);
}
static bool save_shop_from_dlog(cDialog& me, cShop& shop, size_t which_shop, bool close) {
if(!me.toast(true)) return false;
shop.setName(me["name"].getText());
shop.setType(eShopType(dynamic_cast<cLedGroup&>(me["type"]).getSelected()[1] - '1'));
shop.setPrompt(eShopPrompt(dynamic_cast<cLedGroup&>(me["prompt"]).getSelected()[1] - '1'));
shop.setFace(dynamic_cast<cPict&>(me["face"]).getPicNum());
// Items are filled in as they're added by the dialog, so that's all we need to do here
scenario.shops[which_shop] = shop;
if(!close) me.untoast();
return true;
}
static bool change_shop_dlog_page(cDialog& me, std::string dir, cShop& shop, size_t& which_shop) {
if(!save_shop_from_dlog(me, shop, which_shop, false))
return true;
if(dir == "left") {
if(which_shop == 0)
which_shop = scenario.shops.size();
which_shop--;
} else if(dir == "right") {
which_shop++;
if(which_shop == scenario.shops.size())
which_shop = 0;
}
shop = scenario.shops[which_shop];
put_shop_in_dlog(me, shop, which_shop);
return true;
}
static bool change_shop_dlog_items_page(cDialog& me, std::string dir, const cShop& shop) {
cStack& items = dynamic_cast<cStack&>(me["items"]);
int curPage = items.getPage(), maxPage = items.getPageCount();
if(dir == "up") {
if(curPage == 0)
curPage = maxPage - 1;
else curPage--;
} else if(dir == "down") {
if(curPage == maxPage - 1)
curPage = 0;
else curPage++;
}
for(int i = 0; i < 5; i++) {
std::string id = std::to_string(i + 1);
if(shop.getItem(curPage * 5 + i).type == eShopItemType::EMPTY) {
me["ed" + id].hide();
me["del" + id].hide();
} else {
me["ed" + id].show();
me["del" + id].show();
}
}
items.setPage(curPage);
return true;
}
static void edit_shop_item(cDialog& parent, size_t& item, size_t& quantity, bool optional) {
using namespace std::placeholders;
int was_item = item;
cDialog item_dlg("edit-shop-item", &parent);
item_dlg["cancel"].attachClickHandler(std::bind(&cDialog::toast, _1, false));
item_dlg["okay"].attachClickHandler(std::bind(&cDialog::toast, _1, true));
if(optional) {
item_dlg["amount"].setTextToNum(quantity % 1000);
item_dlg["chance"].setTextToNum(quantity / 1000);
item_dlg["amount"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 999, "amount"));
item_dlg["chance"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 1, 100, "chance"));
} else {
item_dlg["amount"].setTextToNum(quantity);
item_dlg["chance"].hide();
item_dlg["chance-prompt"].hide();
}
item_dlg["item"].setText(scenario.scen_items[item].full_name);
item_dlg["choose"].attachClickHandler([&item](cDialog& me, std::string, eKeyMod) -> bool {
item = choose_text(STRT_ITEM, item, &me, "Which item?");
me["item"].setText(scenario.scen_items[item].full_name);
return true;
});
item_dlg.run();
if(item_dlg.accepted()) {
quantity = item_dlg["amount"].getTextAsNum();
if(optional)
quantity += 1000 * item_dlg["chance"].getTextAsNum();
} else item = was_item;
}
static void edit_shop_special(cDialog& parent, cItem& item, size_t& quantity) {
using namespace std::placeholders;
cDialog spec_dlg("edit-shop-special", &parent);
spec_dlg["cancel"].attachClickHandler(std::bind(&cDialog::toast, _1, false));
spec_dlg["okay"].attachClickHandler(std::bind(&cDialog::toast, _1, true));
spec_dlg["cost"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, 10000, "cost"));
spec_dlg["pickicon"].attachClickHandler(std::bind(pick_picture, PIC_ITEM, _1, "", "icon"));
spec_dlg["edit"].attachClickHandler([](cDialog& me, std::string, eKeyMod) -> bool {
int spec = me["node"].getTextAsNum();
if(spec < 0) spec = get_fresh_spec(0);
if(edit_spec_enc(spec, 0, &me))
me["node"].setTextToNum(spec);
return true;
});
spec_dlg["name"].setText(item.full_name);
spec_dlg["descr"].setText(item.desc);
spec_dlg["node"].setTextToNum(item.item_level);
spec_dlg["cost"].setTextToNum(item.value);
spec_dlg["amount"].setTextToNum(quantity);
dynamic_cast<cPict&>(spec_dlg["icon"]).setPict(item.graphic_num);
spec_dlg.run();
if(spec_dlg.accepted()) {
item.full_name = spec_dlg["name"].getText();
item.desc = spec_dlg["descr"].getText();
item.item_level = spec_dlg["node"].getTextAsNum();
item.value = spec_dlg["cost"].getTextAsNum();
quantity = spec_dlg["amount"].getTextAsNum();
item.graphic_num = dynamic_cast<cPict&>(spec_dlg["icon"]).getPicNum();
}
}
static bool edit_shop_entry(cDialog& me, std::string which, cShop& shop) {
int btn_i = which[2] - '0';
int i = dynamic_cast<cStack&>(me["items"]).getPage() * 5 + btn_i - 1;
cShopItem entry = shop.getItem(i);
eStrType list;
std::string prompt;
bool need_string = true;
switch(entry.type) {
case eShopItemType::EMPTY: return true;
case eShopItemType::ITEM:
case eShopItemType::OPTIONAL:
edit_shop_item(me, entry.index, entry.quantity, entry.type == eShopItemType::OPTIONAL);
entry.item = scenario.scen_items[entry.index];
shop.replaceItem(i, entry);
need_string = false;
break;
case eShopItemType::CLASS:
entry.index = get_monst_abil_num("Which special class?", 1, 100, me, entry.index);
shop.replaceSpecial(i, eShopItemType::CLASS, entry.index);
need_string = false;
break;
case eShopItemType::CALL_SPECIAL:
edit_shop_special(me, entry.item, entry.quantity);
shop.replaceItem(i, entry);
need_string = false;
break;
case eShopItemType::MAGE_SPELL: list = STRT_MAGE; prompt = "Which mage spell?"; break;
case eShopItemType::PRIEST_SPELL: list = STRT_PRIEST; prompt = "Which priest spell?"; break;
case eShopItemType::ALCHEMY: list = STRT_ALCHEMY; prompt = "Which recipe?"; break;
case eShopItemType::SKILL: list = STRT_SKILL; prompt = "Which skill?"; break;
case eShopItemType::TREASURE: list = STRT_TREASURE; prompt = "What class of treasure?"; break;
case eShopItemType::CURE_ACID: case eShopItemType::CURE_DISEASE: case eShopItemType::CURE_POISON:
case eShopItemType::CURE_DUMBFOUNDING: case eShopItemType::CURE_PARALYSIS: case eShopItemType::DESTONE:
case eShopItemType::HEAL_WOUNDS: case eShopItemType::RAISE_DEAD: case eShopItemType::REMOVE_CURSE:
case eShopItemType::RESURRECT:
list = STRT_HEALING;
break;
}
if(need_string) {
entry.index = choose_text(list, entry.index, &me, prompt);
if(list == STRT_HEALING)
shop.replaceSpecial(i, eShopItemType(int(eShopItemType::HEAL_WOUNDS) + entry.index));
else shop.replaceSpecial(i, entry.type, entry.index);
}
std::string pic_id = which, num_id = which, title_id = which;
pic_id.replace(0,2,"pict"); num_id.replace(0,2,"n"); title_id.replace(0,2,"item");
put_shop_item_in_dlog(dynamic_cast<cPict&>(me[pic_id]), me[num_id], me[title_id], shop, i);
return true;
}
static bool delete_shop_entry(cDialog& me, std::string which, cShop& shop, size_t which_shop) {
cStack& items = dynamic_cast<cStack&>(me["items"]);
int page = items.getPage();
shop.clearItem((which[3] - '1') + 5 * page);
put_shop_in_dlog(me, shop, which_shop);
items.setPage(page);
change_shop_dlog_items_page(me, "stay", shop);
return true;
}
static bool add_shop_entry(cDialog& me, std::string type, cShop& shop, size_t which_shop) {
if(shop.size() == 30) {
giveError("There is no more room in this shop to add another item. Each shop can only have up to 30 items.", &me);
return true;
}
if(type == "item" || type == "opt") {
size_t which_item = 0, amount = 0;
edit_shop_item(me, which_item, amount, type == "opt");
if(scenario.scen_items[which_item].variety == eItemType::NO_ITEM)
return true;
if(scenario.scen_items[which_item].variety == eItemType::GOLD)
return true;
if(type == "item")
shop.addItem(which_item, scenario.scen_items[which_item], amount);
else shop.addItem(which_item, scenario.scen_items[which_item], amount % 1000, amount / 1000);
} else if(type == "spec") {
cItem item('spec');
size_t amount = 0;
edit_shop_special(me, item, amount);
if(item.item_level < 0)
return true;
shop.addSpecial(item.full_name, item.desc, item.graphic_num, item.item_level, item.value, amount);
} else if(type == "class") {
int n = get_monst_abil_num("Which special class?", 0, 100, me);
if(n == 0) return true;
shop.addSpecial(eShopItemType::CLASS, n);
} else {
eStrType list;
eShopItemType item;
std::string prompt;
if(type == "mage") {
list = STRT_MAGE;
item = eShopItemType::MAGE_SPELL;
prompt = "Which mage spell?";
} else if(type == "priest") {
list = STRT_PRIEST;
item = eShopItemType::PRIEST_SPELL;
prompt = "Which priest spell?";
} else if(type == "alch") {
list = STRT_ALCHEMY;
item = eShopItemType::ALCHEMY;
prompt = "Which recipe?";
} else if(type == "skill") {
list = STRT_SKILL;
item = eShopItemType::SKILL;
prompt = "Which skill?";
} else if(type == "treas") {
list = STRT_TREASURE;
item = eShopItemType::TREASURE;
prompt = "What class of treasure?";
} else if(type == "heal") {
list = STRT_HEALING;
prompt = "What kind of healing?";
}
int i = choose_text(list, -1, &me, prompt);
if(i == -1) return true;
if(list == STRT_HEALING) {
item = eShopItemType(int(eShopItemType::HEAL_WOUNDS) + i);
i = 0;
}
shop.addSpecial(item, i);
}
put_shop_in_dlog(me, shop, which_shop);
int atItem = shop.size() - 1;
int onPage = atItem / 5;
dynamic_cast<cStack&>(me["items"]).setPage(onPage);
change_shop_dlog_items_page(me, "stay", shop);
return true;
}
void edit_shop(size_t which_shop, cDialog* parent) {
using namespace std::placeholders;
if(which_shop == scenario.shops.size())
scenario.shops.emplace_back("New Shop");
cShop shop = scenario.shops[which_shop];
cDialog shop_dlg("edit-shop", parent);
shop_dlg["cancel"].attachClickHandler(std::bind(&cDialog::toast, _1, false));
shop_dlg["okay"].attachClickHandler(std::bind(save_shop_from_dlog, _1, std::ref(shop), std::ref(which_shop), true));
shop_dlg["pickface"].attachClickHandler(std::bind(pick_picture, PIC_TALK, _1, "", "face"));
shop_dlg.attachClickHandlers(std::bind(change_shop_dlog_items_page, _1, _2, std::ref(shop)), {"up", "down"});
shop_dlg.attachClickHandlers(std::bind(delete_shop_entry, _1, _2, std::ref(shop), std::ref(which_shop)), {"del1", "del2", "del3", "del4", "del5"});
shop_dlg.attachClickHandlers(std::bind(edit_shop_entry, _1, _2, std::ref(shop)), {"ed1", "ed2", "ed3", "ed4", "ed5"});
shop_dlg.attachClickHandlers(std::bind(add_shop_entry, _1, _2, std::ref(shop), std::ref(which_shop)), {"item", "opt", "spec", "mage", "priest", "alch", "skill", "treas", "heal", "class"});
shop_dlg["rand"].attachClickHandler([&shop,which_shop](cDialog& me, std::string, eKeyMod) -> bool {
shop = cShop('junk');
put_shop_in_dlog(me, shop, which_shop);
return true;
});
if(scenario.shops.size() == 1 || parent != nullptr) {
shop_dlg["left"].hide();
shop_dlg["right"].hide();
} else {
shop_dlg.attachClickHandlers(std::bind(change_shop_dlog_page, _1, _2, std::ref(shop), std::ref(which_shop)), {"left", "right"});
}
dynamic_cast<cStack&>(shop_dlg["items"]).setPageCount(6);
put_shop_in_dlog(shop_dlg, shop, which_shop);
shop_dlg.run();
}
static void put_save_rects_in_dlog(cDialog& me) {
short i;
for(i = 0; i < 3; i++) {
std::string id = std::to_string(i + 1);
me["top" + id].setTextToNum(scenario.store_item_rects[i].top);
me["left" + id].setTextToNum(scenario.store_item_rects[i].left);
me["bottom" + id].setTextToNum(scenario.store_item_rects[i].bottom);
me["right" + id].setTextToNum(scenario.store_item_rects[i].right);
me["town" + id].setTextToNum(scenario.store_item_towns[i]);
}
}
static bool save_save_rects(cDialog& me) {
short i;
for(i = 0; i < 3; i++) {
std::string id = std::to_string(i + 1);
scenario.store_item_rects[i].top = me["top" + id].getTextAsNum();
scenario.store_item_rects[i].left = me["left" + id].getTextAsNum();
scenario.store_item_rects[i].bottom = me["bottom" + id].getTextAsNum();
scenario.store_item_rects[i].right = me["right" + id].getTextAsNum();
scenario.store_item_towns[i] = me["town" + id].getTextAsNum();
if((scenario.store_item_towns[i] < -1) || (scenario.store_item_towns[i] >= 200)) {
giveError("Towns must be in 0 to 200 range (or -1 for no save items rectangle).","",&me);
return false;
}
}
if(((scenario.store_item_towns[0] == scenario.store_item_towns[1]) &&
(scenario.store_item_towns[0] >= 0) && (scenario.store_item_towns[1] >= 0))
||
((scenario.store_item_towns[2] == scenario.store_item_towns[1]) &&
(scenario.store_item_towns[2] >= 0) && (scenario.store_item_towns[1] >= 0))
||
((scenario.store_item_towns[2] == scenario.store_item_towns[0]) &&
(scenario.store_item_towns[2] >= 0) && (scenario.store_item_towns[0] >= 0))
) {
giveError("The three towns towns with saved item rectangles must be different.","",&me);
return false;
}
return true;
}
static bool edit_save_rects_event_filter(cDialog& me, std::string item_hit) {
if(item_hit == "cancel") {
me.toast(false);
} else if(item_hit == "okay") {
if(save_save_rects(me))
me.toast(true);
}
return true;
}
void edit_save_rects() {
using namespace std::placeholders;
cDialog save_dlg("edit-save-rects");
save_dlg.attachClickHandlers(std::bind(edit_save_rects_event_filter, _1, _2), {"okay"});
put_save_rects_in_dlog(save_dlg);
save_dlg.run();
}
static bool save_vehicles(cDialog& me, cVehicle* vehicles, const short page) {
short i;
for(i = 0; i < 6; i++) {
std::string id = std::to_string(i + 1);
vehicles[6 * page + i].which_town = me["town" + id].getTextAsNum();
if(cre(vehicles[6 * page + i].which_town,
-1,199,"Town number must be from 0 to 199 (or -1 for it to not exist).","",&me)) return false;
vehicles[6 * page + i].loc.x = me["x" + id].getTextAsNum();
if(cre(vehicles[6 * page + i].loc.x,
0,63,"coordinates must be from 0 to 63.","",&me)) return false;
vehicles[6 * page + i].loc.y = me["y" + id].getTextAsNum();
if(cre(vehicles[6 * page + i].loc.y,
0,63,"coordinates must be from 0 to 63.","",&me)) return false;
vehicles[6 * page + i].property = dynamic_cast<cLed&>(me["owned" + id]).getState() != led_off;
}
return true;
}
static void put_vehicles_in_dlog(cDialog& me, cVehicle* vehicles, const short page) {
short i;
for(i = 0; i < 6; i++) {
std::string id = std::to_string(i + 1);
me["num" + id].setTextToNum(6 * page + i);
me["town" + id].setTextToNum(vehicles[6 * page + i].which_town);
me["x" + id].setTextToNum(vehicles[6 * page + i].loc.x);
me["y" + id].setTextToNum(vehicles[6 * page + i].loc.y);
dynamic_cast<cLed&>(me["owned" + id]).setState(vehicles[6 * page + i].property ? led_red : led_off);
}
}
static bool edit_vehicles_event_filter(cDialog& me, std::string hit, cVehicle* vehicles, size_t nVehicles, size_t& page) {
if(hit == "okay") {
if(save_vehicles(me, vehicles, page))
me.toast(true);
} else if(hit == "left") {
if(!save_vehicles(me, vehicles, page)) return true;
if(page == 0) page = (nVehicles - 1) / 6;
else page--;
put_vehicles_in_dlog(me, vehicles, page);
} else if(hit == "right") {
if(!save_vehicles(me, vehicles, page)) return true;
page++;
if(page > (nVehicles - 1) / 6) page = 0;
put_vehicles_in_dlog(me, vehicles, page);
}
return true;
}
void edit_horses() {
using namespace std::placeholders;
size_t page = 0;
cDialog horse_dlg("edit-horses");
horse_dlg.attachClickHandlers(std::bind(edit_vehicles_event_filter, _1, _2, scenario.horses.data(), 30, std::ref(page)), {"okay", "left", "right"});
put_vehicles_in_dlog(horse_dlg, scenario.horses.data(), page);
horse_dlg.run();
}
void edit_boats() {
using namespace std::placeholders;
size_t page = 0;
cDialog boat_dlg("edit-boats");
boat_dlg.attachClickHandlers(std::bind(edit_vehicles_event_filter, _1, _2, scenario.boats.data(), 30, std::ref(page)), {"okay", "left", "right"});
put_vehicles_in_dlog(boat_dlg, scenario.boats.data(), page);
boat_dlg.run();
}
static bool save_add_town(cDialog& me) {
short i;
for(i = 0; i < 10; i++) {
std::string id = std::to_string(i + 1);
scenario.town_to_add_to[i] = me["town" + id].getTextAsNum();
if(cre(scenario.town_to_add_to[i],
-1,199,"Town number must be from 0 to 199 (or -1 for no effect).","",&me)) return false;
scenario.flag_to_add_to_town[i][0] = me["flag" + id + "-x"].getTextAsNum();
if(cre(scenario.flag_to_add_to_town[i][0],
0,299,"First part of flag must be from 0 to 299.","",&me)) return false;
scenario.flag_to_add_to_town[i][1] = me["flag" + id + "-y"].getTextAsNum();
if(cre(scenario.flag_to_add_to_town[i][1],
0,9,"Second part of flag must be from 0 to 9.","",&me)) return false;
}
return true;
}
static void put_add_town_in_dlog(cDialog& me) {
short i;
for(i = 0; i < 10; i++) {
std::string id = std::to_string(i + 1);
me["town" + id].setTextToNum(scenario.town_to_add_to[i]);
me["flag" + id + "-x"].setTextToNum(scenario.flag_to_add_to_town[i][0]);
me["flag" + id + "-y"].setTextToNum(scenario.flag_to_add_to_town[i][1]);
}
}
static bool edit_add_town_event_filter(cDialog& me, std::string hit) {
if(hit == "okay") {
if(save_add_town(me))
me.toast(true);
}
return true;
}
void edit_add_town() {
using namespace std::placeholders;
cDialog vary_dlg("edit-town-varying");
vary_dlg.attachClickHandlers(std::bind(edit_add_town_event_filter, _1, _2), {"okay"});
put_add_town_in_dlog(vary_dlg);
vary_dlg.run();
}
static bool save_item_placement(cDialog& me, cScenario::cItemStorage& storage, short which) {
short i;
storage.property = dynamic_cast<cLed&>(me["owned"]).getState() != led_off;
storage.ter_type = me["ter"].getTextAsNum();
if(cre(storage.ter_type,
-1,255,"Terrain Type must be from 0 to 255 (or -1 for No Shortcut).","",&me)) return false;
for(i = 0; i < 10; i++) {
std::string id = std::to_string(i + 1);
storage.item_num[i] = me["item" + id].getTextAsNum();
if(cre(storage.item_num[i],
-1,399,"All item numbers must be from 0 to 399 (or -1 for No Item).","",&me)) return false;
storage.item_odds[i] = me["odds" + id].getTextAsNum();
if(cre(storage.item_odds[i],
0,100,"All item chances must bve from 0 to 100.","",&me)) return false;
}
scenario.storage_shortcuts[which] = storage;
return true;
}
static void put_item_placement_in_dlog(cDialog& me, const cScenario::cItemStorage& storage, short which) {
short i;
me["num"].setTextToNum(which);
dynamic_cast<cLed&>(me["owned"]).setState(storage.property ? led_red : led_off);
me["ter"].setTextToNum(storage.ter_type);
for(i = 0; i < 10; i++) {
std::string id = std::to_string(i + 1);
me["item" + id].setTextToNum(storage.item_num[i]);
me["odds" + id].setTextToNum(storage.item_odds[i]);
}
}
static bool edit_item_placement_event_filter(cDialog& me, std::string hit, cScenario::cItemStorage& storage, short& which) {
short i;
if(hit == "okay") {
if(save_item_placement(me, storage, which))
me.toast(true);
} else if(hit == "cancel") {
me.toast(false);
} else if(hit == "left") {
if(!save_item_placement(me, storage, which)) return true;
which--;
if(which < 0) which = 9;
storage = scenario.storage_shortcuts[which];
put_item_placement_in_dlog(me, storage, which);
} else if(hit == "right") {
if(!save_item_placement(me, storage, which)) return true;
which++;
if(which > 9) which = 0;
storage = scenario.storage_shortcuts[which];
put_item_placement_in_dlog(me, storage, which);
} else if(hit == "choose-ter") {
i = me["ter"].getTextAsNum();
storage.ter_type = i;
i = choose_text(STRT_TER,i,&me,"Which Terrain?");
if(i >= 0){
me["ter"].setTextToNum(i);
storage.ter_type = i;
}
}
return true;
}
static bool edit_item_placement_select_item(cDialog& me, cScenario::cItemStorage& storage, short hit) {
std::string id = "item" + std::to_string(hit);
short i = me[id].getTextAsNum();
storage.item_num[hit - 1] = i;
i = choose_text(STRT_ITEM,i,&me,"Place which item?");
if(i >= 0) {
me[id].setTextToNum(i);
storage.item_num[hit - 1] = i;
}
return true;
}
void edit_item_placement() {
using namespace std::placeholders;
cScenario::cItemStorage storage = scenario.storage_shortcuts[0];
short cur_shortcut = 0;
cDialog shortcut_dlg("edit-item-shortcut");
shortcut_dlg.attachClickHandlers(std::bind(edit_item_placement_event_filter, _1, _2, std::ref(storage), std::ref(cur_shortcut)), {"okay", "cancel", "left", "right", "choose-ter"});
for(int i = 0; i < 10; i++) {
std::string id = "choose-item" + std::to_string(i + 1);
shortcut_dlg[id].attachClickHandler(std::bind(edit_item_placement_select_item, _1, std::ref(storage), i + 1));
}
put_item_placement_in_dlog(shortcut_dlg, storage, cur_shortcut);
shortcut_dlg.run();
}
static bool save_scen_details(cDialog& me, std::string, eKeyMod) {
short i;
if(!me.toast(true)) return true;
{
cLedGroup& difficulty = dynamic_cast<cLedGroup&>(me["difficulty"]);
scenario.difficulty = difficulty.getSelected()[3] - '1';
}{
cLedGroup& rating = dynamic_cast<cLedGroup&>(me["rating"]);
scenario.rating = rating.getSelected()[4] - '1';
}
scenario.adjust_diff = dynamic_cast<cLed&>(me["adjust"]).getState() != led_red;
for(i = 0; i < 3; i++)
scenario.format.ver[i] = me["ver" + std::to_string(i + 1)].getTextAsNum();
scenario.who_wrote[0] = me["who1"].getText().substr(0, 60);
scenario.who_wrote[1] = me["who2"].getText().substr(0, 60);
scenario.contact_info = me["contact"].getText().substr(0, 256);
scenario.campaign_id = me["cpnid"].getText();
scenario.bg_out = boost::lexical_cast<int>(me["bg-out"].getText().substr(10));
scenario.bg_town = boost::lexical_cast<int>(me["bg-town"].getText().substr(10));
scenario.bg_dungeon = boost::lexical_cast<int>(me["bg-dungeon"].getText().substr(13));
scenario.bg_fight = boost::lexical_cast<int>(me["bg-fight"].getText().substr(11));
return true;
}
static void put_scen_details_in_dlog(cDialog& me) {
dynamic_cast<cLedGroup&>(me["difficulty"]).setSelected("lvl" + std::to_string(scenario.difficulty + 1));
dynamic_cast<cLedGroup&>(me["rating"]).setSelected("rate" + std::to_string(scenario.rating + 1));
dynamic_cast<cLed&>(me["adjust"]).setState(scenario.adjust_diff ? led_red : led_off);
for(int i = 0; i < 3; i++)
me["ver" + std::to_string(i + 1)].setTextToNum(scenario.format.ver[i]);
me["who1"].setText(scenario.who_wrote[0]);
me["who2"].setText(scenario.who_wrote[1]);
me["contact"].setText(scenario.contact_info);
me["cpnid"].setText(scenario.campaign_id);
me["bg-out"].setText("Outdoors: " + std::to_string(scenario.bg_out));
me["bg-town"].setText("In towns: " + std::to_string(scenario.bg_town));
me["bg-dungeon"].setText("In dungeons: " + std::to_string(scenario.bg_dungeon));
me["bg-fight"].setText("In combat: " + std::to_string(scenario.bg_fight));
}
static bool edit_scen_default_bgs(cDialog& me, std::string which, eKeyMod) {
int bg_i = 0, idx_i = 0;
if(which == "bg-out" || which == "bg-town")
idx_i = 10;
else if(which == "bg-dungeon")
idx_i = 13;
else if(which == "bg-fight")
idx_i = 11;
else return true;
bg_i = boost::lexical_cast<int>(me[which].getText().substr(idx_i));
bg_i = choose_background(bg_i, &me);
std::string lbl;
if(which == "bg-out")
lbl = "Outdoors";
else if(which == "bg-town")
lbl = "In towns";
else if(which == "bg-dungeon")
lbl = "In dungeons";
else if(which == "bg-fight")
lbl = "In combat";
me[which].setText(lbl + ": " + std::to_string(bg_i));
return true;
}
void edit_scen_details() {
cDialog info_dlg("edit-scenario-details");
info_dlg["okay"].attachClickHandler(save_scen_details);
info_dlg.attachClickHandlers(edit_scen_default_bgs, {"bg-out", "bg-town", "bg-dungeon", "bg-fight"});
put_scen_details_in_dlog(info_dlg);
info_dlg.run();
}
static bool edit_make_scen_1_event_filter(cDialog& me, std::string, eKeyMod) {
short i,j;
std::string str = me["file"].getText();
j = str.length();
if(j == 0) {
giveError("You've left the file name empty.","",&me);
return true;
}
if(j > 50) {
giveError("The file name can be at most 50 characters long.","",&me);
return true;
}
for(i = 0; i < j; i++)
if((str[i] < 97) || (str[i] > 122)) {
giveError("The file name must consist of only lower case letters.","",&me);
return true;
}
me.setResult(true);
me.toast(true);
return true;
}
bool edit_make_scen_1(std::string& filename,std::string& title,bool& grass) {
cDialog new_dlog("make-scenario1");
new_dlog["okay"].attachClickHandler(edit_make_scen_1_event_filter);
new_dlog["cancel"].attachClickHandler(std::bind(&cDialog::toast, &new_dlog, false));
new_dlog.setResult(false);
new_dlog.run();
if(!new_dlog.getResult<bool>()) return false;
title = new_dlog["name"].getText();
filename = new_dlog["file"].getText();
grass = dynamic_cast<cLed&>(new_dlog["surface"]).getState() != led_off;
return true;
}
static bool edit_make_scen_2_event_filter(cDialog& me, std::string, eKeyMod) {
short i,j,k;
i = me["out-w"].getTextAsNum();
if(cre(i, 1,50,"Outdoors width must be between 1 and 50.","",&me)) return true;
j = me["out-h"].getTextAsNum();
if(cre(j, 1,50,"Outdoors height must be between 1 and 50.","",&me)) return true;
if(cre(i * j, 1,100,"The total number of outdoor sections (width times height) must be between 1 and 100.","",&me)) return true;
i = me["town-s"].getTextAsNum();
j = me["town-m"].getTextAsNum();
k = me["town-l"].getTextAsNum();
if(cre(i, 0,200,"Number of small towns must be between 0 and 200.","",&me)) return true;
if(cre(j, 1,200,"Number of medium towns must be between 1 and 200. The first town (Town 0) must always be of medium size.","",&me)) return true;
if(cre(k, 0,200,"Number of large towns must be between 0 and 200.","",&me)) return true;
if(cre(i + j + k, 1,200,"The total number of towns must be from 1 to 200 (you must have at least 1 town).","",&me)) return true;
me.toast(true);
return true;
}
bool edit_make_scen_2(short& out_w, short& out_h, short& town_l, short& town_m, short& town_s, bool& def_town) {
cDialog new_dlog("make-scenario2");
new_dlog["okay"].attachClickHandler(edit_make_scen_2_event_filter);
new_dlog["cancel"].attachClickHandler(std::bind(&cDialog::toast, &new_dlog, false));
new_dlog.setResult(false);
new_dlog.run();
if(!new_dlog.accepted()) return false;
out_w = new_dlog["out-w"].getTextAsNum();
out_h = new_dlog["out-h"].getTextAsNum();
town_l = new_dlog["town-l"].getTextAsNum();
town_m = new_dlog["town-m"].getTextAsNum();
town_s = new_dlog["town-s"].getTextAsNum();
def_town = dynamic_cast<cLed&>(new_dlog["warrior-grove"]).getState();
return true;
}
extern fs::path progDir;
extern eScenMode overall_mode;
bool build_scenario() {
short width, height, lg, med, sm;
bool default_town, grass;
std::string filename, title;
short i,j;
cTown* warriors_grove = nullptr;
std::vector<cShop> warriors_grove_shops;
if(!edit_make_scen_1(filename, title, grass))
return false;
filename += ".boes";
if(!edit_make_scen_2(width, height, lg, med, sm, default_town))
return false;
scenario = cScenario(true);
scenario.scen_name = title;
scenario.default_ground = grass ? 2 : 0;
fs::path basePath = progDir/"Scenario Editor"/"Blades of Exile Base"/"bladbase.exs";
if(!fs::exists(basePath)) {oopsError(40);}
cScenario base;
load_scenario(basePath, base);
// Load in all terrains, items, and monsters
std::swap(scenario.ter_types, base.ter_types);
std::swap(scenario.scen_items, base.scen_items);
std::swap(scenario.scen_monsters, base.scen_monsters);
if(default_town) {
warriors_grove = base.towns[0];
std::swap(warriors_grove_shops, base.shops);
base.towns[0] = nullptr;
if(!grass) {
// Go through and replace all surface terrains with similar cave terrains
// Note that this assumes the default terrain set is unchanged.
for(int x = 0; x < warriors_grove->max_dim(); x++) {
for(int y = 0; y < warriors_grove->max_dim(); y++) {
ter_num_t ter_there = warriors_grove->terrain(x,y);
if(ter_there >= 36 && ter_there <= 49 && ter_there != 37) // Hills
ter_there = 0;
else if(ter_there >= 50 && ter_there <= 62) // Water
ter_there = 71;
else switch(ter_there) {
// Mountains
case 22: case 23: ter_there = 5; break;
case 24: ter_there = 6; break;
case 25: ter_there = 8; break;
case 26: ter_there = 9; break;
case 27: ter_there = 11; break;
case 28: ter_there = 12; break;
case 29: ter_there = 14; break;
case 30: ter_there = 15; break;
case 31: ter_there = 17; break;
case 32: ter_there = 18; break;
case 33: ter_there = 19; break;
case 34: ter_there = 20; break;
case 35: ter_there = 21; break;
// Water stuff
case 63: case 64: ter_there = 74; break;
case 65: case 66: case 67: ter_there = 73; break;
case 68: case 69: case 70: ter_there = 72; break;
// Rubble
case 87: case 88: case 89: ter_there -= 3; break;
// Vegetation and stuff
case 2: ter_there = 0; break;
case 3: case 4: ter_there = 1; break;
case 110: case 112: ter_there = 97; break;
case 111: ter_there = 96; break;
case 113: ter_there = 91; break;
case 114: case 37: ter_there = 98; break;
case 115: ter_there = 92; break;
case 118: ter_there = 94; break;
// Artificial stuff - walkways, fences, signs
case 83: ter_there = 82; break;
case 116: case 119: ter_there = 99; break;
case 117: case 120: ter_there = 100; break;
case 121: ter_there = 106; break;
}
warriors_grove->terrain(x,y) = ter_there;
}
}
}
if(med > 0) med--;
}
scenario.shops.push_back(cShop('heal'));
overall_mode = MODE_MAIN_SCREEN;
editing_town = false;
scenario.outdoors.resize(width, height);
for(int x = 0; x < width; x++) {
for(int y = 0; y < height; y++) {
scenario.outdoors[x][y] = new cOutdoors(scenario);
// Add borders
if(x == 0) {
for(int i = 0; i < 48; i++) {
scenario.outdoors[x][y]->terrain[0][i] = grass ? 23 : 5;
scenario.outdoors[x][y]->terrain[1][i] = grass ? 22 : 5;
scenario.outdoors[x][y]->terrain[2][i] = grass ? 22 : 5;
scenario.outdoors[x][y]->terrain[3][i] = grass ? 22 : 5;
if(grass)
scenario.outdoors[x][y]->terrain[4][i] = 36;
}
}
if(x == width - 1) {
for(int i = 0; i < 48; i++) {
scenario.outdoors[x][y]->terrain[47][i] = grass ? 23 : 5;
scenario.outdoors[x][y]->terrain[46][i] = grass ? 22 : 5;
scenario.outdoors[x][y]->terrain[45][i] = grass ? 22 : 5;
scenario.outdoors[x][y]->terrain[44][i] = grass ? 22 : 5;
if(grass)
scenario.outdoors[x][y]->terrain[43][i] = 36;
}
}
if(y == 0) {
for(int i = 0; i < 48; i++) {
scenario.outdoors[x][y]->terrain[i][0] = grass ? 23 : 5;
scenario.outdoors[x][y]->terrain[i][1] = grass ? 22 : 5;
scenario.outdoors[x][y]->terrain[i][2] = grass ? 22 : 5;
scenario.outdoors[x][y]->terrain[i][3] = grass ? 22 : 5;
if(grass && scenario.outdoors[x][y]->terrain[i][4] == 2)
scenario.outdoors[x][y]->terrain[i][4] = 36;
}
}
if(y == height - 1) {
for(int i = 0; i < 48; i++) {
scenario.outdoors[x][y]->terrain[i][47] = grass ? 23 : 5;
scenario.outdoors[x][y]->terrain[i][46] = grass ? 22 : 5;
scenario.outdoors[x][y]->terrain[i][45] = grass ? 22 : 5;
scenario.outdoors[x][y]->terrain[i][44] = grass ? 22 : 5;
if(grass && scenario.outdoors[x][y]->terrain[i][43] == 2)
scenario.outdoors[x][y]->terrain[i][43] = 36;
}
}
// Minor fixup for mountain corners
if(grass) {
if(x == 0 && y == 0) {
scenario.outdoors[x][y]->terrain[0][1] = 23;
scenario.outdoors[x][y]->terrain[0][2] = 23;
scenario.outdoors[x][y]->terrain[0][3] = 23;
}
if(x == 0 && y == height - 1) {
scenario.outdoors[x][y]->terrain[0][46] = 23;
scenario.outdoors[x][y]->terrain[0][45] = 23;
scenario.outdoors[x][y]->terrain[0][44] = 23;
}
if(x == width - 1 && y == 0) {
scenario.outdoors[x][y]->terrain[47][1] = 23;
scenario.outdoors[x][y]->terrain[47][2] = 23;
scenario.outdoors[x][y]->terrain[47][3] = 23;
}
if(x == width - 1 && y == height - 1) {
scenario.outdoors[x][y]->terrain[47][46] = 23;
scenario.outdoors[x][y]->terrain[47][45] = 23;
scenario.outdoors[x][y]->terrain[47][44] = 23;
}
}
current_terrain = scenario.outdoors[x][y];
if(x == 0 || y == 0)
adjust_space(loc(3,3));
if(x == width - 1 || y == height - 1)
adjust_space(loc(44,44));
}
}
cur_out.x = 0;
cur_out.y = 0;
current_terrain = scenario.outdoors[0][0];
current_terrain->terrain[24][24] = grass ? 234 : 232;
current_terrain->terrain[23][23] = grass ? 121 : 106;
if(default_town && warriors_grove) {
scenario.towns.push_back(warriors_grove);
std::swap(scenario.shops, warriors_grove_shops);
}
for(i = 0; i < lg; i++) {
scenario.addTown<cBigTown>();
scenario.towns.back()->town_name = "Large town " + std::to_string(i + 1);
}
for(i = 0; i < med; i++) {
scenario.addTown<cMedTown>();
scenario.towns.back()->town_name = "Medium town " + std::to_string(i + 1);
}
for(i = 0; i < sm; i++) {
scenario.addTown<cTinyTown>();
scenario.towns.back()->town_name = "Small town " + std::to_string(i + 1);
}
cur_town = 0;
town = scenario.towns[0];
update_item_menu();
save_scenario(progDir/filename);
return true;
}
static bool check_location_bounds(cDialog& me, std::string id, bool losing) {
if(!losing) return true;
short town_num = me["town-num"].getTextAsNum();
short dim = me[id].getTextAsNum();
if(dim < 0 || dim >= scenario.towns[town_num]->max_dim()) {
giveError("This coordinate is not inside the bounds of the town.");
return false;
}
return true;
}
static bool set_starting_loc_filter(cDialog& me, std::string, eKeyMod) {
if(me.toast(true)) {
scenario.which_town_start = me["town-num"].getTextAsNum();
scenario.where_start.x = me["town-x"].getTextAsNum();
scenario.where_start.y = me["town-y"].getTextAsNum();
}
return true;
}
void set_starting_loc() {
using namespace std::placeholders;
cDialog loc_dlg("set-start-loc");
loc_dlg["cancel"].attachClickHandler(std::bind(&cDialog::toast, &loc_dlg, false));
loc_dlg["okay"].attachClickHandler(set_starting_loc_filter);
loc_dlg["town-num"].attachFocusHandler(std::bind(check_range, _1, _2, _3, 0, scenario.towns.size() - 1, "The starting town"));
loc_dlg.attachFocusHandlers(check_location_bounds, {"town-x", "town-y"});
loc_dlg["town-num"].setTextToNum(scenario.which_town_start);
loc_dlg["town-x"].setTextToNum(scenario.where_start.x);
loc_dlg["town-y"].setTextToNum(scenario.where_start.y);
loc_dlg.run();
}
static bool save_scenario_events(cDialog& me, std::string, eKeyMod) {
short i;
if(!me.toast(true)) return true;
for(i = 0; i < 10; i++) {
std::string id = std::to_string(i + 1);
scenario.scenario_timers[i].time = me["time" + id].getTextAsNum();
scenario.scenario_timers[i].node = me["node" + id].getTextAsNum();
}
return true;
}
static bool check_scenario_timer_time(cDialog& me, std::string id, bool losing) {
if(!losing) return true;
int val = me[id].getTextAsNum();
if(val > 0 && val % 10 != 0) {
giveError("All scenario event times must be multiples of 10 (e.g. 100, 150, 1000, etc.).");
return false;
}
return true;
}
static bool edit_scenario_events_event_filter(cDialog& me, std::string item_hit, eKeyMod) {
// item_hit is of the form editN; we need an ID of the form nodeN
item_hit.replace(0, 4, "node");
short spec = me[item_hit].getTextAsNum();
if(spec < 0)
spec = get_fresh_spec(0);
if(edit_spec_enc(spec,0,&me))
me[item_hit].setTextToNum(spec);
return true;
}
void edit_scenario_events() {
using namespace std::placeholders;
cDialog evt_dlg("edit-scenario-events");
evt_dlg["okay"].attachClickHandler(save_scenario_events);
for(int i = 0; i < 10; i++) {
std::string id = std::to_string(i + 1);
evt_dlg["time" + id].attachFocusHandler(check_scenario_timer_time);
evt_dlg["node" + id].attachFocusHandler(std::bind(check_range_msg, _1, _2, _3, -1, 255, "The scenario special node", "-1 for no special"));
evt_dlg["edit" + id].attachClickHandler(edit_scenario_events_event_filter);
evt_dlg["time" + id].setTextToNum(scenario.scenario_timers[i].time);
evt_dlg["node" + id].setTextToNum(scenario.scenario_timers[i].node);
}
evt_dlg.run();
}
static void fill_custom_pics_types(cDialog& me, std::vector<ePicType>& pics, pic_num_t first) {
pic_num_t last = first + 9;
if(last >= pics.size()) pics.resize(last + 1, PIC_FULL);
me["num0"].setTextToNum(first);
for(pic_num_t i = first; i <= last; i++) {
std::string id = std::to_string(i - first + 1);
cLedGroup& grp = dynamic_cast<cLedGroup&>(me["type" + id]);
cPict& pic = dynamic_cast<cPict&>(me["pic" + id]);
pic.setPict(i, PIC_CUSTOM_TER);
cControl& num = me["num" + id];
num.setTextToNum(1000 + i);
switch(pics[i]) {
case PIC_TER:
grp.setSelected("ter" + id);
break;
case PIC_TER_ANIM:
grp.setSelected("anim" + id);
num.setTextToNum(2000 + i);
break;
case PIC_TER_MAP:
grp.setSelected("map" + id);
break;
case PIC_MONST:
grp.setSelected("monst-sm" + id);
break;
case PIC_MONST_WIDE:
grp.setSelected("monst-wide" + id);
num.setTextToNum(2000 + i);
break;
case PIC_MONST_TALL:
grp.setSelected("monst-tall" + id);
num.setTextToNum(3000 + i);
break;
case PIC_MONST_LG:
grp.setSelected("monst-lg" + id);
num.setTextToNum(4000 + i);
break;
case PIC_DLOG:
grp.setSelected("dlog" + id);
break;
case PIC_DLOG_LG:
grp.setSelected("dlog-lg" + id);
break;
case PIC_TALK:
grp.setSelected("talk" + id);
pic.setPict(i, PIC_CUSTOM_TALK);
break;
case PIC_ITEM:
grp.setSelected("item" + id);
break;
case PIC_BOOM:
grp.setSelected("boom" + id);
break;
case PIC_MISSILE:
grp.setSelected("miss" + id);
break;
case PIC_FULL:
grp.setSelected("none" + id);
break;
}
}
}
static bool set_custom_pic_type(cDialog& me, std::string hit, std::vector<ePicType>& pics, pic_num_t first) {
hit = dynamic_cast<cLedGroup&>(me[hit]).getSelected();
size_t iNum = hit.find_last_not_of("0123456789");
std::string id = hit.substr(iNum + 1);
hit = hit.substr(0, iNum + 1);
pic_num_t pic = boost::lexical_cast<int>(id) + first - 1;
cControl& num = me["num" + id];
num.setTextToNum(1000 + pic);
if(hit == "ter") {
pics[pic] = PIC_TER;
} else if(hit == "anim") {
pics[pic] = PIC_TER_ANIM;
num.setTextToNum(2000 + pic);
} else if(hit == "map") {
pics[pic] = PIC_TER_MAP;
} else if(hit == "monst-sm") {
pics[pic] = PIC_MONST;
} else if(hit == "monst-wide") {
pics[pic] = PIC_MONST_WIDE;
num.setTextToNum(2000 + pic);
} else if(hit == "monst-tall") {
pics[pic] = PIC_MONST_TALL;
num.setTextToNum(3000 + pic);
} else if(hit == "monst-lg") {
pics[pic] = PIC_MONST_LG;
num.setTextToNum(4000 + pic);
} else if(hit == "dlog") {
pics[pic] = PIC_DLOG;
} else if(hit == "dlog-lg") {
pics[pic] = PIC_DLOG_LG;
} else if(hit == "talk") {
pics[pic] = PIC_TALK;
} else if(hit == "item") {
pics[pic] = PIC_ITEM;
} else if(hit == "boom") {
pics[pic] = PIC_BOOM;
} else if(hit == "miss") {
pics[pic] = PIC_MISSILE;
} else if(hit == "none") {
pics[pic] = PIC_FULL;
}
return true;
}
static bool save_pics_types(cDialog& me, const std::vector<ePicType>& pics) {
if(!me.toast(true)) return true;
scenario.custom_graphics = pics;
return true;
}
static bool change_pics_page(cDialog& me, std::string hit, std::vector<ePicType>& pics, pic_num_t& first) {
size_t num_pics = spec_scen_g.count();
if(hit == "left") {
if(first == 0) first = ((num_pics - 1) / 10) * 10;
else first -= 10;
} else if(hit == "right") {
if(first + 10 >= num_pics) first = 0;
else first += 10;
} else return true;
fill_custom_pics_types(me, pics, first);
return true;
}
void edit_custom_pics_types() {
if(spec_scen_g.count() == 0) {
giveError("You don't have any custom graphics to classify!");
return;
}
using namespace std::placeholders;
std::vector<ePicType> pics = scenario.custom_graphics;
pic_num_t first_pic = 0;
cDialog pic_dlg("graphic-types");
for(int i = 0; i < 10; i++) {
std::string id = std::to_string(i + 1);
pic_dlg["type" + id].attachFocusHandler(std::bind(set_custom_pic_type, _1, _2, std::ref(pics), std::ref(first_pic)));
}
pic_dlg["okay"].attachClickHandler(std::bind(save_pics_types, _1, std::ref(pics)));
pic_dlg["cancel"].attachClickHandler(std::bind(&cDialog::toast, _1, false));
pic_dlg.attachClickHandlers(std::bind(change_pics_page, _1, _2, std::ref(pics), std::ref(first_pic)), {"left", "right"});
fill_custom_pics_types(pic_dlg, pics, first_pic);
if(spec_scen_g.count() <= 10) {
pic_dlg["left"].hide();
pic_dlg["right"].hide();
}
pic_dlg.run();
}
Reference in New Issue View Git Blame Copy Permalink