HillBlockInfo* HillRes::operator[](int hillBlockId)
{
err_if( hillBlockId<1 || hillBlockId>hill_block_count )
err_now( "HillRes::operator[]" );
return hill_block_info_array+(hillBlockId-1);
}
MonsterInfo* MonsterRes::operator[](int monsterId)
{
err_if( monsterId<1 || monsterId>monster_count )
err_now( "MonsterRes::operator[]" );
return monster_info_array+monsterId-1;
}
FirmInfo* FirmRes::operator[](int firmId)
{
err_if( firmId<1 || firmId>firm_count )
err_now( "FirmRes::operator[]" );
return firm_info_array+firmId-1;
}
RawInfo* RawRes::operator[](int rawId)
{
err_if( rawId<1 || rawId>raw_count )
err_now( "RawRes::operator[]" );
return raw_info_array+rawId-1;
}
//--------- Begin of function NationArray::create_nation ---------//
//
// <int> nationClassId - the class id. of the nation to be created.
//
// return : <int> nationRecno = the recno. of the newly added nation
//
int NationArray::create_nation(int nationClassId)
{
Nation* nationPtr;
switch(nationClassId)
{
case NATION_HUMAN:
nationPtr = new NationHuman;
break;
case NATION_MONSTER:
nationPtr = new NationMonster;
break;
default:
err_now("NationArray::create_nation()");
}
nationPtr->nation_class_id = nationClassId;
//----------------------------------------//
linkin(&nationPtr);
err_when( size() > MAX_NATION );
nationPtr->nation_recno = recno();
return recno();
}
TerrainInfo* TerrainRes::operator[](int terrainId)
{
err_if( terrainId<1 || terrainId>terrain_count )
err_now( "TerrainRes::operator[]" );
return terrain_info_array+terrainId-1;
}
TownBuild* TownRes::get_build(int recNo)
{
err_if( recNo<1 || recNo>town_build_count )
err_now( "TownRes::get_build()" );
return town_build_array+recNo-1;
}
char* TownRes::get_name(int recNo)
{
err_if( recNo<1 || recNo>town_name_count )
err_now( "TownRes::get_name()" );
return town_name_array[recNo-1].name;
}
TownSlot* TownRes::get_slot(int recNo)
{
err_if( recNo<1 || recNo>town_slot_count )
err_now( "TownRes::get_slot()" );
return town_slot_array+recNo-1;
}
TownBuildType* TownRes::get_build_type(int recNo)
{
err_if( recNo<1 || recNo>town_build_type_count )
err_now( "TownRes::get_build_type()" );
return town_build_type_array+recNo-1;
}
TownLayout* TownRes::get_layout(int recNo)
{
err_if( recNo<1 || recNo>town_layout_count )
err_now( "TownRes::get_layout()" );
return town_layout_array+recNo-1;
}
//--------- Begin of function SiteArray::del_site ----------//
//
// Delete a specified site.
//
// <int> siteRecno = the record no. of the site to be deleted
//
void SiteArray::del_site(int siteRecno)
{
err_if( siteRecno == 0 )
err_now( "SiteArray::del_site" );
Site* sitePtr = site_array[siteRecno];
switch( sitePtr->site_type )
{
case SITE_RAW:
untapped_raw_count--;
break;
case SITE_SCROLL:
scroll_count--;
break;
case SITE_GOLD_COIN:
gold_coin_count--;
break;
}
//-------------------------------//
sitePtr->deinit();
linkout(siteRecno);
if( siteRecno == site_array.selected_recno )
site_array.selected_recno = 0;
}
WallInfo* WallRes::operator[](int wallId)
{
err_if( wallId<1 || wallId>max_wall_id )
err_now( "WallRes::operator[]" );
return wall_index[wallId-1];
}
Firm* FirmArray::operator()()
{
Firm* firmPtr = (Firm*) get_ptr(); // if recno()==0, get_ptr() returns NULL
err_if( !firmPtr )
err_now( "FirmArray[recno()] is deleted" );
return firmPtr;
}
//------- Begin of function Misc::random ---------//
//
// <int> maxNum = maximum random number, it must <= 0x7FFF
// in 32 bit compiler <int> = <long>
//
// return : <int> the random number
//
int Misc::random(int maxNum)
{
err_if( maxNum < 0 || maxNum > 0x7FFF )
err_now( "Misc::random()" );
// ###### begin Gilbert 19/6 ######//
err_when( is_seed_locked() );
// ###### end Gilbert 19/6 ######//
#define MULTIPLIER 0x015a4e35L
#define INCREMENT 1
#define RANDOM_MAX 0x7FFFU
random_seed = MULTIPLIER * random_seed + INCREMENT;
return maxNum * ((random_seed >> 16) & RANDOM_MAX) / (RANDOM_MAX+1);
}
//------- BEGIN OF FUNCTION Misc::fix_str ------//
//
// format the word to the fixed length
//
// e.g. Misc::fix_str("ABC",10) -> "ABC "
//
// <char*> str = the string to be formated
// <int> len = the deserved length after formatted
// [char] endChar = the end character of the string ( default : NULL terminator )
//
void Misc::fix_str(char* str,int len,char endChar)
{
int oldLen;
if ( endChar == '\0' )
oldLen = strlen(str);
else
{
oldLen = Misc::str_chr(str,endChar)-1;
err_if ( oldLen == -1 ) // the end character not found
err_now("Misc::fix_str");
}
if ( len > oldLen )
memset( str+oldLen, ' ', len-oldLen );
str[len] = '\0';
}
//------- Begin of function TownRes::load_town_layout -------//
//
// Read in information from TOWNLAY.DBF.
//
void TownRes::load_town_layout()
{
TownLayoutRec *townLayoutRec;
TownLayout *townLayout;
TownSlot *townSlot;
int i, j;
Database *dbTownLayout = game_set.open_db(TOWN_LAYOUT_DB);
town_layout_count = (short) dbTownLayout->rec_count();
town_layout_array = (TownLayout*) mem_add( sizeof(TownLayout)*town_layout_count );
//------ read in town layout info array -------//
memset( town_layout_array, 0, sizeof(TownLayout) * town_layout_count );
for( i=0 ; i<town_layout_count ; i++ )
{
townLayoutRec = (TownLayoutRec*) dbTownLayout->read(i+1);
townLayout = town_layout_array+i;
townLayout->first_slot_recno = misc.atoi(townLayoutRec->first_slot, TownLayoutRec::FIRST_SLOT_LEN);
townLayout->slot_count = misc.atoi(townLayoutRec->slot_count, TownLayoutRec::SLOT_COUNT_LEN);
// ###### begin Gilbert 9/9 ########//
// townLayout->ground_bitmap_ptr = image_spict.get_ptr( misc.nullify(townLayoutRec->ground_name, TownLayoutRec::GROUND_NAME_LEN) );
townLayout->ground_bitmap_ptr = image_tpict.get_ptr( misc.nullify(townLayoutRec->ground_name, TownLayoutRec::GROUND_NAME_LEN) );
// ###### end Gilbert 9/9 ########//
err_if( townLayout->slot_count > MAX_TOWN_LAYOUT_SLOT )
err_now( "Error: MAX_TOWN_LAYOUT_SLOT limit exceeded." );
//----- calculate min_population & max_population -----//
townSlot = town_slot_array+townLayout->first_slot_recno-1;
for( j=0 ; j<townLayout->slot_count ; j++, townSlot++ )
{
if( townSlot->build_type==TOWN_OBJECT_HOUSE ) // if there is a building in this slot
townLayout->build_count++;
}
}
}
//---------- Begin of function ResourceDb::init ---------//
//
// <char*> resName = name of the resource file (e.g. "GIF.RES")
// <Database*> dbObj = name of the database (e.g. Database db("PFILE.DBF"))
// <int> indexOffset = offset of the index field
// [int] useCommonBuf = whether use the vga common buffer to store the data or not
// (default:0)
//
void ResourceDb::init(char* resName, Database* dbObj, int indexOffset, int useCommonBuf)
{
deinit();
file_open( resName );
db_obj = dbObj;
index_field_offset = indexOffset;
use_common_buf = useCommonBuf;
if( use_common_buf )
data_buf = sys.common_data_buf;
else
data_buf = NULL;
err_if( db_obj == NULL )
err_now("db_obj is NULL");
init_flag = 1;
}
News* NewsArray::operator[](int recNo) {
#ifdef DEBUG
News* msgPtr;
if( recNo )
msgPtr = (News*) get(recNo);
else
msgPtr = NULL; // NULL will then cause error
err_if( !msgPtr || msgPtr->news_date==0 )
err_now( "NewsArray[] is deleted" );
return msgPtr;
#else
return (News*) get(recNo);
#endif
}
PlantInfo* PlantRes::operator[](int plantId) {
err_if( plantId<1 || plantId>plant_count )
err_now( "PlantRes::operator[]" );
return info_array+plantId-1;
}
//--------- Begin of function FirmArray::create_firm ---------//
//
// create_firm() will be called directly by :
//
// 1. FirmArray::build_firm() for setting up a new firm
// 2. FirmArray::read_file() when loading game.
//
// <int> firmId = firm type id
//
// Return : <int> the record no. of the newly added firm
//
int FirmArray::create_firm(int firmId)
{
Firm* firmPtr;
// static char firmAnimalTrainArray[] = { UNIT_JAGUAR, UNIT_GORILLA, UNIT_RHINO, 0 };
static char firmIncubatorTrainArray[] = { UNIT_BALLISTA, UNIT_CATAPULT, UNIT_CANNON, 0 };
switch(firmId)
{
case FIRM_BASE:
firmPtr = new FirmBase;
break;
case FIRM_FORT:
firmPtr = new FirmFort;
break;
case FIRM_CAMP:
firmPtr = new FirmCamp;
break;
case FIRM_FACTORY:
firmPtr = new FirmFactory;
break;
case FIRM_INN:
firmPtr = new FirmInn;
break;
case FIRM_MARKET:
firmPtr = new FirmMarket;
break;
case FIRM_MINE:
firmPtr = new FirmMine;
break;
case FIRM_RESEARCH:
firmPtr = new FirmResearch;
break;
case FIRM_WAR_FACTORY:
firmPtr = new FirmWar;
break;
// case FIRM_HARBOR:
// firmPtr = new FirmHarbor;
// break;
case FIRM_SPY:
firmPtr = new FirmSpy;
break;
case FIRM_SPECIAL:
firmPtr = new FirmSpecial;
break;
case FIRM_LAIR:
firmPtr = new FirmLair;
break;
case FIRM_BEE:
firmPtr = new FirmMonsterTrain(UNIT_BEE);
break;
case FIRM_TERMITE:
firmPtr = new FirmMonsterTrain(UNIT_TERMITE);
break;
case FIRM_LISHORR:
case FIRM_WILDE_LISHORR:
firmPtr = new FirmLishorr;
break;
case FIRM_ALCHEMY:
firmPtr = new FirmMonsterAlchemy;
break;
case FIRM_INCUBATOR:
firmPtr = new FirmIncubator;
break;
case FIRM_ANIMAL:
firmPtr = new FirmAnimal;
break;
case FIRM_FORTRESS:
firmPtr = new FirmMonsterFortress(UNIT_ROCK);
break;
case FIRM_MAGIC:
firmPtr = new FirmMagic;
break;
case FIRM_OFFENSIVE_BUILDING_1:
case FIRM_OFFENSIVE_BUILDING_2:
case FIRM_OFFENSIVE_BUILDING_4:
firmPtr = new FirmOffensive;
break;
case FIRM_OFFENSIVE_BUILDING_3:
firmPtr = new FirmOffensive2;
break;
default:
err_now("FirmArray::create_firm()");
}
//----------------------------------------//
linkin(&firmPtr);
firmPtr->firm_recno = recno();
return firmPtr->firm_recno;
}
RoadInfo* RoadRes::operator[](int roadId) {
err_if( roadId<1 || roadId>road_count )
err_now( "RoadRes::operator[]" );
return info_array+roadId-1;
}
//--------- Begin of function FirmArray::firm_class_size ---------//
//
// Return the size of the specified class.
// This function will be called by FirmArray::write_file()
//
// <int> id = the id of the job
//
int FirmArray::firm_class_size(int id)
{
switch(id)
{
case FIRM_BASE:
return sizeof(FirmBase);
case FIRM_FORT:
return sizeof(FirmFort);
case FIRM_CAMP:
return sizeof(FirmCamp);
case FIRM_FACTORY:
return sizeof(FirmFactory);
case FIRM_INN:
return sizeof(FirmInn);
case FIRM_MARKET:
return sizeof(FirmMarket);
case FIRM_MINE:
return sizeof(FirmMine);
case FIRM_RESEARCH:
return sizeof(FirmResearch);
case FIRM_WAR_FACTORY:
return sizeof(FirmWar);
// case FIRM_HARBOR:
// return sizeof(FirmHarbor);
case FIRM_SPY:
return sizeof(FirmSpy);
case FIRM_SPECIAL:
return sizeof(FirmSpecial);
case FIRM_LAIR:
return sizeof(FirmLair);
case FIRM_BEE:
return sizeof(FirmMonsterTrain);
case FIRM_TERMITE:
return sizeof(FirmMonsterTrain);
case FIRM_LISHORR:
case FIRM_WILDE_LISHORR:
return sizeof(FirmLishorr);
case FIRM_ALCHEMY:
return sizeof(FirmMonsterAlchemy);
case FIRM_INCUBATOR:
return sizeof(FirmIncubator);
case FIRM_ANIMAL:
return sizeof(FirmAnimal);
case FIRM_FORTRESS:
return sizeof(FirmMonsterFortress);
case FIRM_MAGIC:
return sizeof(FirmMagic);
case FIRM_OFFENSIVE_BUILDING_1:
case FIRM_OFFENSIVE_BUILDING_2:
case FIRM_OFFENSIVE_BUILDING_4:
return sizeof(FirmOffensive);
case FIRM_OFFENSIVE_BUILDING_3:
return sizeof(FirmOffensive2);
default:
err_now( "FirmArray::firm_class_size" );
}
return 0;
}
