openboe/oboe
2
0
Fork 0
Code Issues 146 Pull Requests 4 Actions Packages Projects Releases Wiki Activity
Files
1fbf8939b234892aa2fdc42538c1c9bfa2475e1a
oboe/osx/classes/universe.cpp

905 lines
24 KiB
C++
Raw Blame History

/*
* universe.cpp
* BoE
*
* Created by Celtic Minstrel on 24/04/09.
*
*/
#include <string>
#include <vector>
#include <map>
#include <sstream>
#include "classes.h"
#include "oldstructs.h"
#include "mathutil.h"
#include "fileio.h"
void cCurOut::append(legacy::out_info_type& old){
for(int i = 0; i < 96; i++)
for(int j = 0; j < 96; j++)
expl[i][j] = old.expl[i][j];
}
void cCurTown::append(legacy::current_town_type& old,short which_size){
num = old.town_num;
difficulty = old.difficulty;
if(record != NULL) delete record;
switch(which_size){
case 0:
record = new cBigTown;
break;
case 1:
record = new cMedTown;
break;
case 2:
record = new cTinyTown;
break;
}
*record = old.town;
for(int i = 0; i < 64; i++)
for(int j = 0; j < 64; j++)
fields[i][j] = old.explored[i][j];
hostile = old.hostile;
monst = old.monst;
in_boat = old.in_boat;
p_loc.x = old.p_loc.x;
p_loc.y = old.p_loc.y;
curTalk = &record->talking;
talkNeedsDeleting = false;
cur_talk_loaded = num;
}
void cCurTown::append(legacy::big_tr_type& old){
int i,j;
for(i = 0; i < record->max_dim(); i++)
for(j = 0; j < record->max_dim(); j++)
record->terrain(i,j) = old.terrain[i][j];
for(i = 0; i < 16; i++){
record->room_rect(i).top = old.room_rect[i].top;
record->room_rect(i).left = old.room_rect[i].left;
record->room_rect(i).bottom = old.room_rect[i].bottom;
record->room_rect(i).right = old.room_rect[i].right;
}
for(i = 0; i < record->max_monst(); i++)
record->creatures(i) = old.creatures[i];
for(i = 0; i < record->max_dim() / 8; i++)
for(j = 0; j < record->max_dim(); j++)
record->lighting(i,j) = old.lighting[i][j];
}
void cCurTown::append(legacy::town_item_list& old){
for(int i = 0; i < 115; i++)
items[i] = old.items[i];
}
void cUniverse::append(legacy::stored_town_maps_type& old){
for(int n = 0; n < 200; n++)
for(int i = 0; i < 8; i++)
for(int j = 0; j < 64; j++)
town_maps[n][i][j] = old.town_maps[n][i][j];
}
void cUniverse::append(legacy::stored_outdoor_maps_type& old){
for(int n = 0; n < 100; n++)
for(int i = 0; i < 6; i++)
for(int j = 0; j < 48; j++)
out_maps[n][i][j] = old.outdoor_maps[n][i][j];
}
void cCurTown::append(unsigned char(& old_sfx)[64][64], unsigned char(& old_misc_i)[64][64]){
for(int i = 0; i < 64; i++)
for(int j = 0; j < 64; j++){
unsigned long tmp_sfx, tmp_misc_i;
tmp_sfx = old_sfx[i][j];
tmp_misc_i = old_misc_i[i][j];
tmp_sfx <<= 16;
tmp_misc_i <<= 8;
fields[i][j] |= tmp_sfx;
fields[i][j] |= tmp_misc_i;
}
}
cTown* cCurTown::operator -> (){
return record;
}
bool cCurTown::loaded() const{
return record != NULL;
}
void cCurTown::unload(){
delete record;
record = NULL;
}
cSpeech& cCurTown::cur_talk() {
// Make sure we actually have a valid speech stored
if(curTalk == NULL) prep_talk(num);
return *curTalk;
}
bool cCurTown::prep_talk(short which) {
if(which == cur_talk_loaded) return true;
if(talkNeedsDeleting && curTalk != NULL) delete curTalk;
cur_talk_loaded = which;
if(which == num) {
curTalk = &record->talking;
talkNeedsDeleting = false;
return true;
} else {
curTalk = new cSpeech;
talkNeedsDeleting = true;
return false;
}
}
void cCurTown::prep_arena() {
if(loaded()) delete record;
record = new cMedTown();
}
cCurTown::~cCurTown() {
if(talkNeedsDeleting && curTalk != NULL) delete curTalk;
}
bool cCurTown::is_explored(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 1L;
}
bool cCurTown::is_force_wall(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 2L;
}
bool cCurTown::is_fire_wall(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 4L;
}
bool cCurTown::is_antimagic(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 8L;
}
bool cCurTown::is_scloud(char x, char y) const{ // stinking cloud
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 16L;
}
bool cCurTown::is_ice_wall(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 32L;
}
bool cCurTown::is_blade_wall(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 64L;
}
bool cCurTown::is_sleep_cloud(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 128L;
}
bool cCurTown::is_block(char x, char y) const{ // currently unused
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 256L;
}
bool cCurTown::is_spot(char x, char y) const{
return special_spot[x][y];
}
bool cCurTown::is_special(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 512L;
}
bool cCurTown::is_web(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 1024L;
}
bool cCurTown::is_crate(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 2048L;
}
bool cCurTown::is_barrel(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 4096L;
}
bool cCurTown::is_fire_barr(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 8192L;
}
bool cCurTown::is_force_barr(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 16384L;
}
bool cCurTown::is_quickfire(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 32768L;
}
bool cCurTown::is_sm_blood(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 65536L;
}
bool cCurTown::is_med_blood(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 131072L;
}
bool cCurTown::is_lg_blood(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 262144L;
}
bool cCurTown::is_sm_slime(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 524288L;
}
bool cCurTown::is_lg_slime(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 1048576L;
}
bool cCurTown::is_ash(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 2097152L;
}
bool cCurTown::is_bones(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 4194304L;
}
bool cCurTown::is_rubble(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 8388608L;
}
bool cCurTown::is_force_cage(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return false;
return fields[x][y] & 16777216L;
}
//bool cCurTown::is_trim(char x, char y, char t){
// unsigned char bit = 1 << t;
// return trim[x][y] & bit;
//}
bool cCurTown::set_explored(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b) fields[x][y] |= 1L;
else fields[x][y] &= ~1L;
return true;
}
bool cCurTown::set_force_wall(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){ // If certain things are on space, there's no room for field.
if(is_impassable(x,y))
return false;
if(is_antimagic(x,y) || is_blade_wall(x,y) || is_quickfire(x,y))
return false;
if(is_crate(x,y) || is_barrel(x,y) || is_fire_barr(x,y) || is_force_barr(x,y))
return false;
fields[x][y] |= 2L;
set_web(x,y,false);
set_fire_wall(x,y,false);
}
else fields[x][y] &= ~2L;
return true;
}
bool cCurTown::set_fire_wall(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){ // If certain things are on space, there's no room for field.
if(is_impassable(x,y))
return false;
if(is_antimagic(x,y) || is_blade_wall(x,y) || is_quickfire(x,y) || is_ice_wall(x,y))
return false;
if(is_crate(x,y) || is_barrel(x,y) || is_fire_barr(x,y) || is_force_barr(x,y))
return false;
if(is_web(x,y) || is_scloud(x,y) || is_sleep_cloud(x,y))
return false;
fields[x][y] |= 4L;
set_web(x,y,false);
set_fire_wall(x,y,false);
}
else fields[x][y] &= ~4L;
return true;
}
bool cCurTown::set_antimagic(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){ // If certain things are on space, there's no room for a field.
if(is_impassable(x,y))
return false;
if(is_quickfire(x,y) || is_force_wall(x,y) || is_fire_wall(x,y))
return false;
fields[x][y] |= 8L;
set_force_wall(x,y,false);
set_fire_wall(x,y,false);
set_antimagic(x,y,false);
set_scloud(x,y,false);
set_ice_wall(x,y,false);
set_blade_wall(x,y,false);
set_sleep_cloud(x,y,false);
}
else fields[x][y] &= ~8L;
return true;
}
bool cCurTown::set_scloud(char x, char y, bool b){ // stinking cloud
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){ // If certain things are on space, there's no room for cloud.
if(is_impassable(x,y))
return false;
if(is_force_wall(x,y) || is_fire_wall(x,y) || is_ice_wall(x,y) || is_blade_wall(x,y))
return false;
if(is_antimagic(x,y) || is_sleep_cloud(x,y) || is_quickfire(x,y))
return false;
if(is_fire_barr(x,y) || is_force_barr(x,y))
return false;
fields[x][y] |= 16L;
}
else fields[x][y] &= ~16L;
return true;
}
bool cCurTown::set_ice_wall(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){ // If certain things are on space, ther's no room for a field.
if(is_impassable(x,y))
return false;
if(is_force_wall(x,y) || is_blade_wall(x,y) || is_antimagic(x,y))
return false;
if(is_web(x,y) || is_crate(x,y) || is_barrel(x,y))
return false;
if(is_fire_barr(x,y) || is_force_barr(x,y) || is_quickfire(x,y))
return false;
fields[x][y] |= 32L;
set_fire_wall(x,y,false);
set_scloud(x,y,false);
}
else fields[x][y] &= ~32L;
return true;
}
bool cCurTown::set_blade_wall(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){ // if certain things are on space, there's no room for a field.
if(is_impassable(x,y))
return false;
if(is_fire_barr(x,y) || is_force_barr(x,y) || is_quickfire(x,y) || is_antimagic(x,y))
return false;
fields[x][y] |= 64L;
set_force_wall(x,y,false);
set_fire_wall(x,y,false);
}
else fields[x][y] &= ~64L;
return true;
}
bool cCurTown::set_sleep_cloud(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){ // if certain things are on space, there's no room for cloud.
if(is_impassable(x,y))
return false;
if(is_fire_barr(x,y) || is_force_barr(x,y) || is_quickfire(x,y) || is_antimagic(x,y))
return false;
fields[x][y] |= 128L;
set_force_wall(x,y,false);
set_fire_wall(x,y,false);
}
else fields[x][y] &= ~128L;
return true;
}
bool cCurTown::set_block(char x, char y, bool b){ // currently unused
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b) fields[x][y] |= 256L;
else fields[x][y] &= ~256L;
return true;
}
bool cCurTown::set_spot(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
special_spot[x][y] = b;
return true;
}
bool cCurTown::set_special(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b) fields[x][y] |= 512L;
else fields[x][y] &= ~512L;
return true;
}
bool cCurTown::set_web(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){ // If certain things are on the space, there's no room for webs
if(is_impassable(x,y))
return false;
if(is_fire_barr(x,y) || is_force_barr(x,y) || is_quickfire(x,y))
return false;
if(is_force_wall(x,y) || is_fire_wall(x,y) || is_antimagic(x, y))
return false;
if(is_ice_wall(x, y) || is_blade_wall(x,y) || is_sleep_cloud(x,y))
return false;
fields[x][y] |= 1024L;
}
else fields[x][y] &= ~1024L;
return true;
}
bool cCurTown::set_crate(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){ // If certain things are on the space, there's no room for a crate.
if(is_fire_barr(x,y) || is_force_barr(x,y) || is_quickfire(x,y) || is_barrel(x,y))
return false;
fields[x][y] |= 2048L;
}
else fields[x][y] &= ~2048L;
return true;
}
bool cCurTown::set_barrel(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){ // If certain things are on the space, there's no room for a crate.
if(is_fire_barr(x,y) || is_force_barr(x,y) || is_quickfire(x,y) || is_crate(x,y))
return false;
fields[x][y] |= 4096L;
}
else fields[x][y] &= ~4096L;
return true;
}
bool cCurTown::set_fire_barr(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){ // If certain things are on the space, there's no room for a barrier.
if(is_barrel(x,y) || is_force_barr(x,y) || is_quickfire(x,y) || is_crate(x,y))
return false;
if (is_antimagic(x,y) && get_ran(1,0,3) < 3)
return false;
fields[x][y] |= 8192L;
// Cancel out fields
set_web(x,y,false);
set_force_wall(x,y,false);
set_fire_wall(x,y,false);
set_antimagic(x,y,false);
set_scloud(x,y,false);
set_ice_wall(x,y,false);
set_blade_wall(x,y,false);
set_sleep_cloud(x,y,false);
}
else fields[x][y] &= ~8192L;
return true;
}
bool cCurTown::set_force_barr(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){ // If certain things are on the space, there's no room for a barrier.
if(is_fire_barr(x,y) || is_barrel(x,y) || is_quickfire(x,y) || is_crate(x,y))
return false;
if (is_antimagic(x,y) && get_ran(1,0,2) < 2)
return false;
fields[x][y] |= 16384L;
// Cancel out fields
set_web(x,y,false);
set_force_wall(x,y,false);
set_fire_wall(x,y,false);
set_antimagic(x,y,false);
set_scloud(x,y,false);
set_ice_wall(x,y,false);
set_blade_wall(x,y,false);
set_sleep_cloud(x,y,false);
}
else fields[x][y] &= ~16384L;
return true;
}
bool cCurTown::set_quickfire(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){ // If certain things are on space, there's no room for quickfire.
ter_num_t ter = record->terrain(x,y);
if(scenario.ter_types[ter].blockage == eTerObstruct::BLOCK_SIGHT)
return false;
// TODO: Isn't it a little odd that BLOCK_MOVE_AND_SHOOT isn't included here?
if(scenario.ter_types[ter].blockage == eTerObstruct::BLOCK_MOVE_AND_SIGHT)
return false;
if (is_antimagic(x,y) && get_ran(1,0,1) == 0)
return false;
if (is_force_barr(x,y) || is_fire_barr(x,y))
return false;
quickfire_present = true;
fields[x][y] |= 32768L;
set_force_wall(x,y,false);
set_fire_wall(x,y,false);
set_antimagic(x,y,false);
set_scloud(x,y,false);
set_ice_wall(x,y,false);
set_blade_wall(x,y,false);
set_sleep_cloud(x,y,false);
set_web(x,y,false);
set_crate(x,y,false);
set_barrel(x,y,false);
set_force_barr(x,y,false);
set_fire_barr(x,y,false);
}
else fields[x][y] &= ~32768;
return true;
}
bool cCurTown::free_for_sfx(short x, short y) {
ter_num_t ter;
ter = record->terrain(x,y);
if(scenario.ter_types[ter].blockage != eTerObstruct::CLEAR)
return false;
return true;
}
bool cCurTown::set_sm_blood(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){
if(!free_for_sfx(x,y)) return false;
if(is_med_blood(x,y) || is_lg_blood(x,y))
return false;
fields[x][y] |= 65536L;
set_sm_slime(x,y,false);
set_lg_slime(x,y,false);
set_ash(x,y,false);
set_bones(x,y,false);
set_rubble(x,y,false);
}
else fields[x][y] &= ~65536L;
return true;
}
bool cCurTown::set_med_blood(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){
if(!free_for_sfx(x,y)) return false;
if(is_lg_blood(x,y))
return false;
fields[x][y] |= 131072L;
set_sm_blood(x,y,false);
set_sm_slime(x,y,false);
set_lg_slime(x,y,false);
set_ash(x,y,false);
set_bones(x,y,false);
set_rubble(x,y,false);
}
else fields[x][y] &= ~131072L;
return true;
}
bool cCurTown::set_lg_blood(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){
if(!free_for_sfx(x,y)) return false;
fields[x][y] |= 262144L;
set_sm_blood(x,y,false);
set_med_blood(x,y,false);
set_sm_slime(x,y,false);
set_lg_slime(x,y,false);
set_ash(x,y,false);
set_bones(x,y,false);
set_rubble(x,y,false);
}
else fields[x][y] &= ~262144L;
return true;
}
bool cCurTown::set_sm_slime(char x, char y, bool b){
if(b){
if(!free_for_sfx(x,y)) return false;
if(is_lg_slime(x,y))
return false;
fields[x][y] |= 524288L;
set_sm_blood(x,y,false);
set_med_blood(x,y,false);
set_lg_blood(x,y,false);
set_ash(x,y,false);
set_bones(x,y,false);
set_rubble(x,y,false);
}
else fields[x][y] &= ~524288L;
return true;
}
bool cCurTown::set_lg_slime(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){
if(!free_for_sfx(x,y)) return false;
fields[x][y] |= 1048576L;
set_sm_blood(x,y,false);
set_med_blood(x,y,false);
set_lg_blood(x,y,false);
set_sm_slime(x,y,false);
set_ash(x,y,false);
set_bones(x,y,false);
set_rubble(x,y,false);
}
else fields[x][y] &= ~1048576L;
return true;
}
bool cCurTown::set_ash(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){
if(!free_for_sfx(x,y)) return false;
fields[x][y] |= 2097152L;
set_sm_blood(x,y,false);
set_med_blood(x,y,false);
set_lg_blood(x,y,false);
set_sm_slime(x,y,false);
set_lg_slime(x,y,false);
set_bones(x,y,false);
set_rubble(x,y,false);
}
else fields[x][y] &= ~2097152L;
return true;
}
bool cCurTown::set_bones(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){
if(!free_for_sfx(x,y)) return false;
fields[x][y] |= 4194304L;
set_sm_blood(x,y,false);
set_med_blood(x,y,false);
set_lg_blood(x,y,false);
set_sm_slime(x,y,false);
set_lg_slime(x,y,false);
set_ash(x,y,false);
set_rubble(x,y,false);
}
else fields[x][y] &= ~4194304L;
return true;
}
bool cCurTown::set_rubble(char x, char y, bool b){
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b){
if(!free_for_sfx(x,y)) return false;
fields[x][y] |= 8388608L;
set_sm_blood(x,y,false);
set_med_blood(x,y,false);
set_lg_blood(x,y,false);
set_sm_slime(x,y,false);
set_lg_slime(x,y,false);
set_ash(x,y,false);
set_bones(x,y,false);
}
else fields[x][y] &= ~8388608L;
return true;
}
bool cCurTown::set_force_cage(char x, char y, bool b){
// TODO: Consider whether placing a forcecage should erase anything already present, or fail due to something already present
// TODO: Also consider checking for forcecage in some of the other placement functions.
if(x > record->max_dim() || y > record->max_dim()) return false;
if(b) fields[x][y] |= 16777216L;
else fields[x][y] &= ~16777216L;
return true;
}
//bool cCurTown::set_trim(char x, char y, char t, bool b){
// unsigned char bit = 1 << t;
// if(b){
// switch(t){
// case 0:
// set_trim(x,y,1,false);
// break;
// case 1:
// if(!is_trim(x,y,3)) break;
// set_trim(x,y,3,false);
// set_trim(x,y,5,false);
// break;
// case 2:
// set_trim(x,y,1,false);
// set_trim(x,y,3,false);
// break;
// case 3:
// if(!is_trim(x,y,1)) break;
// set_trim(x,y,3,false);
// set_trim(x,y,5,false);
// break;
// case 6:
// set_trim(x,y,5,false);
// break;
// }
// trim[x][y] |= bit;
// }else trim[x][y] &= ~bit;
//}
unsigned char cCurTown::explored(char x,char y) const{
if(x > record->max_dim() || y > record->max_dim()) return 0;
return fields[x][y] & 0x000000FF;
}
unsigned char cCurTown::misc_i(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return 0;
return (fields[x][y] & 0x0000FF00) >> 8;
}
unsigned char cCurTown::sfx(char x, char y) const{
if(x > record->max_dim() || y > record->max_dim()) return 0;
return (fields[x][y] & 0x00FF0000) >> 16;
}
// TODO: This seems to be wrong; impassable implies "blocks movement", which two other blockages also do
bool cCurTown::is_impassable(short i,short j) {
ter_num_t ter;
ter = record->terrain(i,j);
if(scenario.ter_types[ter].blockage == eTerObstruct::BLOCK_MOVE_AND_SIGHT)
return true;
else return false;
}
ter_num_t(& cCurOut::operator [] (size_t i))[96]{
return out[i];
}
ter_num_t& cCurOut::operator [] (location loc) {
return out[loc.x][loc.y];
}
void cCurOut::writeTo(std::ostream& file){
writeArray(file, expl, 96, 96);
writeArray(file, out, 96, 96);
writeArray(file, out_e, 96, 96);
// file << "OUTDOORS 0 0" << std::endl;
// outdoors[0][0].writeTo(file);
// file << "OUTDOORS 0 1" << std::endl;
// outdoors[0][1].writeTo(file);
// file << "OUTDOORS 1 0" << std::endl;
// outdoors[1][0].writeTo(file);
// file << "OUTDOORS 1 1" << std::endl;
// outdoors[1][1].writeTo(file);
// file << std::endl;
}
void cCurOut::readFrom(std::istream& file) {
readArray(file, expl, 96, 96);
readArray(file, out, 96, 96);
readArray(file, out_e, 96, 96);
}
void cCurTown::writeTo(std::ostream& file){
file << "TOWN " << num << '\n';
file << "DIFFICULTY " << difficulty << '\n';
if(hostile) file << "HOSTILE" << '\n';
file << "INBOAT " << in_boat << '\n';
file << "AT " << p_loc.x << ' ' << p_loc.y << '\n';
file << '\f';
for(int i = 0; i < 115; i++)
if(items[i].variety != eItemType::NO_ITEM){
file << "ITEM " << i << '\n';
items[i].writeTo(file);
file << '\f';
}
file << '\f';
for(int i = 0; i < 60; i++) {
if(monst[i].active > 0) {
file << "CREATURE " << i << '\n';
monst[i].writeTo(file);
file << '\f';
}
}
file << '\f';
file << "FIELDS\n";
writeArray(file, fields, 64, 46);
file << "SIZE " << record->max_dim() << "\n";
record->writeTerrainTo(file);
// TODO: Do we need to save special_spot?
}
void cCurTown::readFrom(std::istream& file){
std::istringstream bin, sin;
std::string cur;
getline(file, cur, '\f');
bin.str(cur);
while(bin){
getline(bin, cur);
sin.str(cur);
sin >> cur;
if(cur == "TOWN")
sin >> num;
else if(cur == "DIFFICULTY")
sin >> difficulty;
else if(cur == "HOSTILE")
hostile = true;
else if(cur == "INBOAT")
sin >> in_boat;
else if(cur == "AT")
sin >> p_loc.x >> p_loc.y;
sin.clear();
}
bin.clear();
while(file) {
getline(file, cur, '\f');
bin.str(cur);
bin >> cur;
if(cur == "FIELDS")
readArray(bin, fields, 64, 64);
else if(cur == "ITEM") {
int i;
bin >> i;
items[i].readFrom(bin);
} else if(cur == "CREATURE") {
int i;
bin >> i;
monst[i].active = true;
monst[i].readFrom(bin);
} else if(cur == "SIZE") {
int dim;
bin >> dim;
if(record != NULL) delete record;
switch(dim){
case 32:
record = new cTinyTown;
break;
case 48:
record = new cMedTown;
break;
case 64:
record = new cBigTown;
break;
}
record->readTerrainFrom(bin);
}
bin.clear();
}
}
cCurTown::cCurTown(){
record = NULL;
num = 200;
for(int i = 0; i < 64; i++)
for(int j = 0; j < 64; j++)
fields[i][j] = 0L;
}
extern cScenario scenario;
short cUniverse::difficulty_adjust() {
short party_level = 0;
short adj = 1;
if(!scenario.adjust_diff) return 1;
for (short i = 0; i < 6; i++)
if(party[i].main_status == eMainStatus::ALIVE)
party_level += party[i].level;
if ((scenario.difficulty <= 0) && (party_level >= 60))
adj++;
if ((scenario.difficulty <= 1) && (party_level >= 130))
adj++;
if ((scenario.difficulty <= 2) && (party_level >= 210))
adj++;
return adj;
}
short cCurTown::countMonsters(){
short to_ret = 0;
for (short i = 0; i < record->max_monst(); i++)
if (monst[i].active > 0)
to_ret++;
return to_ret;
}
Reference in New Issue View Git Blame Copy Permalink