openboe/oboe
2
0
Fork 0
Code Issues 146 Pull Requests 4 Actions Packages Projects Releases Wiki Activity
Files
bd6506f3530feb1004636aa3f1ba0f166e8d5eb0
oboe/src/boe.town.cpp

1589 lines
53 KiB
C++
Raw Blame History

#include <cstdio>
#include <queue>
#include "boe.global.hpp"
#include "universe.hpp"
#include "boe.graphutil.hpp"
#include "boe.graphics.hpp"
#include "boe.newgraph.hpp"
#include "boe.fileio.hpp"
#include "boe.items.hpp"
#include "boe.itemdata.hpp"
#include "boe.monster.hpp"
#include "boe.town.hpp"
#include "boe.combat.hpp"
#include "boe.party.hpp"
#include "boe.text.hpp"
#include "soundtool.hpp"
#include "boe.locutils.hpp"
#include "boe.specials.hpp"
#include "boe.infodlg.hpp"
#include "mathutil.hpp"
#include "boe.main.hpp"
#include "graphtool.hpp"
#include "dlogutil.hpp"
#include "fileio.hpp"
#include "winutil.hpp"
extern short stat_window,store_spell_target,which_combat_type,current_pc,combat_active_pc;
extern eGameMode overall_mode;
extern location center;
extern sf::RenderWindow mainPtr;
extern short store_current_pc,current_ground;
extern eGameMode store_pre_shop_mode,store_pre_talk_mode;
extern std::queue<pending_special_type> special_queue;
extern bool map_visible,diff_depth_ok;
extern sf::RenderWindow mini_map;
extern location hor_vert_place[14];
extern location diag_place[14];
extern location golem_m_locs[16];
extern cUniverse univ;
extern sf::Texture anim_gworld;
extern sf::Texture terrain_gworld[NUM_TER_SHEETS];
extern cCustomGraphics spec_scen_g;
bool need_map_full_refresh = true,forcing_map_button_redraw = false;
extern sf::RenderTexture map_gworld;
extern sf::Texture small_ter_gworld;
// In the 0..65535 range, this colour was {65535,65535,52428}
sf::Color parchment = {255,255,205};
long pause_dummy;
location town_map_adj;
short town_force = 200,store_which_shop,store_min,store_max,store_shop,store_selling_pc;
short sell_offset = 0;
location town_force_loc;
bool shop_button_active[12];
rectangle map_title_rect = {3,50,15,300};
rectangle map_bar_rect = {15,50,27,300};
void force_town_enter(short which_town,location where_start) {
town_force = which_town;
town_force_loc = where_start;
}
//short entry_dir; // if 9, go to forced
void start_town_mode(short which_town, short entry_dir) {
short i,m,n;
short j,k,town_number;
short at_which_save_slot,former_town;
bool monsters_loaded = false,town_toast = false;
location loc;
unsigned short temp;
bool play_town_sound = false;
if(town_force < 200)
which_town = town_force;
else play_town_sound = true;
former_town = town_number = which_town;
if(town_number < 0 || town_number >= univ.scenario.towns.size()) {
showError("The scenario tried to put you into a town that doesn't exist.",
"Requested town: " + std::to_string(town_number) + "|Max town: " + std::to_string(univ.scenario.towns.size()));
return;
}
// Now adjust town number as necessary.
for(i = 0; i < univ.scenario.town_mods.size(); i++)
if(univ.scenario.town_mods[i].spec >= 0 && univ.scenario.town_mods[i].spec < 200 &&
town_number == univ.scenario.town_mods[i].spec &&
univ.party.sd_legit(univ.scenario.town_mods[i].x,univ.scenario.town_mods[i].y)) {
former_town = town_number;
town_number += PSD[univ.scenario.town_mods[i].x][univ.scenario.town_mods[i].y];
// Now update horses & boats
for(i = 0; i < univ.party.horses.size(); i++)
if((univ.party.horses[i].exists) && (univ.party.horses[i].which_town == former_town))
univ.party.horses[i].which_town = town_number;
for(i = 0; i < univ.party.boats.size(); i++)
if((univ.party.boats[i].exists) && (univ.party.boats[i].which_town == former_town))
univ.party.boats[i].which_town = town_number;
}
if(town_number < 0 || town_number >= univ.scenario.towns.size()) {
showError("The scenario tried to put you into a town that doesn't exist.",
"Requested town: " + std::to_string(former_town) + "|Adjusted town: " + std::to_string(town_number) + "|Max town: " + std::to_string(univ.scenario.towns.size()));
return;
}
overall_mode = MODE_TOWN;
univ.town.num = town_number;
if(play_town_sound) {
if(univ.town->lighting_type > 0)
play_sound(95);
else play_sound(16);
}
// TODO: This means cleared webs reappear, for example. Is that right?
univ.town.place_preset_fields();
univ.town.belt_present = false;
// Set up map, using stored map
for(i = 0; i < univ.town->max_dim(); i++)
for(j = 0; j < univ.town->max_dim(); j++) {
if(univ.town_maps[univ.town.num][i / 8][j] & (char)(1 << i % 8))
make_explored(i,j);
if(univ.town->terrain(i,j) == 0)
current_ground = 0;
else if(univ.town->terrain(i,j) == 2)
current_ground = 2;
if(univ.scenario.ter_types[univ.town->terrain(i,j)].special == eTerSpec::CONVEYOR)
univ.town.belt_present = true;
}
univ.town.monst.which_town = town_number;
univ.town.monst.hostile = false;
at_which_save_slot = univ.party.at_which_save_slot;
for(i = 0; i < 4; i++)
if(town_number == univ.party.creature_save[i].which_town) {
univ.town.monst = univ.party.creature_save[i];
monsters_loaded = true;
for(j = 0; j < univ.town.monst.size(); j++) {
if(loc_off_act_area(univ.town.monst[j].cur_loc))
univ.town.monst[j].active = 0;
if(univ.town.monst[j].active == 2)
univ.town.monst[j].active = 1;
univ.town.monst[j].cur_loc = univ.town.monst[j].start_loc;
univ.town.monst[j].health = univ.town.monst[j].m_health;
univ.town.monst[j].mp = univ.town.monst[j].max_mp;
univ.town.monst[j].morale = univ.town.monst[j].m_morale;
univ.town.monst[j].status.clear();
if(univ.town.monst[j].summon_time > 0)
univ.town.monst[j].active = 0;
univ.town.monst[j].target = 6;
// Bonus SP and HP wear off
if(univ.town.monst[i].mp > univ.town.monst[i].max_mp)
univ.town.monst[i].mp = univ.town.monst[i].max_mp;
if(univ.town.monst[i].health > univ.town.monst[i].m_health)
univ.town.monst[i].health = univ.town.monst[i].m_health;
}
// Now, travelling NPCs might have arrived. Go through and put them in.
// These should have protected status (i.e. spec1 >= 200, spec1 <= 204)
for(j = 0; j < univ.town.monst.size(); j++) {
switch(univ.town.monst[j].time_flag){
case eMonstTime::ALWAYS: break; // Nothing to do.
case eMonstTime::SOMETIMES_A: case eMonstTime::SOMETIMES_B: case eMonstTime::SOMETIMES_C:
if((univ.party.calc_day() % 3) + 3 != int(univ.town.monst[j].time_flag))
univ.town.monst[j].active = 0;
else {
univ.town.monst[j].active = 1;
univ.town.monst[j].spec_enc_code = 0;
univ.town.monst[j].cur_loc = univ.town.monst[j].start_loc;
univ.town.monst[j].health = univ.town.monst[j].m_health;
}
break ;
// Now, appearing/disappearing monsters might have arrived/disappeared.
case eMonstTime::APPEAR_ON_DAY:
if(day_reached(univ.town.monst[j].monster_time, univ.town.monst[j].time_code)) {
univ.town.monst[j].active = 1;
univ.town.monst[j].time_flag = eMonstTime::ALWAYS;
}
break;
case eMonstTime::DISAPPEAR_ON_DAY:
if(day_reached(univ.town.monst[j].monster_time, univ.town.monst[j].time_code)) {
univ.town.monst[j].active = 0;
univ.town.monst[j].time_flag = eMonstTime::ALWAYS;
}
break;
case eMonstTime::APPEAR_WHEN_EVENT:
if(univ.party.key_times.find(univ.town.monst[j].time_code) == univ.party.key_times.end())
break; // Event hasn't happened yet
if(univ.party.calc_day() >= univ.party.key_times[univ.town.monst[j].time_code]){ //calc_day is used because of the "definition" of univ.party.key_times
univ.town.monst[j].active = 1;
univ.town.monst[j].time_flag = eMonstTime::ALWAYS;
}
break;
case eMonstTime::DISAPPEAR_WHEN_EVENT:
if(univ.party.key_times.find(univ.town.monst[j].time_code) == univ.party.key_times.end())
break; // Event hasn't happened yet
if(univ.party.calc_day() >= univ.party.key_times[univ.town.monst[j].time_code]){
univ.town.monst[j].active = 0;
univ.town.monst[j].time_flag = eMonstTime::ALWAYS;
}
break;
case eMonstTime::APPEAR_AFTER_CHOP:
// TODO: Should these two cases be separated?
if(univ.town->town_chop_time > 0 && day_reached(univ.town->town_chop_time,univ.town->town_chop_key))
univ.town.monst[i].active += 10;
else if(univ.town->is_cleaned_out(univ.party.m_killed[univ.town.num]))
univ.town.monst[i].active += 10;
else univ.town.monst[i].active = 0;
if(univ.town.monst[i].active >= 10)
univ.town.monst[i].time_flag = eMonstTime::ALWAYS;
break;
}
}
for(j = 0; j < univ.town->max_dim(); j++)
for(k = 0; k < univ.town->max_dim(); k++) { // now load in saved setup,
// except that pushable things restore to orig locs
temp = univ.party.setup[i][j][k] << 8;
temp &= ~(OBJECT_CRATE | OBJECT_BARREL | OBJECT_BLOCK);
univ.town.fields[j][k] |= temp;
}
}
if(!monsters_loaded) {
for(i = 0; i < univ.town->creatures.size(); i++){
if(univ.town->creatures[i].number == 0) {
if(i >= univ.town.monst.size()) continue;
univ.town.monst[i].active = 0;
univ.town.monst[i].number = 0;
univ.town.monst[i].time_flag = eMonstTime::ALWAYS;
univ.town.monst[i].cur_loc.x = 80;
}
else {
// First set up the values.
cTownperson& preset = univ.town->creatures[i];
univ.town.monst.assign(i, preset, univ.scenario.scen_monsters[preset.number], PSD[SDF_EASY_MODE], univ.difficulty_adjust());
if(univ.town.monst[i].spec_enc_code > 0)
univ.town.monst[i].active = 0;
// Now, if necessary, fry the monster.
switch(univ.town.monst[i].time_flag) {
case eMonstTime::APPEAR_ON_DAY:
if(!day_reached(univ.town.monst[i].monster_time, univ.town.monst[i].time_code))
univ.town.monst[i].active = 0;
break;
case eMonstTime::DISAPPEAR_ON_DAY:
if(day_reached(univ.town.monst[i].monster_time, univ.town.monst[i].time_code))
univ.town.monst[i].active = 0;
break;
case eMonstTime::SOMETIMES_A: case eMonstTime::SOMETIMES_B: case eMonstTime::SOMETIMES_C:
if((univ.party.calc_day() % 3) + 3 != int(univ.town.monst[i].time_flag)) {
univ.town.monst[i].active = 0;
}
else {
univ.town.monst[i].active = 1;
}
break;
case eMonstTime::APPEAR_WHEN_EVENT:
if(univ.party.key_times.find(univ.town.monst[j].time_code) == univ.party.key_times.end())
univ.town.monst[i].active = 0; // Event hasn't happened yet
else if(univ.party.calc_day() < univ.party.key_times[univ.town.monst[i].time_code])
univ.town.monst[i].active = 0; // This would only be reached if the time was set back (or in a legacy save)
break;
case eMonstTime::DISAPPEAR_WHEN_EVENT:
if(univ.party.key_times.find(univ.town.monst[j].time_code) == univ.party.key_times.end())
break; // Event hasn't happened yet
if(univ.party.calc_day() >= univ.party.key_times[univ.town.monst[i].time_code])
univ.town.monst[i].active = 0;
break;
case eMonstTime::APPEAR_AFTER_CHOP:
// TODO: Should these two cases be separated?
if(univ.town->town_chop_time > 0 && day_reached(univ.town->town_chop_time,univ.town->town_chop_key))
univ.town.monst[i].active += 10;
else if(univ.town->is_cleaned_out(univ.party.m_killed[univ.town.num]))
univ.town.monst[i].active += 10;
else univ.town.monst[i].active = 0;
break;
case eMonstTime::ALWAYS:
break;
}
if(univ.town.monst[i].active) {
// In forcecage?
if(univ.town.is_force_cage(univ.town.monst[i].cur_loc.x, univ.town.monst[i].cur_loc.y))
univ.town.monst[i].status[eStatus::FORCECAGE] = 1000;
}
}
}
}
// Now munch all large monsters that are misplaced
// only large monsters, as some smaller monsters are intentionally placed
// where they cannot be
for(i = 0; i < univ.town.monst.size(); i++) {
if(univ.town.monst[i].active > 0)
if(((univ.town.monst[i].x_width > 1) || (univ.town.monst[i].y_width > 1)) &&
!monst_can_be_there(univ.town.monst[i].cur_loc,i))
univ.town.monst[i].active = 0;
}
// Thrash town?
if(univ.town->is_cleaned_out(univ.party.m_killed[univ.town.num])) {
town_toast = true;
add_string_to_buf("Area has been cleaned out.");
}
if(univ.town->town_chop_time > 0) {
if(day_reached(univ.town->town_chop_time,univ.town->town_chop_key)) {
add_string_to_buf("Area has been abandoned.");
for(i = 0; i < univ.town.monst.size(); i++)
if((univ.town.monst[i].active > 0) && (univ.town.monst[i].active < 10) &&
!univ.town.monst[i].is_friendly())
univ.town.monst[i].active += 10;
town_toast = true;
}
}
if(town_toast) {
for(i = 0; i < univ.town.monst.size(); i++)
if(univ.town.monst[i].active >= 10)
univ.town.monst[i].active -= 10;
else univ.town.monst[i].active = 0;
}
handle_town_specials(town_number, (short) town_toast,(entry_dir < 9) ? univ.town->start_locs[entry_dir] : town_force_loc);
// Flush excess doomguards and viscous goos
for(i = 0; i < univ.town.monst.size(); i++)
if((univ.town.monst[i].abil[eMonstAbil::SPLITS].active) &&
(i >= univ.town->creatures.size() || univ.town.monst[i].number != univ.town->creatures[i].number))
univ.town.monst[i].active = 0;
// Set up field booleans, correct for doors
for(j = 0; j < univ.town->max_dim(); j++)
for(k = 0; k < univ.town->max_dim(); k++) {
loc.x = j; loc.y = k;
if(is_door(loc)) {
univ.town.set_web(j,k,false);
univ.town.set_crate(j,k,false);
univ.town.set_barrel(j,k,false);
univ.town.set_fire_barr(j,k,false);
univ.town.set_force_barr(j,k,false);
univ.town.set_quickfire(j,k,false);
}
if(univ.town.is_quickfire(j,k))
univ.town.quickfire_present = true;
}
// Set up items, maybe place items already there
univ.town.items.clear();
for(j = 0; j < 3; j++)
if(univ.scenario.store_item_towns[j] == town_number) {
univ.town.items = univ.party.stored_items[j];
}
for(i = 0; i < univ.town->preset_items.size(); i++)
if((univ.town->preset_items[i].code >= 0)
&& (((univ.party.item_taken[univ.town.num][i / 8] & (1 << i % 8)) == 0) ||
(univ.town->preset_items[i].always_there))) {
j = univ.town.items.size();
// place the preset item, if party hasn't gotten it already
univ.town.items.push_back(get_stored_item(univ.town->preset_items[i].code));
// Don't place special items if already in the party's possession
if(univ.town.items[j].variety == eItemType::SPECIAL && univ.party.spec_items.count(univ.town.items[j].item_level))
break;
// Don't place quest items if party already started
if(univ.town.items[j].variety == eItemType::QUEST && univ.party.quest_status[univ.town.items[j].item_level] != eQuestStatus::AVAILABLE)
break;
univ.town.items[j].item_loc = univ.town->preset_items[i].loc;
// Not use the items data flags, starting with forcing an ability
if(univ.town->preset_items[i].ability >= 0) {
// TODO: What other ways might there be to use this?
switch(univ.town.items[j].variety) {
case eItemType::ONE_HANDED:
case eItemType::TWO_HANDED: {
if(univ.town->preset_items[i].ability > int(eEnchant::BLESSED))
break;
// TODO: This array and accompanying calculation is now duplicated here and in place_buy_button()
const short aug_cost[10] = {4,7,10,8, 15,15,10, 0,0,0};
int ench = univ.town->preset_items[i].ability;
int val = max(aug_cost[ench] * 100, univ.town.items[j].value * (5 + aug_cost[ench]));
univ.town.items[j].enchant_weapon(eEnchant(ench), val);
break;
}
default: break; // Silence compiler warning
}
}
if(univ.town->preset_items[i].charges > 0) {
eItemType variety = univ.town.items[j].variety;
if(univ.town.items[j].charges > 0)
univ.town.items[j].charges = univ.town->preset_items[i].charges;
else if(variety == eItemType::GOLD || variety == eItemType::FOOD)
univ.town.items[j].item_level = univ.town->preset_items[i].charges;
}
if(town_toast)
univ.town.items[j].property = false;
else
univ.town.items[j].property = univ.town->preset_items[i].property;
univ.town.items[j].contained = univ.town->preset_items[i].contained;
int x = univ.town.items[j].item_loc.x, y = univ.town.items[j].item_loc.y;
if(univ.town.items[j].contained && (univ.town.is_barrel(x,y) || univ.town.is_crate(x,y)))
univ.town.items[j].held = true;
univ.town.items[j].is_special = i + 1;
}
for(i = 0; i < univ.town.monst.size(); i++)
if(loc_off_act_area(univ.town.monst[i].cur_loc))
univ.town.monst[i].active = 0;
for(i = 0; i < univ.town.items.size(); i++)
if(loc_off_act_area(univ.town.items[i].item_loc))
univ.town.items[i].variety = eItemType::NO_ITEM;
// Clean out unwanted monsters
for(i = 0; i < univ.town.monst.size(); i++)
if(univ.party.sd_legit(univ.town.monst[i].spec1,univ.town.monst[i].spec2)) {
if(PSD[univ.town.monst[i].spec1][univ.town.monst[i].spec2] > 0)
univ.town.monst[i].active = 0;
}
erase_specials();
// make_town_trim(0);
univ.town.p_loc = (entry_dir < 9) ? univ.town->start_locs[entry_dir] : town_force_loc;
center = univ.town.p_loc;
if(univ.party.in_boat >= 0) {
univ.party.boats[univ.party.in_boat].which_town = which_town;
univ.party.boats[univ.party.in_boat].loc = univ.town.p_loc;
}
if(univ.party.in_horse >= 0) {
univ.party.horses[univ.party.in_horse].which_town = which_town;
univ.party.horses[univ.party.in_horse].loc = univ.town.p_loc;
}
// End flying
if(univ.party.status[ePartyStatus::FLIGHT] > 0) {
univ.party.status[ePartyStatus::FLIGHT] = 0;
add_string_to_buf("You land, and enter. ");
}
// No hostile monsters present.
PSD[SDF_HOSTILES_PRESENT] = 0;
add_string_to_buf("Now entering:");
add_string_to_buf(" " + univ.town->town_name);
// clear entry space, and check exploration
univ.town.set_web(univ.town.p_loc.x,univ.town.p_loc.y,false);
univ.town.set_crate(univ.town.p_loc.x,univ.town.p_loc.y,false);
univ.town.set_barrel(univ.town.p_loc.x,univ.town.p_loc.y,false);
univ.town.set_fire_barr(univ.town.p_loc.x,univ.town.p_loc.y,false);
univ.town.set_force_barr(univ.town.p_loc.x,univ.town.p_loc.y,false);
univ.town.set_quickfire(univ.town.p_loc.x,univ.town.p_loc.y,false);
update_explored(univ.town.p_loc);
// If a PC dead, drop his items
for(m = 0; m < 6; m++) {
if(univ.party[m].main_status == eMainStatus::ALIVE || isSplit(univ.party[m].main_status))
continue;
for(n = 0; n < 24; n++)
if(univ.party[m].items[n].variety != eItemType::NO_ITEM) {
place_item(univ.party[m].items[n],univ.town.p_loc);
univ.party[m].items[n].variety = eItemType::NO_ITEM;
}
}
for(i = 0; i < univ.town.monst.size(); i++) {
univ.town.monst[i].targ_loc.x = 0;
univ.town.monst[i].targ_loc.y = 0;
}
// check horses
for(i = 0; i < univ.party.boats.size(); i++) {
if(univ.scenario.boats[i].which_town >= 0 && univ.scenario.boats[i].loc.x >= 0) {
if(!univ.party.boats[i].exists) {
univ.party.boats[i] = univ.scenario.boats[i];
univ.party.boats[i].exists = true;
}
}
}
for(i = 0; i < univ.party.horses.size(); i++) {
if(univ.scenario.horses[i].which_town >= 0 && univ.scenario.horses[i].loc.x >= 0) {
if(!univ.party.horses[i].exists) {
univ.party.horses[i] = univ.scenario.horses[i];
univ.party.horses[i].exists = true;
}
}
}
clear_map();
reset_item_max();
town_force = 200;
// TODO: One problem with this - it paints the terrain after the town entry dialog is dismissed
// ... except it actually doesn't, because the town enter special is only queued, not run immediately.
draw_terrain(1);
}
location end_town_mode(short switching_level,location destination) { // returns new party location
location to_return;
bool data_saved = false,combat_end = false;
short i,j,k;
if(is_combat())
combat_end = true;
// Bonus SP and HP wear off
for(i = 0; i < 6; i++) {
if(univ.party[i].cur_sp > univ.party[i].max_sp)
univ.party[i].cur_sp = univ.party[i].max_sp;
if(univ.party[i].cur_health > univ.party[i].max_health)
univ.party[i].cur_health = univ.party[i].max_health;
}
if(overall_mode == MODE_TOWN) {
for(i = 0; i < 4; i++)
if(univ.party.creature_save[i].which_town == univ.town.num) {
univ.party.creature_save[i] = univ.town.monst;
for(j = 0; j < univ.town->max_dim(); j++)
for(k = 0; k < univ.town->max_dim(); k++)
univ.party.setup[i][j][k] = (univ.town.fields[j][k] & 0xff00) >> 8;
data_saved = true;
}
if(!data_saved) {
univ.party.creature_save[univ.party.at_which_save_slot] = univ.town.monst;
for(j = 0; j < univ.town->max_dim(); j++)
for(k = 0; k < univ.town->max_dim(); k++)
univ.party.setup[univ.party.at_which_save_slot][j][k] = (univ.town.fields[j][k] & 0xff00) >> 8;
univ.party.at_which_save_slot = (univ.party.at_which_save_slot == 3) ? 0 : univ.party.at_which_save_slot + 1;
}
// Store items, if necessary
for(j = 0; j < 3; j++)
if(univ.scenario.store_item_towns[j] == univ.town.num) {
univ.party.stored_items[j].clear();
for(i = 0; i < univ.town.items.size(); i++)
if(univ.town.items[i].variety != eItemType::NO_ITEM && univ.town.items[i].is_special == 0 &&
univ.town.items[i].item_loc.x >= univ.scenario.store_item_rects[j].left &&
univ.town.items[i].item_loc.x <= univ.scenario.store_item_rects[j].right &&
univ.town.items[i].item_loc.y >= univ.scenario.store_item_rects[j].top &&
univ.town.items[i].item_loc.y <= univ.scenario.store_item_rects[j].bottom) {
univ.party.stored_items[j].push_back(univ.town.items[i]);
}
}
// Now store map
for(i = 0; i < univ.town->max_dim(); i++)
for(j = 0; j < univ.town->max_dim(); j++)
if(is_explored(i,j)) {
univ.town_maps[univ.town.num][i / 8][j] = univ.town_maps[univ.town.num][i / 8][j] |
(char) (1 << i % 8);
}
to_return = univ.party.p_loc;
erase_if(univ.party.party_event_timers, [](const cTimer& t) {
return t.node_type == 2;
});
}
// Check for exit specials, if leaving town
if(switching_level == 0) {
to_return = univ.party.p_loc;
if(is_town()) {
if(destination.x <= univ.town->in_town_rect.left) {
if(univ.town->exit_locs[1].x > 0)
to_return = local_to_global(univ.town->exit_locs[1]);
else to_return.x--;
univ.party.p_loc = to_return; univ.party.p_loc.x++;
handle_leave_town_specials(univ.town.num, univ.town->exit_specs[1],destination) ;
}
else if(destination.x >= univ.town->in_town_rect.right) {
if(univ.town->exit_locs[3].x > 0)
to_return = local_to_global(univ.town->exit_locs[3]);
else to_return.x++;
univ.party.p_loc = to_return; univ.party.p_loc.x--;
handle_leave_town_specials(univ.town.num, univ.town->exit_specs[3],destination) ;
}
else if(destination.y <= univ.town->in_town_rect.top) {
if(univ.town->exit_locs[0].x > 0)
to_return = local_to_global(univ.town->exit_locs[0]);
else to_return.y--;
univ.party.p_loc = to_return; univ.party.p_loc.y++;
handle_leave_town_specials(univ.town.num, univ.town->exit_specs[0],destination) ;
}
else if(destination.y >= univ.town->in_town_rect.bottom) {
if(univ.town->exit_locs[2].x > 0)
to_return = local_to_global(univ.town->exit_locs[2]);
else to_return.y++;
univ.party.p_loc = to_return; univ.party.p_loc.y--;
handle_leave_town_specials(univ.town.num, univ.town->exit_specs[2],destination) ;
}
}
}
if(switching_level == 0) {
fix_boats();
overall_mode = MODE_OUTDOORS;
erase_out_specials();
univ.party.status[ePartyStatus::STEALTH] = 0;
univ.party.status[ePartyStatus::DETECT_LIFE] = 0; // TODO: Yes? No? Maybe?
for(i = 0; i < 6; i++)
erase_if(univ.party[i].status, [](std::pair<const eStatus, short> kv) -> bool {
if(kv.first == eStatus::POISON) return false;
if(kv.first == eStatus::DISEASE) return false;
if(kv.first == eStatus::DUMB) return false;
if(kv.first == eStatus::ACID && kv.second > 2)
return false;
return true;
});
update_explored(to_return);
redraw_screen(REFRESH_TERRAIN | REFRESH_TEXT);
}
if(!combat_end)
clear_map();
univ.town.num = 200; // should be harmless...
return to_return;
}
void handle_town_specials(short /*town_number*/, bool town_dead,location /*start_loc*/) {
queue_special(eSpecCtx::ENTER_TOWN, 2, town_dead ? univ.town->spec_on_entry_if_dead : univ.town->spec_on_entry, univ.town.p_loc);
}
void handle_leave_town_specials(short /*town_number*/, short which_spec,location /*start_loc*/) {
queue_special(eSpecCtx::LEAVE_TOWN, 2, which_spec, univ.party.p_loc);
}
bool abil_exists(eItemAbil abil) { // use when outdoors
short i,j;
for(i = 0; i < 6; i++)
for(j = 0; j < 24; j++)
if(univ.party[i].items[j].variety != eItemType::NO_ITEM && univ.party[i].items[j].ability == abil)
return true;
for(i = 0; i < 3; i++)
for(j = 0; j < univ.town.items.size(); j++)
if(univ.party.stored_items[i][j].variety != eItemType::NO_ITEM && univ.party.stored_items[i][j].ability == abil)
return true;
return false;
}
void start_town_combat(eDirection direction) {
short i;
place_party(direction);
if(current_pc == 6)
for(i = 0; i < 6; i++)
if(univ.party[i].main_status == eMainStatus::ALIVE) {
current_pc = i;
break;
}
center = univ.party[current_pc].combat_pos;
which_combat_type = 1;
overall_mode = MODE_COMBAT;
combat_active_pc = 6;
for(i = 0; i < univ.town.monst.size(); i++)
univ.town.monst[i].target = 6;
for(i = 0; i < 6; i++) {
univ.party[i].last_attacked = nullptr;
univ.party[i].parry = 0;
univ.party[i].direction = direction;
univ.party[current_pc].direction = direction;
if(univ.party[i].main_status == eMainStatus::ALIVE)
update_explored(univ.party[i].combat_pos);
}
store_current_pc = current_pc;
current_pc = 0;
set_pc_moves();
pick_next_pc();
center = univ.party[current_pc].combat_pos;
draw_buttons(0);
put_pc_screen();
set_stat_window(current_pc);
give_help(48,49);
}
eDirection end_town_combat() {
short num_tries = 0,r1,i;
int in_cage = 0;
location cage_loc;
bool same_cage = true;
for(int i = 0; i < 6; i++) {
if(univ.party[i].status[eStatus::FORCECAGE] > 0) {
if(in_cage == 0)
cage_loc = univ.party[i].get_loc();
in_cage++;
}
if(univ.party[i].get_loc() != cage_loc)
same_cage = false;
}
if(in_cage != 0 && in_cage != univ.party.count() && !same_cage) {
add_string_to_buf(" Someone trapped.");
return DIR_HERE;
}
// TODO: Don't allow ending combat if two PCs are separated by an impassable wall with no way around it
r1 = get_ran(1,0,5);
while(univ.party[r1].main_status != eMainStatus::ALIVE && num_tries++ < 1000)
r1 = get_ran(1,0,5);
univ.town.p_loc = univ.party[r1].combat_pos;
overall_mode = MODE_TOWN;
current_pc = store_current_pc;
if(univ.party[current_pc].main_status != eMainStatus::ALIVE)
current_pc = first_active_pc();
for(i = 0; i < 6; i++) {
univ.party[i].parry = 0;
univ.party[i].combat_pos = {-1,-1};
}
return univ.party[r1].direction;
}
void place_party(short direction) {
bool in_cage = false;
for(int n = 0; n < 6; n++)
if(univ.party[n].status[eStatus::FORCECAGE])
in_cage = true;
if(in_cage) {
for(int n = 0; n < 6; n++)
univ.party[n].combat_pos = univ.town.p_loc;
return;
}
bool spot_ok[14] = {true,true,true,true,true,true,true,
true,true,true,true,true,true,true};
location pos_locs[14];
location check_loc;
short x_adj,y_adj,how_many_ok = 1,where_in_a = 0,i;
for(i = 0; i < 14; i++) {
check_loc = univ.town.p_loc;
if(direction % 4 < 2)
x_adj = ((direction % 2 == 0) ? hor_vert_place[i].x : diag_place[i].x);
else x_adj = ((direction % 2 == 0) ? hor_vert_place[i].y : diag_place[i].y);
if(direction % 2 == 0)
x_adj = (direction < 4) ? x_adj : -1 * x_adj;
else x_adj = ((direction == 1) || (direction == 7)) ? -1 * x_adj : x_adj;
check_loc.x -= x_adj;
if(direction % 4 < 2)
y_adj = ((direction % 2 == 0) ? hor_vert_place[i].y : diag_place[i].y);
else y_adj = ((direction % 2 == 0) ? hor_vert_place[i].x : diag_place[i].x);
if(direction % 2 == 0)
y_adj = ((direction > 1) && (direction < 6)) ? y_adj : -1 * y_adj;
else y_adj = ((direction == 3) || (direction == 1)) ? -1 * y_adj : y_adj;
check_loc.y -= y_adj;
pos_locs[i] = check_loc;
if(!is_blocked(check_loc) && !is_special(check_loc) && sight_obscurity(check_loc.x,check_loc.y) == 0
&& can_see_light(univ.town.p_loc,check_loc,combat_obscurity) < 1 && !loc_off_act_area(check_loc)) {
spot_ok[i] = true;
how_many_ok += (i > 1) ? 1 : 0;
}
else spot_ok[i] = false;
if(i == 0)
spot_ok[i] = true;
}
i = 0;
while(i < 6) {
if(univ.party[i].main_status == eMainStatus::ALIVE) {
if(how_many_ok == 1)
univ.party[i].combat_pos = pos_locs[where_in_a];
else {
univ.party[i].combat_pos = pos_locs[where_in_a];
if(how_many_ok > 1)
where_in_a++;
how_many_ok--;
// if(how_many_ok > 1) {
while(!spot_ok[where_in_a] && where_in_a < 14)
where_in_a++;
// }
}
}
i++;
}
}
// spec_code is encounter's spec_code
void create_out_combat_terrain(short ter_type,short num_walls,short /*spec_code*/) {
short i,j,k,r1,arena;
static const short ter_base[20] = {
2,0,36,50,71, 0,0,0, 0,2,
2,2, 2, 0, 0, 36,0,2, 0,2,
};
static const location special_ter_locs[15] = {
loc(11,10),loc(11,14),loc(10,20),loc(11,26),loc(9,30),
loc(15,19),loc(23,19),loc(19,29),loc(20,11),loc(28,16),
loc(28,24),loc(27,19),loc(27,29),loc(15,28),loc(19,19),
};
static const ter_num_t cave_pillar[4][4] = {
{0 ,14,11,1 },
{14,19,20,11},
{17,18,21,8 },
{1 ,17,8 ,0 }
};
static const ter_num_t mntn_pillar[4][4] = {
{37,29,27,36},
{29,33,34,27},
{31,32,35,25},
{36,31,25,37}
};
static const ter_num_t surf_lake[4][4] = {
{56,55,54,3 },
{57,50,61,54},
{58,51,59,53},
{3 ,4 ,58,52}
};
static const ter_num_t cave_lake[4][4] = {
{93,96,71,71},
{96,71,71,71},
{71,71,71,96},
{71,71,71,96}
};
static const ter_num_t surf_fume[4][4] = {
{75,75,75,36},
{75,75,75,75},
{75,75,75,75},
{36,37,75,75}
};
static const ter_num_t cave_fume[4][4] = {
{98,0 ,75,75},
{0 ,75,75,75},
{75,75,75,0 },
{75,75,75,0 }
};
// TODO: There's no surface bonfire or bedding in the default terrain set!
static const ter_num_t surf_camp[4][4] = {
{105, 2,4, 2},
{ 2,104,2,105},
{115, 2,4, 2},
{ 2,105,2,115},
};
static const ter_num_t cave_camp[4][4] = {
{105, 0, 1, 0},
{ 0,104, 0,105},
{ 92, 0,93, 0},
{ 0,105, 0, 92},
};
static const short terrain_odds[20][10] = {
{ 3, 80, 4, 40, 115, 20, 114, 10, 112, 1}, // Grassy field
{ 1, 50, 93, 25, 94, 5, 98, 10, 95, 1}, // Ordinary cave
{37, 20}, // Mountain
{64, 3, 63, 1}, // Surface bridge
{74, 1}, // Cave bridge
{84,700, 97, 30, 98, 20, 92, 4, 95, 1}, // Rubble-strewn cave
{93,280, 91,300, 92,270, 95, 7, 98, 10}, // Cave forest
{ 1,800, 93,600, 94, 10, 92, 10, 95, 4}, // Cave mushrooms
{ 1,700, 96,200, 95,100, 92, 10, 112, 5}, // Cave swamp
{ 3,600, 87, 90, 110, 20, 114, 6, 113, 2}, // Surface rocks
{ 3,200, 4,400, 111,250}, // Surface swamp
{ 3,200, 4,300, 112, 50, 113, 60, 114,100}, // Surface woods
{ 3,100, 4,250, 115,120, 114, 30, 112, 2}, // Surface shrubbery
{ 1, 25, 76, 15, 98,300, 97,280, 75, 5}, // Stalagmites
{ 1,150, 94, 80, 98, 20, 76, 20, 75, 5}, // Cave fumarole
{37,150, 76, 20, 75, 5}, // Surface fumarole
{ 1, 50, 93, 25, 94, 5, 98, 10, 95, 1}, // Cave camp
{ 3, 80, 4, 40, 115, 20, 114, 10, 112, 1}, // Surface camp
{ 1,600, 97, 50, 98, 80, 93, 10, 84, 10}, // Cave crops
{ 3,500, 4,500, 110, 50, 87, 10}, // Surface crops
}; // ter then odds then ter then odds ...
// These sets only include the ones that can have a road running through them
static const std::set<int> cave_arenas = {1,5,6,7,8,13};
static const std::set<int> surface_arenas = {0,2,9,10,11,12};
location stuff_ul;
arena = univ.scenario.ter_types[ter_type].combat_arena;
if(arena >= 1000) {
arena -= 1000;
// We take the terrain from the specified town, and nothing else.
// No preset creatures, items, special nodes, etc.
// Furthermore, if it's a large town, we drop the outer 8 tiles.
size_t town_size = univ.scenario.towns[arena]->max_dim();
int offset = max(0,town_size - 48);
rectangle town_bounds = univ.scenario.towns[arena]->in_town_rect;
// Just in case the town boundary is somehow larger than the town...
town_bounds.left = minmax(0,town_size - 1, town_bounds.left);
town_bounds.right = minmax(0,town_size - 1, town_bounds.right);
town_bounds.top = minmax(0,town_size - 1, town_bounds.top);
town_bounds.bottom = minmax(0,town_size - 1, town_bounds.bottom);
for(i = 0; i < 48; i++)
for(j = 0; j < 48; j++) {
// This test also accounts for small towns since the town boundary is never larger than the town
if(town_bounds.contains(i + offset, j + offset))
univ.town->terrain(i,j) = univ.scenario.towns[arena]->terrain(i + offset,j + offset);
else univ.town->terrain(i,j) = 90;
}
// The game uses the upper left corner to replace spaces that are blocked, so it needs to be set to something sensible.
// We'll take the terrain at the first entry location.
location fetch = univ.scenario.towns[arena]->start_locs[0];
univ.town->terrain(0,0) = univ.scenario.towns[arena]->terrain(fetch.x, fetch.y);
// And now we're done, so skip the rest of this function.
return;
}
for(i = 0; i < 48; i++)
for(j = 0; j < 48; j++) {
univ.town.fields[i][j] = 0;
if((j <= 8) || (j >= 35) || (i <= 8) || (i >= 35))
univ.town->terrain(i,j) = 90;
else univ.town->terrain(i,j) = ter_base[arena];
}
for(i = 0; i < 48; i++)
for(j = 0; j < 48; j++)
for(k = 0; k < 5; k++)
if((univ.town->terrain(i,j) != 90) && (get_ran(1,1,1000) < terrain_odds[arena][k * 2 + 1]))
univ.town->terrain(i,j) = terrain_odds[arena][k * 2];
univ.town->terrain(0,0) = ter_base[arena];
bool is_road = univ.scenario.ter_types[ter_type].trim_type == eTrimType::ROAD;
bool is_bridge = (arena == 3 || arena == 4);
if(arena == 3 || (is_road && surface_arenas.count(arena))) {
univ.town->terrain(0,0) = 83;
for(i = (is_bridge ? 15 : 19); i < (is_bridge ? 26 : 23); i++)
for(j = 9; j < 35; j++)
univ.town->terrain(i,j) = 83;
}
if(arena == 4 || (is_road && cave_arenas.count(arena))) {
univ.town->terrain(0,0) = 82;
for(i = (is_bridge ? 15 : 19); i < (is_bridge ? 26 : 23); i++)
for(j = 9; j < 35; j++)
univ.town->terrain(i,j) = 82;
}
if(arena == 18 || arena == 19) {
for(i = 12; i < 15; i++)
for(j = 9; j < 35; j++)
if(j != 17 && j != 26)
univ.town->terrain(i,j) = ter_type;
for(i = 17; i < 20; i++)
for(j = 9; j < 35; j++)
if(j != 17 && j != 26)
univ.town->terrain(i,j) = ter_type;
for(i = 22; i < 25; i++)
for(j = 9; j < 35; j++)
if(j != 17 && j != 26)
univ.town->terrain(i,j) = ter_type;
for(i = 27; i < 30; i++)
for(j = 9; j < 35; j++)
if(j != 17 && j != 26)
univ.town->terrain(i,j) = ter_type;
}
if(arena == 14 || arena == 15)
univ.town->terrain(0,0) = 75;
// Now place special lakes, etc.
if(arena == 2 || arena == 15)
for(i = 0; i < 15; i++)
if(get_ran(1,0,5) == 1) {
stuff_ul = special_ter_locs[i];
for(j = 0; j < 4; j++)
for(k = 0; k < 4; k++)
univ.town->terrain(stuff_ul.x + j,stuff_ul.y + k) = mntn_pillar[k][j];
}
if(univ.town->terrain(0,0) == 0)
for(i = 0; i < 15; i++)
if(get_ran(1,0,25) == 1) {
stuff_ul = special_ter_locs[i];
for(j = 0; j < 4; j++)
for(k = 0; k < 4; k++)
univ.town->terrain(stuff_ul.x + j,stuff_ul.y + k) = cave_pillar[k][j];
}
if(univ.town->terrain(0,0) == 0)
for(i = 0; i < 15; i++)
if(get_ran(1,0,40) == 1) {
stuff_ul = special_ter_locs[i];
for(j = 0; j < 4; j++)
for(k = 0; k < 4; k++)
univ.town->terrain(stuff_ul.x + j,stuff_ul.y + k) = cave_lake[k][j];
}
if(univ.town->terrain(0,0) == 2)
for(i = 0; i < 15; i++)
if(get_ran(1,0,40) == 1) {
stuff_ul = special_ter_locs[i];
for(j = 0; j < 4; j++)
for(k = 0; k < 4; k++)
univ.town->terrain(stuff_ul.x + j,stuff_ul.y + k) = surf_lake[k][j];
}
if(arena == 14)
for(i = 0; i < 15; i++)
if(get_ran(1,0,5) == 1) {
stuff_ul = special_ter_locs[i];
for(j = 0; j < 4; j++)
for(k = 0; k < 4; k++)
univ.town->terrain(stuff_ul.x + j,stuff_ul.y + k) = cave_fume[k][j];
}
if(arena == 15)
for(i = 0; i < 15; i++)
if(get_ran(1,0,5) == 1) {
stuff_ul = special_ter_locs[i];
for(j = 0; j < 4; j++)
for(k = 0; k < 4; k++)
univ.town->terrain(stuff_ul.x + j,stuff_ul.y + k) = surf_fume[k][j];
}
if(arena == 16) {
stuff_ul = loc(18,14);
for(j = 0; j < 4; j++)
for(k = 0; k < 4; k++)
univ.town->terrain(stuff_ul.x + j,stuff_ul.y + k) = cave_camp[k][j];
}
if(arena == 17) {
stuff_ul = loc(18,14);
for(j = 0; j < 4; j++)
for(k = 0; k < 4; k++)
univ.town->terrain(stuff_ul.x + j,stuff_ul.y + k) = surf_camp[k][j];
}
if(ter_base[ter_type] == 0) {
for(i = 0; i < num_walls; i++) {
r1 = get_ran(1,0,3);
for(j = 9; j < 35; j++)
switch(r1) {
case 0:
univ.town->terrain(j,8) = 6;
break;
case 1:
univ.town->terrain(8,j) = 9;
break;
case 2:
univ.town->terrain(j,35) = 12;
break;
case 3:
univ.town->terrain(32,j) = 15;
break;
}
}
if((univ.town->terrain(17,8) == 6) && (univ.town->terrain(8,20) == 9))
univ.town->terrain(8,8) = 21;
if((univ.town->terrain(32,20) == 15) && (univ.town->terrain(17,35) == 12))
univ.town->terrain(32,35) = 19;
if((univ.town->terrain(17,8) == 6) && (univ.town->terrain(32,20) == 15))
univ.town->terrain(32,8) = 32;
if((univ.town->terrain(8,20) == 9) && (univ.town->terrain(17,35) == 12))
univ.town->terrain(8,35) = 20;
}
if(ter_base[ter_type] == 36) {
for(i = 0; i < num_walls; i++) {
r1 = get_ran(1,0,3);
for(j = 9; j < 35; j++)
switch(r1) {
case 0:
univ.town->terrain(j,8) = 24;
break;
case 1:
univ.town->terrain(8,j) = 26;
break;
case 2:
univ.town->terrain(j,35) = 28;
break;
case 3:
univ.town->terrain(32,j) = 30;
break;
}
}
if((univ.town->terrain(17,8) == 6) && (univ.town->terrain(8,20) == 9))
univ.town->terrain(8,8) = 35;
if((univ.town->terrain(32,20) == 15) && (univ.town->terrain(17,35) == 12))
univ.town->terrain(32,35) = 33;
if((univ.town->terrain(17,8) == 6) && (univ.town->terrain(32,20) == 15))
univ.town->terrain(32,8) = 32;
if((univ.town->terrain(8,20) == 9) && (univ.town->terrain(17,35) == 12))
univ.town->terrain(8,35) = 34;
}
// TODO: Looks like I haven't yet implemented the generalized arenas
// make_town_trim(1);
}
void elim_monst(unsigned short which,short spec_a,short spec_b) {
short i;
if(!univ.party.sd_legit(spec_a,spec_b))
return;
if(PSD[spec_a][spec_b] > 0) {
for(i = 0; i < univ.town.monst.size(); i++)
if(univ.town.monst[i].number == which) {
univ.town.monst[i].active = 0;
}
}
}
//short print_mes; // 0 - no 1 - yes
void dump_gold(short print_mes) {
// Mildly kludgy gold check
if(univ.party.gold > 30000) {
univ.party.gold = 30000;
if(print_mes == 1) {
put_pc_screen();
add_string_to_buf("Excess gold dropped.");
print_buf();
}
}
if(univ.party.food > 25000) {
univ.party.food = 25000;
if(print_mes == 1) {
put_pc_screen();
add_string_to_buf("Excess food dropped.");
print_buf();
}
}
}
void pick_lock(location where,short pc_num) {
ter_num_t terrain;
short r1,which_item;
bool will_break = false;
short unlock_adjust;
terrain = univ.town->terrain(where.x,where.y);
which_item = univ.party[pc_num].has_abil_equip(eItemAbil::LOCKPICKS);
if(which_item == 24) {
add_string_to_buf(" Need lockpick equipped.");
return;
}
r1 = get_ran(1,1,100) + univ.party[pc_num].items[which_item].abil_data[0] * 7;
if(r1 < 75)
will_break = true;
r1 = get_ran(1,1,100) - 5 * univ.party[pc_num].stat_adj(eSkill::DEXTERITY) + univ.town.difficulty * 7
- 5 * univ.party[pc_num].skill(eSkill::LOCKPICKING) - univ.party[pc_num].items[which_item].abil_data[0] * 7;
// Nimble?
if(univ.party[pc_num].traits[eTrait::NIMBLE])
r1 -= 8;
if(univ.party[pc_num].has_abil_equip(eItemAbil::THIEVING) < 24)
r1 = r1 - 12;
if(univ.scenario.ter_types[terrain].special != eTerSpec::UNLOCKABLE) {
add_string_to_buf(" Wrong terrain type.");
return;
}
unlock_adjust = univ.scenario.ter_types[terrain].flag2;
if((unlock_adjust >= 5) || (r1 > (unlock_adjust * 15 + 30))) {
add_string_to_buf(" Didn't work.");
if(will_break) {
add_string_to_buf(" Pick breaks.");
univ.party[pc_num].remove_charge(which_item);
if(stat_window == pc_num)
put_item_screen(stat_window);
}
play_sound(41);
}
else {
add_string_to_buf(" Door unlocked.");
play_sound(9);
univ.town->terrain(where.x,where.y) = univ.scenario.ter_types[terrain].flag1;
}
}
void bash_door(location where,short pc_num) {
ter_num_t terrain;
short r1,unlock_adjust;
terrain = univ.town->terrain(where.x,where.y);
r1 = get_ran(1,1,100) - 15 * univ.party[pc_num].stat_adj(eSkill::STRENGTH) + univ.town.difficulty * 4;
if(univ.scenario.ter_types[terrain].special != eTerSpec::UNLOCKABLE) {
add_string_to_buf(" Wrong terrain type.");
return;
}
unlock_adjust = univ.scenario.ter_types[terrain].flag2;
if(unlock_adjust >= 5 || r1 > (unlock_adjust * 15 + 40) || univ.scenario.ter_types[terrain].flag3 != 1) {
add_string_to_buf(" Didn't work.");
damage_pc(univ.party[pc_num],get_ran(1,1,4),eDamageType::SPECIAL,eRace::UNKNOWN,0);
}
else {
add_string_to_buf(" Lock breaks.");
play_sound(9);
univ.town->terrain(where.x,where.y) = univ.scenario.ter_types[terrain].flag1;
}
}
void erase_specials() {
location where;
short k,sd1,sd2;
cSpecial sn;
if((is_combat()) && (which_combat_type == 0))
return;
if(!is_town() && !is_combat())
return;
for(k = 0; k < univ.town->special_locs.size(); k++) {
if(univ.town->special_locs[k].spec < 0 || univ.town->special_locs[k].spec >= univ.town->specials.size())
continue;
sn = univ.town->specials[univ.town->special_locs[k].spec];
sd1 = sn.sd1; sd2 = sn.sd2;
if((univ.party.sd_legit(sd1,sd2)) && (PSD[sd1][sd2] == 250)) {
long spec = univ.town->special_locs[k].spec;
where = univ.town->special_locs[k];
if(spec >= 0 && (where.x > univ.town->max_dim() || where.y > univ.town->max_dim() || where.x < 0 || where.y < 0)) {
beep();
add_string_to_buf("Town corrupt. Problem fixed.");
print_nums(where.x,where.y,k);
univ.town->special_locs[k].spec = -1;
}
if(spec >= 0) {
univ.town.set_spot(where.x,where.y,false);
}
}
}
}
void erase_out_specials() {
short out_num;
cSpecial sn;
short sd1,sd2;
location where;
for(short i = 0; i < 2; i++)
for(short j = 0; j < 2; j++)
if(quadrant_legal(i,j)) {
cOutdoors& sector = *univ.scenario.outdoors[univ.party.outdoor_corner.x + i][univ.party.outdoor_corner.y + j];
for(short k = 0; k < sector.city_locs.size(); k++) {
if(sector.city_locs[k].spec >= 0 && sector.city_locs[k].x < 48 &&
univ.scenario.ter_types[sector.terrain[sector.city_locs[k].x][sector.city_locs[k].y]].special == eTerSpec::TOWN_ENTRANCE &&
(sector.city_locs[k].x == minmax(0,47,sector.city_locs[k].x)) &&
(sector.city_locs[k].y == minmax(0,47,sector.city_locs[k].y))) {
if(!univ.party.can_find_town[sector.city_locs[k].spec]) {
univ.out[48 * i + sector.city_locs[k].x][48 * j + sector.city_locs[k].y] =
univ.scenario.ter_types[sector.terrain[sector.city_locs[k].x][sector.city_locs[k].y]].flag1;
}
else if(univ.party.can_find_town[sector.city_locs[k].spec]) {
univ.out[48 * i + sector.city_locs[k].x][48 * j + sector.city_locs[k].y] =
sector.terrain[sector.city_locs[k].x][sector.city_locs[k].y];
}
}
}
for(int k = 0; k < sector.special_locs.size(); k++) {
if(sector.special_locs[k].spec < 0) continue; // TODO: Is this needed? Seems to be important, so why was it commented out?
out_num = univ.scenario.outdoors.width() * (univ.party.outdoor_corner.y + j) + univ.party.outdoor_corner.x + i;
sn = sector.specials[sector.special_locs[k].spec];
sd1 = sn.sd1; sd2 = sn.sd2;
if((univ.party.sd_legit(sd1,sd2)) && (PSD[sd1][sd2] == 250)) {
where = sector.special_locs[k];
if(where.x > 48 || where.y > 48 || where.x < 0 || where.y < 0) {
beep();
add_string_to_buf("Outdoor section corrupt. Problem fixed.");
sector.special_locs[k].spec = -1; // TODO: Again, was there a reason for commenting this out?
}
sector.special_spot[where.x][where.y] = false;
}
}
}
}
// TODO: I don't think we need this
void clear_map() {
rectangle map_world_rect(map_gworld);
// if(!map_visible) {
// return;
// }
// draw_map(mini_map,11);
fill_rect(map_gworld, map_world_rect, sf::Color::Black);
}
void draw_map(bool need_refresh) {
if(!map_visible) return;
short i;
pic_num_t pic;
rectangle the_rect,map_world_rect = {0,0,384,384};
location where;
location kludge;
rectangle draw_rect,orig_draw_rect = {0,0,6,6},ter_temp_from,base_source_rect = {0,0,12,12};
rectangle dlogpicrect = {6,6,42,42};
bool draw_pcs = true,out_mode;
rectangle view_rect= {0,0,48,48},tiny_rect = {0,0,32,32},
redraw_rect = {0,0,48,48},big_rect = {0,0,64,64}; // Rectangle visible in view screen
rectangle area_to_draw_from,area_to_draw_on = {29,47,269,287};
ter_num_t what_ter;
bool draw_surroundings = false,expl;
short total_size = 48; // if full redraw, use this to figure out everything
rectangle custom_from;
draw_surroundings = true;
town_map_adj.x = 0;
town_map_adj.y = 0;
// view rect is rect that is visible, redraw rect is area to redraw now
// area_to_draw_from is final draw from rect
// area_to_draw_on is final draw to rect
// extern short store_pre_shop_mode,store_pre_talk_mode;
if((is_out()) || ((is_combat()) && (which_combat_type == 0)) ||
((overall_mode == MODE_TALKING) && (store_pre_talk_mode == 0)) ||
((overall_mode == MODE_SHOPPING) && (store_pre_shop_mode == 0))) {
view_rect.left = minmax(0,8,univ.party.loc_in_sec.x - 20);
view_rect.right = view_rect.left + 40;
view_rect.top = minmax(0,8,univ.party.loc_in_sec.y - 20);
view_rect.bottom = view_rect.top + 40;
redraw_rect = view_rect;
}
else {
total_size = univ.town->max_dim();
switch(total_size) {
case 64:
view_rect.left = minmax(0,24,univ.town.p_loc.x - 20);
view_rect.right = view_rect.left + 40;
view_rect.top = minmax(0,24,univ.town.p_loc.y - 20);
view_rect.bottom = view_rect.top + 40;
redraw_rect = big_rect;
break;
case 48:
view_rect.left = minmax(0,8,univ.town.p_loc.x - 20);
view_rect.right = view_rect.left + 40;
view_rect.top = minmax(0,8,univ.town.p_loc.y - 20);
view_rect.bottom = view_rect.top + 40;
redraw_rect = view_rect;
break;
case 32:
view_rect = tiny_rect;
redraw_rect = view_rect;
break;
}
}
if((is_out()) || ((is_combat()) && (which_combat_type == 0)) ||
((overall_mode == MODE_TALKING) && (store_pre_talk_mode == 0)) ||
((overall_mode == MODE_SHOPPING) && (store_pre_shop_mode == 0)) ||
is_town() || is_combat()) {
area_to_draw_from = view_rect;
area_to_draw_from.width() = 40;
area_to_draw_from.height() = 40;
area_to_draw_from.left *= 6;
area_to_draw_from.right *= 6;
area_to_draw_from.top *= 6;
area_to_draw_from.bottom *= 6;
}
if(is_combat())
draw_pcs = false;
const char* title_string = "Your map:";
bool canMap = true;
if((is_combat()) && (which_combat_type == 0)) {
title_string = "No map in combat.";
canMap = false;
}else if((is_town() && univ.town->defy_mapping)) {
title_string = "This place defies mapping.";
canMap = false;
}
else if(need_refresh) {
map_gworld.setActive();
fill_rect(map_gworld, map_world_rect, sf::Color::Black);
// Now, if shopping or talking, just don't touch anything.
if((overall_mode == MODE_SHOPPING) || (overall_mode == MODE_TALKING))
redraw_rect.right = -1;
if((is_out()) ||
((is_combat()) && (which_combat_type == 0)) ||
((overall_mode == MODE_TALKING) && (store_pre_talk_mode == 0)) ||
((overall_mode == MODE_SHOPPING) && (store_pre_shop_mode == 0)))
out_mode = true;
else out_mode = false;
// TODO: It could be possible to draw the entire map here and then only refresh if a spot actually changes terrain type
for(where.x = redraw_rect.left; where.x < redraw_rect.right; where.x++)
for(where.y = redraw_rect.top; where.y < redraw_rect.bottom; where.y++) {
draw_rect = orig_draw_rect;
draw_rect.offset(6 * where.x, 6 * where.y);
if(out_mode)
what_ter = univ.out[where.x + 48 * univ.party.i_w_c.x][where.y + 48 * univ.party.i_w_c.y];
else what_ter = univ.town->terrain(where.x,where.y);
ter_temp_from = base_source_rect;
if(out_mode)
expl = univ.out.out_e[where.x + 48 * univ.party.i_w_c.x][where.y + 48 * univ.party.i_w_c.y];
else expl = is_explored(where.x,where.y);
if(expl != 0) {
pic = univ.scenario.ter_types[what_ter].map_pic;
bool drawLargeIcon = false;
if(pic == NO_PIC) {
pic = univ.scenario.ter_types[what_ter].picture;
drawLargeIcon = true;
}
if(pic >= 1000) {
if(spec_scen_g) {
//print_nums(0,99,pic);
sf::Texture* src_gw;
if(drawLargeIcon) {
pic = pic % 1000;
graf_pos_ref(src_gw, custom_from) = spec_scen_g.find_graphic(pic);
rect_draw_some_item(*src_gw,custom_from,map_gworld,draw_rect);
} else {
graf_pos_ref(src_gw, custom_from) = spec_scen_g.find_graphic(pic % 1000);
custom_from.right = custom_from.left + 12;
custom_from.bottom = custom_from.top + 12;
pic /= 1000; pic--;
custom_from.offset((pic / 3) * 12, (pic % 3) * 12);
rect_draw_some_item(*src_gw, custom_from, map_gworld, draw_rect);
}
}
} else if(drawLargeIcon) {
if(pic >= 960) {
custom_from = calc_rect(4 * ((pic - 960) / 5),(pic - 960) % 5);
rect_draw_some_item(anim_gworld, custom_from, map_gworld, draw_rect);
} else {
sf::Texture* src_gw = &terrain_gworld[pic / 50];
pic %= 50;
custom_from = calc_rect(pic % 10, pic / 10);
rect_draw_some_item(*src_gw, custom_from, map_gworld, draw_rect);
}
} else {
if(univ.scenario.ter_types[what_ter].picture < 960)
ter_temp_from.offset(12 * (univ.scenario.ter_types[what_ter].picture % 20),
12 * (univ.scenario.ter_types[what_ter].picture / 20));
else ter_temp_from.offset(12 * 20,
12 * (univ.scenario.ter_types[what_ter].picture - 960));
rect_draw_some_item(small_ter_gworld,ter_temp_from,map_gworld,draw_rect);
}
}
}
map_gworld.display();
}
mini_map.setActive();
// Now place terrain map gworld
TextStyle style;
style.font = FONT_BOLD;
style.pointSize = 10;;
the_rect = rectangle(mini_map);
tileImage(mini_map, the_rect,bg[4]);
cPict theGraphic(mini_map);
theGraphic.setBounds(dlogpicrect);
theGraphic.setPict(21, PIC_DLOG);
theGraphic.setFormat(TXT_FRAME, false);
theGraphic.draw();
style.colour = sf::Color::White;
style.lineHeight = 12;
win_draw_string(mini_map, map_title_rect,title_string,eTextMode::WRAP,style);
win_draw_string(mini_map, map_bar_rect,"(Hit Escape to close.)",eTextMode::WRAP,style);
if(canMap) {
rect_draw_some_item(map_gworld.getTexture(),area_to_draw_from,mini_map,area_to_draw_on);
// Now place PCs and monsters
if(draw_pcs) {
if((is_town()) && (univ.party.status[ePartyStatus::DETECT_LIFE] > 0))
for(i = 0; i < univ.town.monst.size(); i++)
if(univ.town.monst[i].active > 0) {
where = univ.town.monst[i].cur_loc;
if((is_explored(where.x,where.y)) &&
((where.x >= view_rect.left) && (where.x < view_rect.right)
&& where.y >= view_rect.top && where.y < view_rect.bottom)){
draw_rect.left = area_to_draw_on.left + 6 * (where.x - view_rect.left);
draw_rect.top = area_to_draw_on.top + 6 * (where.y - view_rect.top);
draw_rect.right = draw_rect.left + 6;
draw_rect.bottom = draw_rect.top + 6;
fill_rect(mini_map, draw_rect, sf::Color::Green);
frame_circle(mini_map, draw_rect, sf::Color::Blue);
}
}
if((overall_mode != MODE_SHOPPING) && (overall_mode != MODE_TALKING)) {
where = (is_town()) ? univ.town.p_loc : global_to_local(univ.party.p_loc);
draw_rect.left = area_to_draw_on.left + 6 * (where.x - view_rect.left);
draw_rect.top = area_to_draw_on.top + 6 * (where.y - view_rect.top);
draw_rect.right = draw_rect.left + 6;
draw_rect.bottom = draw_rect.top + 6;
fill_rect(mini_map, draw_rect, sf::Color::Red);
frame_circle(mini_map, draw_rect, sf::Color::Black);
}
}
}
mini_map.display();
// Now exit gracefully
mainPtr.setActive();
}
bool is_door(location destination) {
if(univ.scenario.ter_types[univ.town->terrain(destination.x,destination.y)].special == eTerSpec::UNLOCKABLE ||
univ.scenario.ter_types[univ.town->terrain(destination.x,destination.y)].special == eTerSpec::CHANGE_WHEN_STEP_ON)
return true;
return false;
}
void display_map() {
// Show the automap if it's not already visible
if(map_visible) return;
rectangle the_rect;
rectangle dlogpicrect = {6,6,42,42};
mini_map.setVisible(true);
map_visible = true;
draw_map(true);
makeFrontWindow(mainPtr);
}
void check_done() {
}
bool quadrant_legal(short i, short j) {
if(univ.party.outdoor_corner.x + i >= univ.scenario.outdoors.width())
return false;
if(univ.party.outdoor_corner.y + j >= univ.scenario.outdoors.height())
return false;
if(univ.party.outdoor_corner.x + i < 0)
return false;
if(univ.party.outdoor_corner.y + j < 0)
return false;
return true;
}
Reference in New Issue View Git Blame Copy Permalink