aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorClyne Sullivan <tullivan99@gmail.com>2016-04-13 08:47:41 -0400
committerClyne Sullivan <tullivan99@gmail.com>2016-04-13 08:47:41 -0400
commitfa4b6e00fd204998f6011420bdad60477b7a2f12 (patch)
tree4fd37e92f375ddb49e156b07811b8a2fe1ad6c0d /src
parent03130c5bcec3c885a1be005c24e192dfb57f3fe5 (diff)
parentheses
Diffstat (limited to 'src')
-rw-r--r--src/common.cpp4
-rw-r--r--src/config.cpp8
-rw-r--r--src/entities.cpp109
-rw-r--r--src/gameplay.cpp16
-rw-r--r--src/inventory.cpp94
-rw-r--r--src/quest.cpp38
-rw-r--r--src/texture.cpp12
-rwxr-xr-xsrc/tinyxml2.cpp1470
-rw-r--r--src/ui.cpp218
-rw-r--r--src/ui_menu.cpp8
-rw-r--r--src/world.cpp867
11 files changed, 1442 insertions, 1402 deletions
diff --git a/src/common.cpp b/src/common.cpp
index b4258f6..8f59fba 100644
--- a/src/common.cpp
+++ b/src/common.cpp
@@ -81,7 +81,7 @@ const char *readFile(const char *path){
unsigned int size;
GLchar *buf;
- if ( !in.is_open() )
+ if (!in.is_open())
UserError("Error reading file " + (std::string)path + "!");
in.seekg(0,in.end);
@@ -95,7 +95,7 @@ const char *readFile(const char *path){
}
void
-UserError( std::string reason )
+UserError(std::string reason)
{
std::cout << "User error: " << reason << "!" << std::endl;
abort();
diff --git a/src/config.cpp b/src/config.cpp
index b8a483d..a2acc03 100644
--- a/src/config.cpp
+++ b/src/config.cpp
@@ -21,7 +21,7 @@ XMLElement *vol;
namespace config {
- void read( void ) {
+ void read(void) {
unsigned int uval;
float fval;
bool bval;
@@ -61,19 +61,19 @@ namespace config {
ui::initFonts();
ui::setFontFace(xml.FirstChildElement("font")->Attribute("path"));
- if ( xml.FirstChildElement("debug") )
+ if (xml.FirstChildElement("debug"))
ui::debug = ui::posFlag = true;
config::update();
}
- void update( void ) {
+ void update(void) {
Mix_Volume(0,VOLUME_MASTER);
Mix_Volume(1,VOLUME_SFX * (VOLUME_MASTER/100.0f));
Mix_VolumeMusic(VOLUME_MUSIC * (VOLUME_MASTER/100.0f));
}
- void save( void ) {
+ void save(void) {
vol->FirstChildElement("master")->SetAttribute("volume",VOLUME_MASTER);
vol->FirstChildElement("music")->SetAttribute("volume",VOLUME_MUSIC);
vol->FirstChildElement("sfx")->SetAttribute("volume", VOLUME_SFX);
diff --git a/src/entities.cpp b/src/entities.cpp
index df32a5b..02be6fe 100644
--- a/src/entities.cpp
+++ b/src/entities.cpp
@@ -71,7 +71,7 @@ void getRandomName(Entity *e){
break;
}
- strcpy( e->name, bufs + 1 );
+ strcpy(e->name, bufs + 1);
delete[] bufs;
}
@@ -315,11 +315,15 @@ void Object::reloadTexture(void){
height = getItemHeight(iname);
}
+bool Entity::isNear(Entity e){
+ return pow(e.loc.x - loc.x, 2) + pow(e.loc.y - loc.y, 2) <= pow(40 * HLINE, 2);
+}
+
void Entity::draw(void){ //draws the entities
glPushMatrix();
glColor3ub(255,255,255);
- if ( !alive )
+ if (!alive)
return;
if(type==NPCT){
@@ -392,7 +396,7 @@ void Entity::draw(void){ //draws the entities
break;
}
- if ( hitCooldown )
+ if (hitCooldown)
glColor3ub(255,255,0);
else
glColor3ub(255,255,255);
@@ -410,11 +414,11 @@ NOPE:
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
- if ( near )
+ if (near)
ui::putStringCentered(loc.x+width/2,loc.y-ui::fontSize-HLINE/2,name);
- if ( health != maxHealth ) {
- glColor3ub(150,0,0); glRectf( loc.x, loc.y + height, loc.x + width, loc.y + height + HLINE * 2 );
- glColor3ub(255,0,0); glRectf( loc.x, loc.y + height, loc.x + width * ( health / maxHealth ), loc.y + height + HLINE * 2 );
+ if (health != maxHealth) {
+ glColor3ub(150,0,0); glRectf(loc.x, loc.y + height, loc.x + width, loc.y + height + HLINE * 2);
+ glColor3ub(255,0,0); glRectf(loc.x, loc.y + height, loc.x + width * (health / maxHealth), loc.y + height + HLINE * 2);
}
}
@@ -423,46 +427,46 @@ NOPE:
*/
void NPC::
-wander( int timeRun )
+wander(int timeRun)
{
static int direction;
- if ( forcedMove )
+ if (forcedMove)
return;
- if ( hitCooldown )
+ if (hitCooldown)
hitCooldown--;
- if ( followee ) {
- if ( loc.x < followee->loc.x - 40 )
+ if (followee) {
+ if (loc.x < followee->loc.x - 40)
direction = 1;
- else if ( loc.x > followee->loc.x + 40 )
+ else if (loc.x > followee->loc.x + 40)
direction = -1;
else
direction = 0;
vel.x = .018 * HLINE * direction;
- } else if ( targetx != 0.9112001f ) {
- if ( loc.x > targetx + HLINE * 5)
+ } else if (targetx != 0.9112001f) {
+ if (loc.x > targetx + HLINE * 5)
vel.x = -0.018 * HLINE;
- else if ( loc.x < targetx - HLINE * 5)
+ else if (loc.x < targetx - HLINE * 5)
vel.x = 0.018 * HLINE;
else
targetx = 0.9112001f;
- } else if ( ticksToUse == 0 ) {
+ } else if (ticksToUse == 0) {
ticksToUse = timeRun;
vel.x = .008 * HLINE;
direction = (getRand() % 3 - 1);
- if ( direction == 0 )
+ if (direction == 0)
ticksToUse *= 2;
vel.x *= direction;
}
- if( vel.x < 0)
- currentWorld->goWorldLeft( this );
+ if(vel.x < 0)
+ currentWorld->goWorldLeft(this);
ticksToUse--;
}
@@ -506,29 +510,29 @@ void NPC::interact(){ //have the npc's interact back to the player
void Merchant::wander(int timeRun){
static int direction;
- if ( forcedMove )
+ if (forcedMove)
return;
- if ( ticksToUse == 0 ) {
+ if (ticksToUse == 0) {
ticksToUse = timeRun;
vel.x = .008 * HLINE;
direction = (getRand() % 3 - 1);
- if ( direction == 0 )
+ if (direction == 0)
ticksToUse *= 2;
vel.x *= direction;
}
- if( vel.x < 0)
- currentWorld->goWorldLeft( this );
- if ( inside != nullptr ) {
+ if(vel.x < 0)
+ currentWorld->goWorldLeft(this);
+ if (inside != nullptr) {
loc.y = inside->loc.y + HLINE * 2;
vel.y = GRAVITY_CONSTANT * 5;
- if ( loc.x <= inside->loc.x + HLINE * 5 )
+ if (loc.x <= inside->loc.x + HLINE * 5)
loc.x = inside->loc.x + HLINE * 5;
- else if ( loc.x + width >= inside->loc.x + inside->width - HLINE * 5 )
+ else if (loc.x + width >= inside->loc.x + inside->width - HLINE * 5)
loc.x = inside->loc.x + inside->width - width - HLINE * 5;
}
ticksToUse--;
@@ -540,10 +544,10 @@ void Merchant::interact(){
ui::waitForDialog();
// handle normal dialog options
- switch ( ui::dialogOptChosen ) {
+ switch (ui::dialogOptChosen) {
// Accept
case 1:
- if ( !(player->inv->takeItem( trade[currTrade].item[1], trade[currTrade].quantity[1])) )
+ if (!(player->inv->takeItem(trade[currTrade].item[1], trade[currTrade].quantity[1])))
player->inv->addItem(trade[currTrade].item[0],trade[currTrade].quantity[0]);
break;
@@ -556,10 +560,10 @@ void Merchant::interact(){
}
// handle merchant-specific dialog options
- switch ( ui::merchOptChosen ) {
+ switch (ui::merchOptChosen) {
// left arrow
case 1:
- if ( currTrade )
+ if (currTrade)
currTrade--;
ui::dontTypeOut();
interact(); // TODO should we nest like this?
@@ -567,7 +571,7 @@ void Merchant::interact(){
// right arrow
case 2:
- if ( currTrade < trade.size() - 1 )
+ if (currTrade < trade.size() - 1)
currTrade++;
ui::dontTypeOut();
interact();
@@ -582,10 +586,10 @@ void Merchant::interact(){
void Object::interact(void){
std::thread([this]{
if(questObject && alive){
- ui::dialogBox( player->name, ":Yes:No", false, pickupDialog.c_str());
+ ui::dialogBox(player->name, ":Yes:No", false, pickupDialog.c_str());
ui::waitForDialog();
if(ui::dialogOptChosen == 1){
- player->inv->addItem( iname, 1 );
+ player->inv->addItem(iname, 1);
alive = false;
}
}else{
@@ -595,9 +599,14 @@ void Object::interact(void){
}).detach();
}
-void Entity::
-follow( Entity *e )
-{
+bool Entity::isInside(vec2 coord) const {
+ return coord.x >= loc.x &&
+ coord.x <= loc.x + width &&
+ coord.y >= loc.y &&
+ coord.y <= loc.y + height;
+}
+
+void Entity::follow(Entity *e){
followee = e;
}
@@ -630,19 +639,19 @@ unsigned int Structures::spawn(BUILD_SUB sub, float x, float y){
//unsigned int tempN = (getRand() % 5 + 2);
- if ( textureLoc.empty() )
- textureLoc = inWorld->sTexLoc[sub];
+ if (textureLoc.empty())
+ textureLoc = inWorld->getSTextureLocation(sub);
switch(sub){
case STALL_MARKET:
tex = new Texturec({ textureLoc });
- dim = Texture::imageDim( textureLoc );
+ dim = Texture::imageDim(textureLoc);
width = dim.x;
height = dim.y;
break;
default:
tex = new Texturec({ textureLoc });
- dim = Texture::imageDim( textureLoc );
+ dim = Texture::imageDim(textureLoc);
width = dim.x;
height = dim.y;
inv = NULL;
@@ -663,13 +672,13 @@ void Mob::wander(int timeRun){
static unsigned int heya=0,hi=0;
static bool YAYA = false;
- if ( forcedMove )
+ if (forcedMove)
return;
- if ( followee ) {
- if ( loc.x < followee->loc.x - 40 )
+ if (followee) {
+ if (loc.x < followee->loc.x - 40)
direction = 1;
- else if ( loc.x > followee->loc.x + 40 )
+ else if (loc.x > followee->loc.x + 40)
direction = -1;
else
direction = 0;
@@ -680,11 +689,11 @@ void Mob::wander(int timeRun){
if(aggressive && !YAYA &&
player->loc.x + (width / 2) > loc.x && player->loc.x + (width / 2) < loc.x + width &&
- player->loc.y + (height / 3) > loc.y && player->loc.y + (height / 3) < loc.y + height ){
- if ( !ui::dialogBoxExists ) {
+ player->loc.y + (height / 3) > loc.y && player->loc.y + (height / 3) < loc.y + height){
+ if (!ui::dialogBoxExists) {
Arena *a = new Arena(currentWorld,player,this);
a->setStyle("");
- a->setBackground( WorldBGType::Forest );
+ a->setBackground(WorldBGType::Forest);
a->setBGM("assets/music/embark.wav");
ui::toggleWhiteFast();
@@ -721,7 +730,7 @@ void Mob::wander(int timeRun){
break;
case MS_TRIGGER:
if(player->loc.x + player->width / 2 > loc.x &&
- player->loc.x + player->width / 2 < loc.x + width )
+ player->loc.x + player->width / 2 < loc.x + width)
std::thread([this]{hey(this);}).detach();
//hey(this);
break;
diff --git a/src/gameplay.cpp b/src/gameplay.cpp
index 7b5b3ba..66b7f1d 100644
--- a/src/gameplay.cpp
+++ b/src/gameplay.cpp
@@ -69,10 +69,10 @@ int commonAIFunc(NPC *speaker){
if((oxml = exml->FirstChildElement("quest"))){
std::string qname;
- while ( oxml ) {
- if ( !(qname = oxml->StrAttribute("assign")).empty() )
+ while (oxml) {
+ if (!(qname = oxml->StrAttribute("assign")).empty())
player->qh.assign(qname,"None",(std::string)oxml->GetText());
- else if( !(qname = oxml->StrAttribute("check")).empty() ){
+ else if(!(qname = oxml->StrAttribute("check")).empty()){
if(player->qh.hasQuest(qname) && player->qh.finish(qname)){
goto CONT;
}else{
@@ -114,7 +114,7 @@ CONT:
* Handle 'go to' thingy
*/
- if ( (oxml = exml->FirstChildElement("gotox")) )
+ if ((oxml = exml->FirstChildElement("gotox")))
speaker->targetx = atoi(oxml->GetText());
/*
@@ -218,8 +218,8 @@ CONT:
return 0;
}
-void commonPageFunc( Mob *callee ){
- ui::drawPage( callee->heyid );
+void commonPageFunc(Mob *callee){
+ ui::drawPage(callee->heyid);
ui::waitForDialog();
callee->health = 0;
}
@@ -272,7 +272,7 @@ void initEverything(void){
* Read the XML directory into an array.
*/
- if ( getdir( std::string("./" + xmlFolder).c_str(), xmlFiles ) )
+ if (getdir(std::string("./" + xmlFolder).c_str(), xmlFiles))
UserError("Error reading XML files!!!");
/*
@@ -312,7 +312,7 @@ void initEverything(void){
optionsMenu.items.push_back(ui::menu::createSlider({-200,000}, {512,50}, {0.0f, 0.0f, 0.0f}, 0, 100, "SFX", &VOLUME_SFX));
optionsMenu.child = NULL;
optionsMenu.parent = &pauseMenu;
- // optionsMenu.push_back(ui::menu::createButton({-256/2,-200},{256,75},{0.0f,0.0f,0.0f}, (const char*)("Save and Quit"), );
+ // optionsMenu.push_back(ui::menu::createButton({-256/2,-200},{256,75},{0.0f,0.0f,0.0f}, (const char*)("Save and Quit"),);
/*
* Spawn the player and begin the game.
diff --git a/src/inventory.cpp b/src/inventory.cpp
index 64254e9..1b2d378 100644
--- a/src/inventory.cpp
+++ b/src/inventory.cpp
@@ -49,7 +49,7 @@ int Inventory::addItem(std::string name,uint count){
return 0;
}
}
- items.push_back( item_t { count, i });
+ items.push_back(item_t { count, i });
return 0;
}
}
@@ -145,11 +145,11 @@ const char *getItemTexturePath(std::string name){
}
GLuint getItemTexture(std::string name){
- for ( int i = itemMap.size(); i--; ) {
- if ( itemMap[i]->name == name )
+ for (int i = itemMap.size(); i--;) {
+ if (itemMap[i]->name == name)
return itemtex[i];
}
- DEBUG_printf("Failed to find texture for item %s!", name.c_str() );
+ DEBUG_printf("Failed to find texture for item %s!", name.c_str());
return 0;
}
@@ -182,12 +182,12 @@ void Inventory::setSelection(unsigned int s){
}
void Inventory::setSelectionUp(){
- if ( !sel-- )
+ if (!sel--)
sel++;
}
void Inventory::setSelectionDown(){
- if ( ++sel >= numSlot )
+ if (++sel >= numSlot)
sel = numSlot - 1;
}
@@ -215,79 +215,79 @@ void Inventory::draw(void){
static vec2 mouseStart = {0,0};
C("End define");
- for ( auto &r : iray ) {
+ for (auto &r : iray) {
r.start.x = player->loc.x + (player->width / 2);
r.start.y = player->loc.y + (player->height / 2);
curCoord[a++] = r.start;
} a = 0;
- for ( auto &cr : curRay ) {
+ for (auto &cr : curRay) {
cr.start.x = (offset.x + SCREEN_WIDTH / 2);
cr.start.y = offset.y - (a * itemWide * 1.5f);
curCurCoord[a++] = cr.start;
} a = 0;
- for ( int r = 0; r < 4; r++ ) {
- for ( int c = 0; c < 8; c++ ) {
- massRay[a ].x = ((offset.x - SCREEN_WIDTH / 2) + itemWide ) + c * itemWide * 1.5f;
+ for (int r = 0; r < 4; r++) {
+ for (int c = 0; c < 8; c++) {
+ massRay[a ].x = ((offset.x - SCREEN_WIDTH / 2) + itemWide) + c * itemWide * 1.5f;
massRay[a++].y = ((offset.y + SCREEN_HEIGHT / 2) - itemWide * 1.5f) - r * itemWide * 1.5f;
}
} a = 0;
ui::fontTransInv = 255 * (averagef(dfp) / range);
- if ( ui::fontTransInv > 255 )
+ if (ui::fontTransInv > 255)
ui::fontTransInv = 255;
- else if ( ui::fontTransInv < 0 )
+ else if (ui::fontTransInv < 0)
ui::fontTransInv = 0;
- if ( invOpening ) {
- for ( auto &d : dfp ) {
- if ( !a || dfp[a - 1] > 50 )
+ if (invOpening) {
+ for (auto &d : dfp) {
+ if (!a || dfp[a - 1] > 50)
d += 1.65f * deltaTime;
- if ( d > range )
+ if (d > range)
d = range;
a++;
} a = 0;
- for ( auto &cd : curdfp ) {
- if ( !a || curdfp[a - 1] > 90 )
+ for (auto &cd : curdfp) {
+ if (!a || curdfp[a - 1] > 90)
cd += 1.5f * deltaTime;
- if ( cd > curRange )
+ if (cd > curRange)
cd = curRange;
a++;
} a = 0;
- while ( ++a < massOrder.size() ) {
- if ( !a || massDfp[ massOrder[a - 1] ] > massRange * 0.75f )
+ while (++a < massOrder.size()) {
+ if (!a || massDfp[ massOrder[a - 1] ] > massRange * 0.75f)
massDfp[ massOrder[a] ] += 5.0f * deltaTime;
- if ( massDfp[ massOrder[a] ] > massRange )
+ if (massDfp[ massOrder[a] ] > massRange)
massDfp[ massOrder[a] ] = massRange;
} a = 0;
- if ( numSlot > 0 )
+ if (numSlot > 0)
invOpen = true;
} else {
- for ( auto &d : dfp ) {
- if ( d > 0 )
+ for (auto &d : dfp) {
+ if (d > 0)
d -= 1.65f * deltaTime;
}
- for ( auto &cd : curdfp ) {
- if ( cd > 0 )
+ for (auto &cd : curdfp) {
+ if (cd > 0)
cd -= 1.0f * deltaTime;
}
a = 0;
- while ( ++a < massRay.size() ) {
- if ( !a || massDfp[ massOrderClosing[a - 1] ] <= 0 )
+ while (++a < massRay.size()) {
+ if (!a || massDfp[ massOrderClosing[a - 1] ] <= 0)
massDfp[ massOrderClosing[a] ] -= 10.0f * deltaTime;
- if ( massDfp[ massOrderClosing[a - 1] ] < 0 )
+ if (massDfp[ massOrderClosing[a - 1] ] < 0)
massDfp[ massOrderClosing[a - 1] ] = 0;
} a = 0;
- if ( std::all_of( std::begin(massDfp), std::end(massDfp), [](auto d){ return d <= 0; } ) ) {
+ if (std::all_of(std::begin(massDfp), std::end(massDfp), [](auto d){ return d <= 0; })) {
invOpen = false;
- for ( auto &md : massDfp ) {
- if ( md < 0 )
+ for (auto &md : massDfp) {
+ if (md < 0)
md = 0;
}
}
@@ -546,10 +546,10 @@ void itemDraw(Player *p,uint id){
} else
hangle = 0;
- if ( p->inv->usingi )
+ if (p->inv->usingi)
inc = 10;
- if ( inc ) {
+ if (inc) {
inc--;
p->inv->useItem();
}
@@ -574,31 +574,31 @@ void itemDraw(Player *p,uint id){
glUseProgram(0);
}
-int Inventory::useItem( void )
+int Inventory::useItem(void)
{
static bool up = false;
- if ( !invHover ) {
- if ( itemMap[items[sel].id]->type == "Sword" ) {
- if ( swing ) {
+ if (!invHover) {
+ if (itemMap[items[sel].id]->type == "Sword") {
+ if (swing) {
int dir = player->left ? 1 : -1;
- if ( hangle == 15 * dir ) {
+ if (hangle == 15 * dir) {
up = true;
- Mix_PlayChannel( 2, swordSwing, 0 );
+ Mix_PlayChannel(2, swordSwing, 0);
}
- if ( up )
+ if (up)
hangle += 0.325f * dir * deltaTime;
- if ( !player->left ) {
- if ( hangle <= -90 )
+ if (!player->left) {
+ if (hangle <= -90)
hangle = -14;
- } else if ( hangle >= 90 )
+ } else if (hangle >= 90)
hangle = 14;
} else {
swing = true;
- Mix_PlayChannel( 2, swordSwing, 0 );
+ Mix_PlayChannel(2, swordSwing, 0);
}
}else if(itemMap[items[sel].id]->type == "Cooked Food"){
player->health += itemMap[items[sel].id]->attribValue;
diff --git a/src/quest.cpp b/src/quest.cpp
index 4ab827f..afeec6b 100644
--- a/src/quest.cpp
+++ b/src/quest.cpp
@@ -12,45 +12,45 @@ int QuestHandler::assign(std::string title,std::string desc,std::string req){
tmp.title = title;
tmp.desc = desc;
- tok = strtok( &req[0], "\n\r\t," );
- tmp.need.emplace_back( "", 0 );
+ tok = strtok(&req[0], "\n\r\t,");
+ tmp.need.emplace_back("", 0);
- while ( tok ) {
- if ( !tmp.need.back().first.empty() ) {
- tmp.need.back().second = atoi( tok );
- tmp.need.emplace_back( "", 0 );
+ while (tok) {
+ if (!tmp.need.back().first.empty()) {
+ tmp.need.back().second = atoi(tok);
+ tmp.need.emplace_back("", 0);
} else
tmp.need.back().first = tok;
- tok = strtok( NULL, "\n\r\t," );
+ tok = strtok(NULL, "\n\r\t,");
}
tmp.need.pop_back();
- current.push_back( tmp );
+ current.push_back(tmp);
return 0;
}
int QuestHandler::drop(std::string title){
- current.erase( std::remove_if( current.begin(),
+ current.erase(std::remove_if(current.begin(),
current.end(),
[&](Quest q){ return q.title == title; }),
- current.end() );
+ current.end());
return 0;
}
int QuestHandler::finish(std::string t){
- for ( auto c = current.begin(); c != current.end(); c++ ) {
- if ( (*c).title == t ) {
- for ( auto &n : (*c).need ) {
- if ( player->inv->hasItem( n.first ) < n.second )
+ for (auto c = current.begin(); c != current.end(); c++) {
+ if ((*c).title == t) {
+ for (auto &n : (*c).need) {
+ if (player->inv->hasItem(n.first) < n.second)
return 0;
}
- for ( auto &n : (*c).need )
- player->inv->takeItem( n.first, n.second );
- current.erase( c );
+ for (auto &n : (*c).need)
+ player->inv->takeItem(n.first, n.second);
+ current.erase(c);
return 1;
}
}
@@ -59,8 +59,8 @@ int QuestHandler::finish(std::string t){
}
bool QuestHandler::hasQuest(std::string t){
- for ( auto &c : current ) {
- if ( c.title == t )
+ for (auto &c : current) {
+ if (c.title == t)
return true;
}
diff --git a/src/texture.cpp b/src/texture.cpp
index 1f8dca3..a61d426 100644
--- a/src/texture.cpp
+++ b/src/texture.cpp
@@ -78,7 +78,7 @@ namespace Texture{
GL_RGBA,
GL_UNSIGNED_BYTE,
image->pixels
- );
+ );
// add texture to LoadedTexture
LoadedTexture.push_back(texture_t{fileName,object,{image->w,image->h}});
@@ -171,25 +171,25 @@ Texturec::Texturec(uint amt, ...){
texState = 0;
va_start(fNames, amt);
for(unsigned int i = 0; i < amt; i++)
- image.push_back( Texture::loadTexture(va_arg(fNames, char *)) );
+ image.push_back(Texture::loadTexture(va_arg(fNames, char *)));
va_end(fNames);
}
-Texturec::Texturec( std::initializer_list<std::string> l )
+Texturec::Texturec(std::initializer_list<std::string> l)
{
texState = 0;
- std::for_each( l.begin(), l.end(), [&](std::string s){ image.push_back( Texture::loadTexture( s ) ); });
+ std::for_each(l.begin(), l.end(), [&](std::string s){ image.push_back(Texture::loadTexture(s)); });
}
Texturec::Texturec(std::vector<std::string>v){
texState = 0;
- std::for_each( v.begin(), v.end(), [&](std::string s){ image.push_back( Texture::loadTexture( s ) ); });
+ std::for_each(v.begin(), v.end(), [&](std::string s){ image.push_back(Texture::loadTexture(s)); });
}
Texturec::Texturec(uint amt,const char **paths){
texState = 0;
for(unsigned int i = 0; i < amt; i++)
- image.push_back( Texture::loadTexture(paths[i]) );
+ image.push_back(Texture::loadTexture(paths[i]));
}
Texturec::~Texturec(){
diff --git a/src/tinyxml2.cpp b/src/tinyxml2.cpp
index 6198418..1388489 100755
--- a/src/tinyxml2.cpp
+++ b/src/tinyxml2.cpp
@@ -32,7 +32,7 @@ distribution.
# include <cstdarg>
#endif
-#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
+#if defined(_MSC_VER) && (_MSC_VER >= 1400) && (!defined WINCE)
// Microsoft Visual Studio, version 2005 and higher. Not WinCE.
/*int _snprintf_s(
char *buffer,
@@ -41,18 +41,18 @@ distribution.
const char *format [,
argument] ...
);*/
- static inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
+ static inline int TIXML_SNPRINTF(char* buffer, size_t size, const char* format, ...)
{
va_list va;
- va_start( va, format );
- int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
- va_end( va );
+ va_start(va, format);
+ int result = vsnprintf_s(buffer, size, _TRUNCATE, format, va);
+ va_end(va);
return result;
}
- static inline int TIXML_VSNPRINTF( char* buffer, size_t size, const char* format, va_list va )
+ static inline int TIXML_VSNPRINTF(char* buffer, size_t size, const char* format, va_list va)
{
- int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
+ int result = vsnprintf_s(buffer, size, _TRUNCATE, format, va);
return result;
}
@@ -63,12 +63,12 @@ distribution.
#define TIXML_SNPRINTF _snprintf
#define TIXML_VSNPRINTF _vsnprintf
#define TIXML_SSCANF sscanf
- #if (_MSC_VER < 1400 ) && (!defined WINCE)
+ #if (_MSC_VER < 1400) && (!defined WINCE)
// Microsoft Visual Studio 2003 and not WinCE.
#define TIXML_VSCPRINTF _vscprintf // VS2003's C runtime has this, but VC6 C runtime or WinCE SDK doesn't have.
#else
// Microsoft Visual Studio 2003 and earlier or WinCE.
- static inline int TIXML_VSCPRINTF( const char* format, va_list va )
+ static inline int TIXML_VSCPRINTF(const char* format, va_list va)
{
int len = 512;
for (;;) {
@@ -76,25 +76,25 @@ distribution.
char* str = new char[len]();
const int required = _vsnprintf(str, len, format, va);
delete[] str;
- if ( required != -1 ) {
- TIXMLASSERT( required >= 0 );
+ if (required != -1) {
+ TIXMLASSERT(required >= 0);
len = required;
break;
}
}
- TIXMLASSERT( len >= 0 );
+ TIXMLASSERT(len >= 0);
return len;
}
#endif
#else
// GCC version 3 and higher
- //#warning( "Using sn* functions." )
+ //#warning("Using sn* functions.")
#define TIXML_SNPRINTF snprintf
#define TIXML_VSNPRINTF vsnprintf
- static inline int TIXML_VSCPRINTF( const char* format, va_list va )
+ static inline int TIXML_VSCPRINTF(const char* format, va_list va)
{
- int len = vsnprintf( 0, 0, format, va );
- TIXMLASSERT( len >= 0 );
+ int len = vsnprintf(0, 0, format, va);
+ TIXMLASSERT(len >= 0);
return len;
}
#define TIXML_SSCANF sscanf
@@ -141,17 +141,17 @@ StrPair::~StrPair()
}
-void StrPair::TransferTo( StrPair* other )
+void StrPair::TransferTo(StrPair* other)
{
- if ( this == other ) {
+ if (this == other) {
return;
}
// This in effect implements the assignment operator by "moving"
// ownership (as in auto_ptr).
- TIXMLASSERT( other->_flags == 0 );
- TIXMLASSERT( other->_start == 0 );
- TIXMLASSERT( other->_end == 0 );
+ TIXMLASSERT(other->_flags == 0);
+ TIXMLASSERT(other->_start == 0);
+ TIXMLASSERT(other->_end == 0);
other->Reset();
@@ -166,7 +166,7 @@ void StrPair::TransferTo( StrPair* other )
void StrPair::Reset()
{
- if ( _flags & NEEDS_DELETE ) {
+ if (_flags & NEEDS_DELETE) {
delete [] _start;
}
_flags = 0;
@@ -175,31 +175,31 @@ void StrPair::Reset()
}
-void StrPair::SetStr( const char* str, int flags )
+void StrPair::SetStr(const char* str, int flags)
{
- TIXMLASSERT( str );
+ TIXMLASSERT(str);
Reset();
- size_t len = strlen( str );
- TIXMLASSERT( _start == 0 );
+ size_t len = strlen(str);
+ TIXMLASSERT(_start == 0);
_start = new char[ len+1 ];
- memcpy( _start, str, len+1 );
+ memcpy(_start, str, len+1);
_end = _start + len;
_flags = flags | NEEDS_DELETE;
}
-char* StrPair::ParseText( char* p, const char* endTag, int strFlags )
+char* StrPair::ParseText(char* p, const char* endTag, int strFlags)
{
- TIXMLASSERT( endTag && *endTag );
+ TIXMLASSERT(endTag && *endTag);
char* start = p;
char endChar = *endTag;
- size_t length = strlen( endTag );
+ size_t length = strlen(endTag);
// Inner loop of text parsing.
- while ( *p ) {
- if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {
- Set( start, p, strFlags );
+ while (*p) {
+ if (*p == endChar && strncmp(p, endTag, length) == 0) {
+ Set(start, p, strFlags);
return p + length;
}
++p;
@@ -208,22 +208,22 @@ char* StrPair::ParseText( char* p, const char* endTag, int strFlags )
}
-char* StrPair::ParseName( char* p )
+char* StrPair::ParseName(char* p)
{
- if ( !p || !(*p) ) {
+ if (!p || !(*p)) {
return 0;
}
- if ( !XMLUtil::IsNameStartChar( *p ) ) {
+ if (!XMLUtil::IsNameStartChar(*p)) {
return 0;
}
char* const start = p;
++p;
- while ( *p && XMLUtil::IsNameChar( *p ) ) {
+ while (*p && XMLUtil::IsNameChar(*p)) {
++p;
}
- Set( start, p, 0 );
+ Set(start, p, 0);
return p;
}
@@ -231,18 +231,18 @@ char* StrPair::ParseName( char* p )
void StrPair::CollapseWhitespace()
{
// Adjusting _start would cause undefined behavior on delete[]
- TIXMLASSERT( ( _flags & NEEDS_DELETE ) == 0 );
+ TIXMLASSERT((_flags & NEEDS_DELETE) == 0);
// Trim leading space.
- _start = XMLUtil::SkipWhiteSpace( _start );
+ _start = XMLUtil::SkipWhiteSpace(_start);
- if ( *_start ) {
+ if (*_start) {
char* p = _start; // the read pointer
char* q = _start; // the write pointer
- while( *p ) {
- if ( XMLUtil::IsWhiteSpace( *p )) {
- p = XMLUtil::SkipWhiteSpace( p );
- if ( *p == 0 ) {
+ while(*p) {
+ if (XMLUtil::IsWhiteSpace(*p)) {
+ p = XMLUtil::SkipWhiteSpace(p);
+ if (*p == 0) {
break; // don't write to q; this trims the trailing space.
}
*q = ' ';
@@ -259,22 +259,22 @@ void StrPair::CollapseWhitespace()
const char* StrPair::GetStr()
{
- TIXMLASSERT( _start );
- TIXMLASSERT( _end );
- if ( _flags & NEEDS_FLUSH ) {
+ TIXMLASSERT(_start);
+ TIXMLASSERT(_end);
+ if (_flags & NEEDS_FLUSH) {
*_end = 0;
_flags ^= NEEDS_FLUSH;
- if ( _flags ) {
+ if (_flags) {
char* p = _start; // the read pointer
char* q = _start; // the write pointer
- while( p < _end ) {
- if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) {
+ while(p < _end) {
+ if ((_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR) {
// CR-LF pair becomes LF
// CR alone becomes LF
// LF-CR becomes LF
- if ( *(p+1) == LF ) {
+ if (*(p+1) == LF) {
p += 2;
}
else {
@@ -282,8 +282,8 @@ const char* StrPair::GetStr()
}
*q++ = LF;
}
- else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {
- if ( *(p+1) == CR ) {
+ else if ((_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF) {
+ if (*(p+1) == CR) {
p += 2;
}
else {
@@ -291,36 +291,36 @@ const char* StrPair::GetStr()
}
*q++ = LF;
}
- else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {
+ else if ((_flags & NEEDS_ENTITY_PROCESSING) && *p == '&') {
// Entities handled by tinyXML2:
// - special entities in the entity table [in/out]
// - numeric character reference [in]
// &#20013; or &#x4e2d;
- if ( *(p+1) == '#' ) {
+ if (*(p+1) == '#') {
const int buflen = 10;
char buf[buflen] = { 0 };
int len = 0;
- char* adjusted = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );
- if ( adjusted == 0 ) {
+ char* adjusted = const_cast<char*>(XMLUtil::GetCharacterRef(p, buf, &len));
+ if (adjusted == 0) {
*q = *p;
++p;
++q;
}
else {
- TIXMLASSERT( 0 <= len && len <= buflen );
- TIXMLASSERT( q + len <= adjusted );
+ TIXMLASSERT(0 <= len && len <= buflen);
+ TIXMLASSERT(q + len <= adjusted);
p = adjusted;
- memcpy( q, buf, len );
+ memcpy(q, buf, len);
q += len;
}
}
else {
bool entityFound = false;
- for( int i = 0; i < NUM_ENTITIES; ++i ) {
+ for(int i = 0; i < NUM_ENTITIES; ++i) {
const Entity& entity = entities[i];
- if ( strncmp( p + 1, entity.pattern, entity.length ) == 0
- && *( p + entity.length + 1 ) == ';' ) {
+ if (strncmp(p + 1, entity.pattern, entity.length) == 0
+ && *(p + entity.length + 1) == ';') {
// Found an entity - convert.
*q = entity.value;
++q;
@@ -329,7 +329,7 @@ const char* StrPair::GetStr()
break;
}
}
- if ( !entityFound ) {
+ if (!entityFound) {
// fixme: treat as error?
++p;
++q;
@@ -346,12 +346,12 @@ const char* StrPair::GetStr()
}
// The loop below has plenty going on, and this
// is a less useful mode. Break it out.
- if ( _flags & NEEDS_WHITESPACE_COLLAPSING ) {
+ if (_flags & NEEDS_WHITESPACE_COLLAPSING) {
CollapseWhitespace();
}
_flags = (_flags & NEEDS_DELETE);
}
- TIXMLASSERT( _start );
+ TIXMLASSERT(_start);
return _start;
}
@@ -360,25 +360,25 @@ const char* StrPair::GetStr()
// --------- XMLUtil ----------- //
-const char* XMLUtil::ReadBOM( const char* p, bool* bom )
+const char* XMLUtil::ReadBOM(const char* p, bool* bom)
{
- TIXMLASSERT( p );
- TIXMLASSERT( bom );
+ TIXMLASSERT(p);
+ TIXMLASSERT(bom);
*bom = false;
const unsigned char* pu = reinterpret_cast<const unsigned char*>(p);
// Check for BOM:
- if ( *(pu+0) == TIXML_UTF_LEAD_0
+ if (*(pu+0) == TIXML_UTF_LEAD_0
&& *(pu+1) == TIXML_UTF_LEAD_1
- && *(pu+2) == TIXML_UTF_LEAD_2 ) {
+ && *(pu+2) == TIXML_UTF_LEAD_2) {
*bom = true;
p += 3;
}
- TIXMLASSERT( p );
+ TIXMLASSERT(p);
return p;
}
-void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )
+void XMLUtil::ConvertUTF32ToUTF8(unsigned long input, char* output, int* length)
{
const unsigned long BYTE_MASK = 0xBF;
const unsigned long BYTE_MARK = 0x80;
@@ -387,13 +387,13 @@ void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length
if (input < 0x80) {
*length = 1;
}
- else if ( input < 0x800 ) {
+ else if (input < 0x800) {
*length = 2;
}
- else if ( input < 0x10000 ) {
+ else if (input < 0x10000) {
*length = 3;
}
- else if ( input < 0x200000 ) {
+ else if (input < 0x200000) {
*length = 4;
}
else {
@@ -422,61 +422,61 @@ void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length
*output = (char)(input | FIRST_BYTE_MARK[*length]);
break;
default:
- TIXMLASSERT( false );
+ TIXMLASSERT(false);
}
}
-const char* XMLUtil::GetCharacterRef( const char* p, char* value, int* length )
+const char* XMLUtil::GetCharacterRef(const char* p, char* value, int* length)
{
// Presume an entity, and pull it out.
*length = 0;
- if ( *(p+1) == '#' && *(p+2) ) {
+ if (*(p+1) == '#' && *(p+2)) {
unsigned long ucs = 0;
- TIXMLASSERT( sizeof( ucs ) >= 4 );
+ TIXMLASSERT(sizeof(ucs) >= 4);
ptrdiff_t delta = 0;
unsigned mult = 1;
static const char SEMICOLON = ';';
- if ( *(p+2) == 'x' ) {
+ if (*(p+2) == 'x') {
// Hexadecimal.
const char* q = p+3;
- if ( !(*q) ) {
+ if (!(*q)) {
return 0;
}
- q = strchr( q, SEMICOLON );
+ q = strchr(q, SEMICOLON);
- if ( !q ) {
+ if (!q) {
return 0;
}
- TIXMLASSERT( *q == SEMICOLON );
+ TIXMLASSERT(*q == SEMICOLON);
delta = q-p;
--q;
- while ( *q != 'x' ) {
+ while (*q != 'x') {
unsigned int digit = 0;
- if ( *q >= '0' && *q <= '9' ) {
+ if (*q >= '0' && *q <= '9') {
digit = *q - '0';
}
- else if ( *q >= 'a' && *q <= 'f' ) {
+ else if (*q >= 'a' && *q <= 'f') {
digit = *q - 'a' + 10;
}
- else if ( *q >= 'A' && *q <= 'F' ) {
+ else if (*q >= 'A' && *q <= 'F') {
digit = *q - 'A' + 10;
}
else {
return 0;
}
- TIXMLASSERT( digit >= 0 && digit < 16);
- TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );
+ TIXMLASSERT(digit >= 0 && digit < 16);
+ TIXMLASSERT(digit == 0 || mult <= UINT_MAX / digit);
const unsigned int digitScaled = mult * digit;
- TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );
+ TIXMLASSERT(ucs <= ULONG_MAX - digitScaled);
ucs += digitScaled;
- TIXMLASSERT( mult <= UINT_MAX / 16 );
+ TIXMLASSERT(mult <= UINT_MAX / 16);
mult *= 16;
--q;
}
@@ -484,106 +484,106 @@ const char* XMLUtil::GetCharacterRef( const char* p, char* value, int* length )
else {
// Decimal.
const char* q = p+2;
- if ( !(*q) ) {
+ if (!(*q)) {
return 0;
}
- q = strchr( q, SEMICOLON );
+ q = strchr(q, SEMICOLON);
- if ( !q ) {
+ if (!q) {
return 0;
}
- TIXMLASSERT( *q == SEMICOLON );
+ TIXMLASSERT(*q == SEMICOLON);
delta = q-p;
--q;
- while ( *q != '#' ) {
- if ( *q >= '0' && *q <= '9' ) {
+ while (*q != '#') {
+ if (*q >= '0' && *q <= '9') {
const unsigned int digit = *q - '0';
- TIXMLASSERT( digit >= 0 && digit < 10);
- TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );
+ TIXMLASSERT(digit >= 0 && digit < 10);
+ TIXMLASSERT(digit == 0 || mult <= UINT_MAX / digit);
const unsigned int digitScaled = mult * digit;
- TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );
+ TIXMLASSERT(ucs <= ULONG_MAX - digitScaled);
ucs += digitScaled;
}
else {
return 0;
}
- TIXMLASSERT( mult <= UINT_MAX / 10 );
+ TIXMLASSERT(mult <= UINT_MAX / 10);
mult *= 10;
--q;
}
}
// convert the UCS to UTF-8
- ConvertUTF32ToUTF8( ucs, value, length );
+ ConvertUTF32ToUTF8(ucs, value, length);
return p + delta + 1;
}
return p+1;
}
-void XMLUtil::ToStr( int v, char* buffer, int bufferSize )
+void XMLUtil::ToStr(int v, char* buffer, int bufferSize)
{
- TIXML_SNPRINTF( buffer, bufferSize, "%d", v );
+ TIXML_SNPRINTF(buffer, bufferSize, "%d", v);
}
-void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize )
+void XMLUtil::ToStr(unsigned v, char* buffer, int bufferSize)
{
- TIXML_SNPRINTF( buffer, bufferSize, "%u", v );
+ TIXML_SNPRINTF(buffer, bufferSize, "%u", v);
}
-void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )
+void XMLUtil::ToStr(bool v, char* buffer, int bufferSize)
{
- TIXML_SNPRINTF( buffer, bufferSize, "%d", v ? 1 : 0 );
+ TIXML_SNPRINTF(buffer, bufferSize, "%d", v ? 1 : 0);
}
/*
ToStr() of a number is a very tricky topic.
https://github.com/leethomason/tinyxml2/issues/106
*/
-void XMLUtil::ToStr( float v, char* buffer, int bufferSize )
+void XMLUtil::ToStr(float v, char* buffer, int bufferSize)
{
- TIXML_SNPRINTF( buffer, bufferSize, "%.8g", v );
+ TIXML_SNPRINTF(buffer, bufferSize, "%.8g", v);
}
-void XMLUtil::ToStr( double v, char* buffer, int bufferSize )
+void XMLUtil::ToStr(double v, char* buffer, int bufferSize)
{
- TIXML_SNPRINTF( buffer, bufferSize, "%.17g", v );
+ TIXML_SNPRINTF(buffer, bufferSize, "%.17g", v);
}
-bool XMLUtil::ToInt( const char* str, int* value )
+bool XMLUtil::ToInt(const char* str, int* value)
{
- if ( TIXML_SSCANF( str, "%d", value ) == 1 ) {
+ if (TIXML_SSCANF(str, "%d", value) == 1) {
return true;
}
return false;
}
-bool XMLUtil::ToUnsigned( const char* str, unsigned *value )
+bool XMLUtil::ToUnsigned(const char* str, unsigned *value)
{
- if ( TIXML_SSCANF( str, "%u", value ) == 1 ) {
+ if (TIXML_SSCANF(str, "%u", value) == 1) {
return true;
}
return false;
}
-bool XMLUtil::ToBool( const char* str, bool* value )
+bool XMLUtil::ToBool(const char* str, bool* value)
{
int ival = 0;
- if ( ToInt( str, &ival )) {
+ if (ToInt(str, &ival)) {
*value = (ival==0) ? false : true;
return true;
}
- if ( StringEqual( str, "true" ) ) {
+ if (StringEqual(str, "true")) {
*value = true;
return true;
}
- else if ( StringEqual( str, "false" ) ) {
+ else if (StringEqual(str, "false")) {
*value = false;
return true;
}
@@ -591,32 +591,32 @@ bool XMLUtil::ToBool( const char* str, bool* value )
}
-bool XMLUtil::ToFloat( const char* str, float* value )
+bool XMLUtil::ToFloat(const char* str, float* value)
{
- if ( TIXML_SSCANF( str, "%f", value ) == 1 ) {
+ if (TIXML_SSCANF(str, "%f", value) == 1) {
return true;
}
return false;
}
-bool XMLUtil::ToDouble( const char* str, double* value )
+bool XMLUtil::ToDouble(const char* str, double* value)
{
- if ( TIXML_SSCANF( str, "%lf", value ) == 1 ) {
+ if (TIXML_SSCANF(str, "%lf", value) == 1) {
return true;
}
return false;
}
-char* XMLDocument::Identify( char* p, XMLNode** node )
+char* XMLDocument::Identify(char* p, XMLNode** node)
{
- TIXMLASSERT( node );
- TIXMLASSERT( p );
+ TIXMLASSERT(node);
+ TIXMLASSERT(p);
char* const start = p;
- p = XMLUtil::SkipWhiteSpace( p );
- if( !*p ) {
+ p = XMLUtil::SkipWhiteSpace(p);
+ if(!*p) {
*node = 0;
- TIXMLASSERT( p );
+ TIXMLASSERT(p);
return p;
}
@@ -633,77 +633,77 @@ char* XMLDocument::Identify( char* p, XMLNode** node )
static const int dtdHeaderLen = 2;
static const int elementHeaderLen = 1;
- TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) ); // use same memory pool
- TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) ); // use same memory pool
+ TIXMLASSERT(sizeof(XMLComment) == sizeof(XMLUnknown)); // use same memory pool
+ TIXMLASSERT(sizeof(XMLComment) == sizeof(XMLDeclaration)); // use same memory pool
XMLNode* returnNode = 0;
- if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {
- TIXMLASSERT( sizeof( XMLDeclaration ) == _commentPool.ItemSize() );
- returnNode = new (_commentPool.Alloc()) XMLDeclaration( this );
+ if (XMLUtil::StringEqual(p, xmlHeader, xmlHeaderLen)) {
+ TIXMLASSERT(sizeof(XMLDeclaration) == _commentPool.ItemSize());
+ returnNode = new (_commentPool.Alloc()) XMLDeclaration(this);
returnNode->_memPool = &_commentPool;
p += xmlHeaderLen;
}
- else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {
- TIXMLASSERT( sizeof( XMLComment ) == _commentPool.ItemSize() );
- returnNode = new (_commentPool.Alloc()) XMLComment( this );
+ else if (XMLUtil::StringEqual(p, commentHeader, commentHeaderLen)) {
+ TIXMLASSERT(sizeof(XMLComment) == _commentPool.ItemSize());
+ returnNode = new (_commentPool.Alloc()) XMLComment(this);
returnNode->_memPool = &_commentPool;
p += commentHeaderLen;
}
- else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {
- TIXMLASSERT( sizeof( XMLText ) == _textPool.ItemSize() );
- XMLText* text = new (_textPool.Alloc()) XMLText( this );
+ else if (XMLUtil::StringEqual(p, cdataHeader, cdataHeaderLen)) {
+ TIXMLASSERT(sizeof(XMLText) == _textPool.ItemSize());
+ XMLText* text = new (_textPool.Alloc()) XMLText(this);
returnNode = text;
returnNode->_memPool = &_textPool;
p += cdataHeaderLen;
- text->SetCData( true );
+ text->SetCData(true);
}
- else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {
- TIXMLASSERT( sizeof( XMLUnknown ) == _commentPool.ItemSize() );
- returnNode = new (_commentPool.Alloc()) XMLUnknown( this );
+ else if (XMLUtil::StringEqual(p, dtdHeader, dtdHeaderLen)) {
+ TIXMLASSERT(sizeof(XMLUnknown) == _commentPool.ItemSize());
+ returnNode = new (_commentPool.Alloc()) XMLUnknown(this);
returnNode->_memPool = &_commentPool;
p += dtdHeaderLen;
}
- else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {
- TIXMLASSERT( sizeof( XMLElement ) == _elementPool.ItemSize() );
- returnNode = new (_elementPool.Alloc()) XMLElement( this );
+ else if (XMLUtil::StringEqual(p, elementHeader, elementHeaderLen)) {
+ TIXMLASSERT(sizeof(XMLElement) == _elementPool.ItemSize());
+ returnNode = new (_elementPool.Alloc()) XMLElement(this);
returnNode->_memPool = &_elementPool;
p += elementHeaderLen;
}
else {
- TIXMLASSERT( sizeof( XMLText ) == _textPool.ItemSize() );
- returnNode = new (_textPool.Alloc()) XMLText( this );
+ TIXMLASSERT(sizeof(XMLText) == _textPool.ItemSize());
+ returnNode = new (_textPool.Alloc()) XMLText(this);
returnNode->_memPool = &_textPool;
p = start; // Back it up, all the text counts.
}
- TIXMLASSERT( returnNode );
- TIXMLASSERT( p );
+ TIXMLASSERT(returnNode);
+ TIXMLASSERT(p);
*node = returnNode;
return p;
}
-bool XMLDocument::Accept( XMLVisitor* visitor ) const
+bool XMLDocument::Accept(XMLVisitor* visitor) const
{
- TIXMLASSERT( visitor );
- if ( visitor->VisitEnter( *this ) ) {
- for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
- if ( !node->Accept( visitor ) ) {
+ TIXMLASSERT(visitor);
+ if (visitor->VisitEnter(*this)) {
+ for (const XMLNode* node=FirstChild(); node; node=node->NextSibling()) {
+ if (!node->Accept(visitor)) {
break;
}
}
}
- return visitor->VisitExit( *this );
+ return visitor->VisitExit(*this);
}
// --------- XMLNode ----------- //
-XMLNode::XMLNode( XMLDocument* doc ) :
- _document( doc ),
- _parent( 0 ),
- _firstChild( 0 ), _lastChild( 0 ),
- _prev( 0 ), _next( 0 ),
- _memPool( 0 )
+XMLNode::XMLNode(XMLDocument* doc) :
+ _document(doc),
+ _parent(0),
+ _firstChild(0), _lastChild(0),
+ _prev(0), _next(0),
+ _memPool(0)
{
}
@@ -711,88 +711,88 @@ XMLNode::XMLNode( XMLDocument* doc ) :
XMLNode::~XMLNode()
{
DeleteChildren();
- if ( _parent ) {
- _parent->Unlink( this );
+ if (_parent) {
+ _parent->Unlink(this);
}
}
const char* XMLNode::Value() const
{
// Catch an edge case: XMLDocuments don't have a a Value. Carefully return nullptr.
- if ( this->ToDocument() )
+ if (this->ToDocument())
return 0;
return _value.GetStr();
}
-void XMLNode::SetValue( const char* str, bool staticMem )
+void XMLNode::SetValue(const char* str, bool staticMem)
{
- if ( staticMem ) {
- _value.SetInternedStr( str );
+ if (staticMem) {
+ _value.SetInternedStr(str);
}
else {
- _value.SetStr( str );
+ _value.SetStr(str);
}
}
void XMLNode::DeleteChildren()
{
- while( _firstChild ) {
- TIXMLASSERT( _lastChild );
- TIXMLASSERT( _firstChild->_document == _document );
+ while(_firstChild) {
+ TIXMLASSERT(_lastChild);
+ TIXMLASSERT(_firstChild->_document == _document);
XMLNode* node = _firstChild;
- Unlink( node );
+ Unlink(node);
- DeleteNode( node );
+ DeleteNode(node);
}
_firstChild = _lastChild = 0;
}
-void XMLNode::Unlink( XMLNode* child )
+void XMLNode::Unlink(XMLNode* child)
{
- TIXMLASSERT( child );
- TIXMLASSERT( child->_document == _document );
- TIXMLASSERT( child->_parent == this );
- if ( child == _firstChild ) {
+ TIXMLASSERT(child);
+ TIXMLASSERT(child->_document == _document);
+ TIXMLASSERT(child->_parent == this);
+ if (child == _firstChild) {
_firstChild = _firstChild->_next;
}
- if ( child == _lastChild ) {
+ if (child == _lastChild) {
_lastChild = _lastChild->_prev;
}
- if ( child->_prev ) {
+ if (child->_prev) {
child->_prev->_next = child->_next;
}
- if ( child->_next ) {
+ if (child->_next) {
child->_next->_prev = child->_prev;
}
child->_parent = 0;
}
-void XMLNode::DeleteChild( XMLNode* node )
+void XMLNode::DeleteChild(XMLNode* node)
{
- TIXMLASSERT( node );
- TIXMLASSERT( node->_document == _document );
- TIXMLASSERT( node->_parent == this );
- Unlink( node );
- DeleteNode( node );
+ TIXMLASSERT(node);
+ TIXMLASSERT(node->_document == _document);
+ TIXMLASSERT(node->_parent == this);
+ Unlink(node);
+ DeleteNode(node);
}
-XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
+XMLNode* XMLNode::InsertEndChild(XMLNode* addThis)
{
- TIXMLASSERT( addThis );
- if ( addThis->_document != _document ) {
- TIXMLASSERT( false );
+ TIXMLASSERT(addThis);
+ if (addThis->_document != _document) {
+ TIXMLASSERT(false);
return 0;
}
- InsertChildPreamble( addThis );
+ InsertChildPreamble(addThis);
- if ( _lastChild ) {
- TIXMLASSERT( _firstChild );
- TIXMLASSERT( _lastChild->_next == 0 );
+ if (_lastChild) {
+ TIXMLASSERT(_firstChild);
+ TIXMLASSERT(_lastChild->_next == 0);
_lastChild->_next = addThis;
addThis->_prev = _lastChild;
_lastChild = addThis;
@@ -800,7 +800,7 @@ XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
addThis->_next = 0;
}
else {
- TIXMLASSERT( _firstChild == 0 );
+ TIXMLASSERT(_firstChild == 0);
_firstChild = _lastChild = addThis;
addThis->_prev = 0;
@@ -811,18 +811,18 @@ XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
}
-XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
+XMLNode* XMLNode::InsertFirstChild(XMLNode* addThis)
{
- TIXMLASSERT( addThis );
- if ( addThis->_document != _document ) {
- TIXMLASSERT( false );
+ TIXMLASSERT(addThis);
+ if (addThis->_document != _document) {
+ TIXMLASSERT(false);
return 0;
}
- InsertChildPreamble( addThis );
+ InsertChildPreamble(addThis);
- if ( _firstChild ) {
- TIXMLASSERT( _lastChild );
- TIXMLASSERT( _firstChild->_prev == 0 );
+ if (_firstChild) {
+ TIXMLASSERT(_lastChild);
+ TIXMLASSERT(_firstChild->_prev == 0);
_firstChild->_prev = addThis;
addThis->_next = _firstChild;
@@ -831,7 +831,7 @@ XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
addThis->_prev = 0;
}
else {
- TIXMLASSERT( _lastChild == 0 );
+ TIXMLASSERT(_lastChild == 0);
_firstChild = _lastChild = addThis;
addThis->_prev = 0;
@@ -842,26 +842,26 @@ XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
}
-XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
+XMLNode* XMLNode::InsertAfterChild(XMLNode* afterThis, XMLNode* addThis)
{
- TIXMLASSERT( addThis );
- if ( addThis->_document != _document ) {
- TIXMLASSERT( false );
+ TIXMLASSERT(addThis);
+ if (addThis->_document != _document) {
+ TIXMLASSERT(false);
return 0;
}
- TIXMLASSERT( afterThis );
+ TIXMLASSERT(afterThis);
- if ( afterThis->_parent != this ) {
- TIXMLASSERT( false );
+ if (afterThis->_parent != this) {
+ TIXMLASSERT(false);
return 0;
}
- if ( afterThis->_next == 0 ) {
+ if (afterThis->_next == 0) {
// The last node or the only node.
- return InsertEndChild( addThis );
+ return InsertEndChild(addThis);
}
- InsertChildPreamble( addThis );
+ InsertChildPreamble(addThis);
addThis->_prev = afterThis;
addThis->_next = afterThis->_next;
afterThis->_next->_prev = addThis;
@@ -873,12 +873,12 @@ XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
-const XMLElement* XMLNode::FirstChildElement( const char* name ) const
+const XMLElement* XMLNode::FirstChildElement(const char* name) const
{
- for( const XMLNode* node = _firstChild; node; node = node->_next ) {
+ for(const XMLNode* node = _firstChild; node; node = node->_next) {
const XMLElement* element = node->ToElement();
- if ( element ) {
- if ( !name || XMLUtil::StringEqual( element->Name(), name ) ) {
+ if (element) {
+ if (!name || XMLUtil::StringEqual(element->Name(), name)) {
return element;
}
}
@@ -887,12 +887,12 @@ const XMLElement* XMLNode::FirstChildElement( const char* name ) const
}
-const XMLElement* XMLNode::LastChildElement( const char* name ) const
+const XMLElement* XMLNode::LastChildElement(const char* name) const
{
- for( const XMLNode* node = _lastChild; node; node = node->_prev ) {
+ for(const XMLNode* node = _lastChild; node; node = node->_prev) {
const XMLElement* element = node->ToElement();
- if ( element ) {
- if ( !name || XMLUtil::StringEqual( element->Name(), name ) ) {
+ if (element) {
+ if (!name || XMLUtil::StringEqual(element->Name(), name)) {
return element;
}
}
@@ -901,12 +901,12 @@ const XMLElement* XMLNode::LastChildElement( const char* name ) const
}
-const XMLElement* XMLNode::NextSiblingElement( const char* name ) const
+const XMLElement* XMLNode::NextSiblingElement(const char* name) const
{
- for( const XMLNode* node = _next; node; node = node->_next ) {
+ for(const XMLNode* node = _next; node; node = node->_next) {
const XMLElement* element = node->ToElement();
- if ( element
- && (!name || XMLUtil::StringEqual( name, element->Name() ))) {
+ if (element
+ && (!name || XMLUtil::StringEqual(name, element->Name()))) {
return element;
}
}
@@ -914,12 +914,12 @@ const XMLElement* XMLNode::NextSiblingElement( const char* name ) const
}
-const XMLElement* XMLNode::PreviousSiblingElement( const char* name ) const
+const XMLElement* XMLNode::PreviousSiblingElement(const char* name) const
{
- for( const XMLNode* node = _prev; node; node = node->_prev ) {
+ for(const XMLNode* node = _prev; node; node = node->_prev) {
const XMLElement* element = node->ToElement();
- if ( element
- && (!name || XMLUtil::StringEqual( name, element->Name() ))) {
+ if (element
+ && (!name || XMLUtil::StringEqual(name, element->Name()))) {
return element;
}
}
@@ -927,7 +927,7 @@ const XMLElement* XMLNode::PreviousSiblingElement( const char* name ) const
}
-char* XMLNode::ParseDeep( char* p, StrPair* parentEnd )
+char* XMLNode::ParseDeep(char* p, StrPair* parentEnd)
{
// This is a recursive method, but thinking about it "at the current level"
// it is a pretty simple flat list:
@@ -946,152 +946,152 @@ char* XMLNode::ParseDeep( char* p, StrPair* parentEnd )
// 'endTag' is the end tag for this node, it is returned by a call to a child.
// 'parentEnd' is the end tag for the parent, which is filled in and returned.
- while( p && *p ) {
+ while(p && *p) {
XMLNode* node = 0;
- p = _document->Identify( p, &node );
- if ( node == 0 ) {
+ p = _document->Identify(p, &node);
+ if (node == 0) {
break;
}
StrPair endTag;
- p = node->ParseDeep( p, &endTag );
- if ( !p ) {
- DeleteNode( node );
- if ( !_document->Error() ) {
- _document->SetError( XML_ERROR_PARSING, 0, 0 );
+ p = node->ParseDeep(p, &endTag);
+ if (!p) {
+ DeleteNode(node);
+ if (!_document->Error()) {
+ _document->SetError(XML_ERROR_PARSING, 0, 0);
}
break;
}
XMLDeclaration* decl = node->ToDeclaration();
- if ( decl ) {
+ if (decl) {
// A declaration can only be the first child of a document.
// Set error, if document already has children.
- if ( !_document->NoChildren() ) {
- _document->SetError( XML_ERROR_PARSING_DECLARATION, decl->Value(), 0);
- DeleteNode( decl );
+ if (!_document->NoChildren()) {
+ _document->SetError(XML_ERROR_PARSING_DECLARATION, decl->Value(), 0);
+ DeleteNode(decl);
break;
}
}
XMLElement* ele = node->ToElement();
- if ( ele ) {
+ if (ele) {
// We read the end tag. Return it to the parent.
- if ( ele->ClosingType() == XMLElement::CLOSING ) {
- if ( parentEnd ) {
- ele->_value.TransferTo( parentEnd );
+ if (ele->ClosingType() == XMLElement::CLOSING) {
+ if (parentEnd) {
+ ele->_value.TransferTo(parentEnd);
}
node->_memPool->SetTracked(); // created and then immediately deleted.
- DeleteNode( node );
+ DeleteNode(node);
return p;
}
// Handle an end tag returned to this level.
// And handle a bunch of annoying errors.
bool mismatch = false;
- if ( endTag.Empty() ) {
- if ( ele->ClosingType() == XMLElement::OPEN ) {
+ if (endTag.Empty()) {
+ if (ele->ClosingType() == XMLElement::OPEN) {
mismatch = true;
}
}
else {
- if ( ele->ClosingType() != XMLElement::OPEN ) {
+ if (ele->ClosingType() != XMLElement::OPEN) {
mismatch = true;
}
- else if ( !XMLUtil::StringEqual( endTag.GetStr(), ele->Name() ) ) {
+ else if (!XMLUtil::StringEqual(endTag.GetStr(), ele->Name())) {
mismatch = true;
}
}
- if ( mismatch ) {
- _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, ele->Name(), 0 );
- DeleteNode( node );
+ if (mismatch) {
+ _document->SetError(XML_ERROR_MISMATCHED_ELEMENT, ele->Name(), 0);
+ DeleteNode(node);
break;
}
}
- InsertEndChild( node );
+ InsertEndChild(node);
}
return 0;
}
-void XMLNode::DeleteNode( XMLNode* node )
+void XMLNode::DeleteNode(XMLNode* node)
{
- if ( node == 0 ) {
+ if (node == 0) {
return;
}
MemPool* pool = node->_memPool;
node->~XMLNode();
- pool->Free( node );
+ pool->Free(node);
}
-void XMLNode::InsertChildPreamble( XMLNode* insertThis ) const
+void XMLNode::InsertChildPreamble(XMLNode* insertThis) const
{
- TIXMLASSERT( insertThis );
- TIXMLASSERT( insertThis->_document == _document );
+ TIXMLASSERT(insertThis);
+ TIXMLASSERT(insertThis->_document == _document);
- if ( insertThis->_parent )
- insertThis->_parent->Unlink( insertThis );
+ if (insertThis->_parent)
+ insertThis->_parent->Unlink(insertThis);
else
insertThis->_memPool->SetTracked();
}
// --------- XMLText ---------- //
-char* XMLText::ParseDeep( char* p, StrPair* )
+char* XMLText::ParseDeep(char* p, StrPair*)
{
const char* start = p;
- if ( this->CData() ) {
- p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION );
- if ( !p ) {
- _document->SetError( XML_ERROR_PARSING_CDATA, start, 0 );
+ if (this->CData()) {
+ p = _value.ParseText(p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION);
+ if (!p) {
+ _document->SetError(XML_ERROR_PARSING_CDATA, start, 0);
}
return p;
}
else {
int flags = _document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;
- if ( _document->WhitespaceMode() == COLLAPSE_WHITESPACE ) {
+ if (_document->WhitespaceMode() == COLLAPSE_WHITESPACE) {
flags |= StrPair::NEEDS_WHITESPACE_COLLAPSING;
}
- p = _value.ParseText( p, "<", flags );
- if ( p && *p ) {
+ p = _value.ParseText(p, "<", flags);
+ if (p && *p) {
return p-1;
}
- if ( !p ) {
- _document->SetError( XML_ERROR_PARSING_TEXT, start, 0 );
+ if (!p) {
+ _document->SetError(XML_ERROR_PARSING_TEXT, start, 0);
}
}
return 0;
}
-XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const
+XMLNode* XMLText::ShallowClone(XMLDocument* doc) const
{
- if ( !doc ) {
+ if (!doc) {
doc = _document;
}
- XMLText* text = doc->NewText( Value() ); // fixme: this will always allocate memory. Intern?
- text->SetCData( this->CData() );
+ XMLText* text = doc->NewText(Value()); // fixme: this will always allocate memory. Intern?
+ text->SetCData(this->CData());
return text;
}
-bool XMLText::ShallowEqual( const XMLNode* compare ) const
+bool XMLText::ShallowEqual(const XMLNode* compare) const
{
const XMLText* text = compare->ToText();
- return ( text && XMLUtil::StringEqual( text->Value(), Value() ) );
+ return (text && XMLUtil::StringEqual(text->Value(), Value()));
}
-bool XMLText::Accept( XMLVisitor* visitor ) const
+bool XMLText::Accept(XMLVisitor* visitor) const
{
- TIXMLASSERT( visitor );
- return visitor->Visit( *this );
+ TIXMLASSERT(visitor);
+ return visitor->Visit(*this);
}
// --------- XMLComment ---------- //
-XMLComment::XMLComment( XMLDocument* doc ) : XMLNode( doc )
+XMLComment::XMLComment(XMLDocument* doc) : XMLNode(doc)
{
}
@@ -1101,96 +1101,96 @@ XMLComment::~XMLComment()
}
-char* XMLComment::ParseDeep( char* p, StrPair* )
+char* XMLComment::ParseDeep(char* p, StrPair*)
{
// Comment parses as text.
const char* start = p;
- p = _value.ParseText( p, "-->", StrPair::COMMENT );
- if ( p == 0 ) {
- _document->SetError( XML_ERROR_PARSING_COMMENT, start, 0 );
+ p = _value.ParseText(p, "-->", StrPair::COMMENT);
+ if (p == 0) {
+ _document->SetError(XML_ERROR_PARSING_COMMENT, start, 0);
}
return p;
}
-XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const
+XMLNode* XMLComment::ShallowClone(XMLDocument* doc) const
{
- if ( !doc ) {
+ if (!doc) {
doc = _document;
}
- XMLComment* comment = doc->NewComment( Value() ); // fixme: this will always allocate memory. Intern?
+ XMLComment* comment = doc->NewComment(Value()); // fixme: this will always allocate memory. Intern?
return comment;
}
-bool XMLComment::ShallowEqual( const XMLNode* compare ) const
+bool XMLComment::ShallowEqual(const XMLNode* compare) const
{
- TIXMLASSERT( compare );
+ TIXMLASSERT(compare);
const XMLComment* comment = compare->ToComment();
- return ( comment && XMLUtil::StringEqual( comment->Value(), Value() ));
+ return (comment && XMLUtil::StringEqual(comment->Value(), Value()));
}
-bool XMLComment::Accept( XMLVisitor* visitor ) const
+bool XMLComment::Accept(XMLVisitor* visitor) const
{
- TIXMLASSERT( visitor );
- return visitor->Visit( *this );
+ TIXMLASSERT(visitor);
+ return visitor->Visit(*this);
}
// --------- XMLDeclaration ---------- //
-XMLDeclaration::XMLDeclaration( XMLDocument* doc ) : XMLNode( doc )
+XMLDeclaration::XMLDeclaration(XMLDocument* doc) : XMLNode(doc)
{
}
XMLDeclaration::~XMLDeclaration()
{
- //printf( "~XMLDeclaration\n" );
+ //printf("~XMLDeclaration\n");
}
-char* XMLDeclaration::ParseDeep( char* p, StrPair* )
+char* XMLDeclaration::ParseDeep(char* p, StrPair*)
{
// Declaration parses as text.
const char* start = p;
- p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION );
- if ( p == 0 ) {
- _document->SetError( XML_ERROR_PARSING_DECLARATION, start, 0 );
+ p = _value.ParseText(p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION);
+ if (p == 0) {
+ _document->SetError(XML_ERROR_PARSING_DECLARATION, start, 0);
}
return p;
}
-XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const
+XMLNode* XMLDeclaration::ShallowClone(XMLDocument* doc) const
{
- if ( !doc ) {
+ if (!doc) {
doc = _document;
}
- XMLDeclaration* dec = doc->NewDeclaration( Value() ); // fixme: this will always allocate memory. Intern?
+ XMLDeclaration* dec = doc->NewDeclaration(Value()); // fixme: this will always allocate memory. Intern?
return dec;
}
-bool XMLDeclaration::ShallowEqual( const XMLNode* compare ) const
+bool XMLDeclaration::ShallowEqual(const XMLNode* compare) const
{
- TIXMLASSERT( compare );
+ TIXMLASSERT(compare);
const XMLDeclaration* declaration = compare->ToDeclaration();
- return ( declaration && XMLUtil::StringEqual( declaration->Value(), Value() ));
+ return (declaration && XMLUtil::StringEqual(declaration->Value(), Value()));
}
-bool XMLDeclaration::Accept( XMLVisitor* visitor ) const
+bool XMLDeclaration::Accept(XMLVisitor* visitor) const
{
- TIXMLASSERT( visitor );
- return visitor->Visit( *this );
+ TIXMLASSERT(visitor);
+ return visitor->Visit(*this);
}
// --------- XMLUnknown ---------- //
-XMLUnknown::XMLUnknown( XMLDocument* doc ) : XMLNode( doc )
+XMLUnknown::XMLUnknown(XMLDocument* doc) : XMLNode(doc)
{
}
@@ -1200,41 +1200,41 @@ XMLUnknown::~XMLUnknown()
}
-char* XMLUnknown::ParseDeep( char* p, StrPair* )
+char* XMLUnknown::ParseDeep(char* p, StrPair*)
{
// Unknown parses as text.
const char* start = p;
- p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION );
- if ( !p ) {
- _document->SetError( XML_ERROR_PARSING_UNKNOWN, start, 0 );
+ p = _value.ParseText(p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION);
+ if (!p) {
+ _document->SetError(XML_ERROR_PARSING_UNKNOWN, start, 0);
}
return p;
}
-XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const
+XMLNode* XMLUnknown::ShallowClone(XMLDocument* doc) const
{
- if ( !doc ) {
+ if (!doc) {
doc = _document;
}
- XMLUnknown* text = doc->NewUnknown( Value() ); // fixme: this will always allocate memory. Intern?
+ XMLUnknown* text = doc->NewUnknown(Value()); // fixme: this will always allocate memory. Intern?
return text;
}
-bool XMLUnknown::ShallowEqual( const XMLNode* compare ) const
+bool XMLUnknown::ShallowEqual(const XMLNode* compare) const
{
- TIXMLASSERT( compare );
+ TIXMLASSERT(compare);
const XMLUnknown* unknown = compare->ToUnknown();
- return ( unknown && XMLUtil::StringEqual( unknown->Value(), Value() ));
+ return (unknown && XMLUtil::StringEqual(unknown->Value(), Value()));
}
-bool XMLUnknown::Accept( XMLVisitor* visitor ) const
+bool XMLUnknown::Accept(XMLVisitor* visitor) const
{
- TIXMLASSERT( visitor );
- return visitor->Visit( *this );
+ TIXMLASSERT(visitor);
+ return visitor->Visit(*this);
}
// --------- XMLAttribute ---------- //
@@ -1249,163 +1249,163 @@ const char* XMLAttribute::Value() const
return _value.GetStr();
}
-char* XMLAttribute::ParseDeep( char* p, bool processEntities )
+char* XMLAttribute::ParseDeep(char* p, bool processEntities)
{
// Parse using the name rules: bug fix, was using ParseText before
- p = _name.ParseName( p );
- if ( !p || !*p ) {
+ p = _name.ParseName(p);
+ if (!p || !*p) {
return 0;
}
// Skip white space before =
- p = XMLUtil::SkipWhiteSpace( p );
- if ( *p != '=' ) {
+ p = XMLUtil::SkipWhiteSpace(p);
+ if (*p != '=') {
return 0;
}
++p; // move up to opening quote
- p = XMLUtil::SkipWhiteSpace( p );
- if ( *p != '\"' && *p != '\'' ) {
+ p = XMLUtil::SkipWhiteSpace(p);
+ if (*p != '\"' && *p != '\'') {
return 0;
}
char endTag[2] = { *p, 0 };
++p; // move past opening quote
- p = _value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES );
+ p = _value.ParseText(p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES);
return p;
}
-void XMLAttribute::SetName( const char* n )
+void XMLAttribute::SetName(const char* n)
{
- _name.SetStr( n );
+ _name.SetStr(n);
}
-XMLError XMLAttribute::QueryIntValue( int* value ) const
+XMLError XMLAttribute::QueryIntValue(int* value) const
{
- if ( XMLUtil::ToInt( Value(), value )) {
+ if (XMLUtil::ToInt(Value(), value)) {
return XML_NO_ERROR;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
-XMLError XMLAttribute::QueryUnsignedValue( unsigned int* value ) const
+XMLError XMLAttribute::QueryUnsignedValue(unsigned int* value) const
{
- if ( XMLUtil::ToUnsigned( Value(), value )) {
+ if (XMLUtil::ToUnsigned(Value(), value)) {
return XML_NO_ERROR;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
-XMLError XMLAttribute::QueryBoolValue( bool* value ) const
+XMLError XMLAttribute::QueryBoolValue(bool* value) const
{
- if ( XMLUtil::ToBool( Value(), value )) {
+ if (XMLUtil::ToBool(Value(), value)) {
return XML_NO_ERROR;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
-XMLError XMLAttribute::QueryFloatValue( float* value ) const
+XMLError XMLAttribute::QueryFloatValue(float* value) const
{
- if ( XMLUtil::ToFloat( Value(), value )) {
+ if (XMLUtil::ToFloat(Value(), value)) {
return XML_NO_ERROR;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
-XMLError XMLAttribute::QueryDoubleValue( double* value ) const
+XMLError XMLAttribute::QueryDoubleValue(double* value) const
{
- if ( XMLUtil::ToDouble( Value(), value )) {
+ if (XMLUtil::ToDouble(Value(), value)) {
return XML_NO_ERROR;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
-void XMLAttribute::SetAttribute( const char* v )
+void XMLAttribute::SetAttribute(const char* v)
{
- _value.SetStr( v );
+ _value.SetStr(v);
}
-void XMLAttribute::SetAttribute( int v )
+void XMLAttribute::SetAttribute(int v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- _value.SetStr( buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ _value.SetStr(buf);
}
-void XMLAttribute::SetAttribute( unsigned v )
+void XMLAttribute::SetAttribute(unsigned v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- _value.SetStr( buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ _value.SetStr(buf);
}
-void XMLAttribute::SetAttribute( bool v )
+void XMLAttribute::SetAttribute(bool v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- _value.SetStr( buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ _value.SetStr(buf);
}
-void XMLAttribute::SetAttribute( double v )
+void XMLAttribute::SetAttribute(double v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- _value.SetStr( buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ _value.SetStr(buf);
}
-void XMLAttribute::SetAttribute( float v )
+void XMLAttribute::SetAttribute(float v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- _value.SetStr( buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ _value.SetStr(buf);
}
// --------- XMLElement ---------- //
-XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ),
- _closingType( 0 ),
- _rootAttribute( 0 )
+XMLElement::XMLElement(XMLDocument* doc) : XMLNode(doc),
+ _closingType(0),
+ _rootAttribute(0)
{
}
XMLElement::~XMLElement()
{
- while( _rootAttribute ) {
+ while(_rootAttribute) {
XMLAttribute* next = _rootAttribute->_next;
- DeleteAttribute( _rootAttribute );
+ DeleteAttribute(_rootAttribute);
_rootAttribute = next;
}
}
-const XMLAttribute* XMLElement::FindAttribute( const char* name ) const
+const XMLAttribute* XMLElement::FindAttribute(const char* name) const
{
- for( XMLAttribute* a = _rootAttribute; a; a = a->_next ) {
- if ( XMLUtil::StringEqual( a->Name(), name ) ) {
+ for(XMLAttribute* a = _rootAttribute; a; a = a->_next) {
+ if (XMLUtil::StringEqual(a->Name(), name)) {
return a;
}
}
return 0;
}
-std::string XMLElement::StrAttribute( const char* name, const char* value ) const
+std::string XMLElement::StrAttribute(const char* name, const char* value) const
{
std::string str;
- const XMLAttribute* a = FindAttribute( name );
- if ( a ) {
- if ( !value || XMLUtil::StringEqual( a->Value(), value )) {
+ const XMLAttribute* a = FindAttribute(name);
+ if (a) {
+ if (!value || XMLUtil::StringEqual(a->Value(), value)) {
str = a->Value();
return str;
}
@@ -1413,13 +1413,13 @@ std::string XMLElement::StrAttribute( const char* name, const char* value ) cons
return str;
}
-const char* XMLElement::Attribute( const char* name, const char* value ) const
+const char* XMLElement::Attribute(const char* name, const char* value) const
{
- const XMLAttribute* a = FindAttribute( name );
- if ( !a ) {
+ const XMLAttribute* a = FindAttribute(name);
+ if (!a) {
return 0;
}
- if ( !value || XMLUtil::StringEqual( a->Value(), value )) {
+ if (!value || XMLUtil::StringEqual(a->Value(), value)) {
return a->Value();
}
return 0;
@@ -1427,69 +1427,69 @@ const char* XMLElement::Attribute( const char* name, const char* value ) const
const char* XMLElement::GetText() const
{
- if ( FirstChild() && FirstChild()->ToText() ) {
+ if (FirstChild() && FirstChild()->ToText()) {
return FirstChild()->Value();
}
return 0;
}
-void XMLElement::SetText( const char* inText )
+void XMLElement::SetText(const char* inText)
{
- if ( FirstChild() && FirstChild()->ToText() )
- FirstChild()->SetValue( inText );
+ if (FirstChild() && FirstChild()->ToText())
+ FirstChild()->SetValue(inText);
else {
- XMLText* theText = GetDocument()->NewText( inText );
- InsertFirstChild( theText );
+ XMLText* theText = GetDocument()->NewText(inText);
+ InsertFirstChild(theText);
}
}
-void XMLElement::SetText( int v )
+void XMLElement::SetText(int v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- SetText( buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ SetText(buf);
}
-void XMLElement::SetText( unsigned v )
+void XMLElement::SetText(unsigned v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- SetText( buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ SetText(buf);
}
-void XMLElement::SetText( bool v )
+void XMLElement::SetText(bool v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- SetText( buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ SetText(buf);
}
-void XMLElement::SetText( float v )
+void XMLElement::SetText(float v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- SetText( buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ SetText(buf);
}
-void XMLElement::SetText( double v )
+void XMLElement::SetText(double v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- SetText( buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ SetText(buf);
}
-XMLError XMLElement::QueryIntText( int* ival ) const
+XMLError XMLElement::QueryIntText(int* ival) const
{
- if ( FirstChild() && FirstChild()->ToText() ) {
+ if (FirstChild() && FirstChild()->ToText()) {
const char* t = FirstChild()->Value();
- if ( XMLUtil::ToInt( t, ival ) ) {
+ if (XMLUtil::ToInt(t, ival)) {
return XML_SUCCESS;
}
return XML_CAN_NOT_CONVERT_TEXT;
@@ -1498,11 +1498,11 @@ XMLError XMLElement::QueryIntText( int* ival ) const
}
-XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const
+XMLError XMLElement::QueryUnsignedText(unsigned* uval) const
{
- if ( FirstChild() && FirstChild()->ToText() ) {
+ if (FirstChild() && FirstChild()->ToText()) {
const char* t = FirstChild()->Value();
- if ( XMLUtil::ToUnsigned( t, uval ) ) {
+ if (XMLUtil::ToUnsigned(t, uval)) {
return XML_SUCCESS;
}
return XML_CAN_NOT_CONVERT_TEXT;
@@ -1511,11 +1511,11 @@ XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const
}
-XMLError XMLElement::QueryBoolText( bool* bval ) const
+XMLError XMLElement::QueryBoolText(bool* bval) const
{
- if ( FirstChild() && FirstChild()->ToText() ) {
+ if (FirstChild() && FirstChild()->ToText()) {
const char* t = FirstChild()->Value();
- if ( XMLUtil::ToBool( t, bval ) ) {
+ if (XMLUtil::ToBool(t, bval)) {
return XML_SUCCESS;
}
return XML_CAN_NOT_CONVERT_TEXT;
@@ -1524,11 +1524,11 @@ XMLError XMLElement::QueryBoolText( bool* bval ) const
}
-XMLError XMLElement::QueryDoubleText( double* dval ) const
+XMLError XMLElement::QueryDoubleText(double* dval) const
{
- if ( FirstChild() && FirstChild()->ToText() ) {
+ if (FirstChild() && FirstChild()->ToText()) {
const char* t = FirstChild()->Value();
- if ( XMLUtil::ToDouble( t, dval ) ) {
+ if (XMLUtil::ToDouble(t, dval)) {
return XML_SUCCESS;
}
return XML_CAN_NOT_CONVERT_TEXT;
@@ -1537,11 +1537,11 @@ XMLError XMLElement::QueryDoubleText( double* dval ) const
}
-XMLError XMLElement::QueryFloatText( float* fval ) const
+XMLError XMLElement::QueryFloatText(float* fval) const
{
- if ( FirstChild() && FirstChild()->ToText() ) {
+ if (FirstChild() && FirstChild()->ToText()) {
const char* t = FirstChild()->Value();
- if ( XMLUtil::ToFloat( t, fval ) ) {
+ if (XMLUtil::ToFloat(t, fval)) {
return XML_SUCCESS;
}
return XML_CAN_NOT_CONVERT_TEXT;
@@ -1551,46 +1551,46 @@ XMLError XMLElement::QueryFloatText( float* fval ) const
-XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
+XMLAttribute* XMLElement::FindOrCreateAttribute(const char* name)
{
XMLAttribute* last = 0;
XMLAttribute* attrib = 0;
- for( attrib = _rootAttribute;
+ for(attrib = _rootAttribute;
attrib;
- last = attrib, attrib = attrib->_next ) {
- if ( XMLUtil::StringEqual( attrib->Name(), name ) ) {
+ last = attrib, attrib = attrib->_next) {
+ if (XMLUtil::StringEqual(attrib->Name(), name)) {
break;
}
}
- if ( !attrib ) {
- TIXMLASSERT( sizeof( XMLAttribute ) == _document->_attributePool.ItemSize() );
- attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
+ if (!attrib) {
+ TIXMLASSERT(sizeof(XMLAttribute) == _document->_attributePool.ItemSize());
+ attrib = new (_document->_attributePool.Alloc()) XMLAttribute();
attrib->_memPool = &_document->_attributePool;
- if ( last ) {
+ if (last) {
last->_next = attrib;
}
else {
_rootAttribute = attrib;
}
- attrib->SetName( name );
+ attrib->SetName(name);
attrib->_memPool->SetTracked(); // always created and linked.
}
return attrib;
}
-void XMLElement::DeleteAttribute( const char* name )
+void XMLElement::DeleteAttribute(const char* name)
{
XMLAttribute* prev = 0;
- for( XMLAttribute* a=_rootAttribute; a; a=a->_next ) {
- if ( XMLUtil::StringEqual( name, a->Name() ) ) {
- if ( prev ) {
+ for(XMLAttribute* a=_rootAttribute; a; a=a->_next) {
+ if (XMLUtil::StringEqual(name, a->Name())) {
+ if (prev) {
prev->_next = a->_next;
}
else {
_rootAttribute = a->_next;
}
- DeleteAttribute( a );
+ DeleteAttribute(a);
break;
}
prev = a;
@@ -1598,30 +1598,30 @@ void XMLElement::DeleteAttribute( const char* name )
}
-char* XMLElement::ParseAttributes( char* p )
+char* XMLElement::ParseAttributes(char* p)
{
const char* start = p;
XMLAttribute* prevAttribute = 0;
// Read the attributes.
- while( p ) {
- p = XMLUtil::SkipWhiteSpace( p );
- if ( !(*p) ) {
- _document->SetError( XML_ERROR_PARSING_ELEMENT, start, Name() );
+ while(p) {
+ p = XMLUtil::SkipWhiteSpace(p);
+ if (!(*p)) {
+ _document->SetError(XML_ERROR_PARSING_ELEMENT, start, Name());
return 0;
}
// attribute.
- if (XMLUtil::IsNameStartChar( *p ) ) {
- TIXMLASSERT( sizeof( XMLAttribute ) == _document->_attributePool.ItemSize() );
- XMLAttribute* attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
+ if (XMLUtil::IsNameStartChar(*p)) {
+ TIXMLASSERT(sizeof(XMLAttribute) == _document->_attributePool.ItemSize());
+ XMLAttribute* attrib = new (_document->_attributePool.Alloc()) XMLAttribute();
attrib->_memPool = &_document->_attributePool;
attrib->_memPool->SetTracked();
- p = attrib->ParseDeep( p, _document->ProcessEntities() );
- if ( !p || Attribute( attrib->Name() ) ) {
- DeleteAttribute( attrib );
- _document->SetError( XML_ERROR_PARSING_ATTRIBUTE, start, p );
+ p = attrib->ParseDeep(p, _document->ProcessEntities());
+ if (!p || Attribute(attrib->Name())) {
+ DeleteAttribute(attrib);
+ _document->SetError(XML_ERROR_PARSING_ATTRIBUTE, start, p);
return 0;
}
// There is a minor bug here: if the attribute in the source xml
@@ -1629,7 +1629,7 @@ char* XMLElement::ParseAttributes( char* p )
// attribute will be doubly added. However, tracking the 'prevAttribute'
// avoids re-scanning the attribute list. Preferring performance for
// now, may reconsider in the future.
- if ( prevAttribute ) {
+ if (prevAttribute) {
prevAttribute->_next = attrib;
}
else {
@@ -1638,96 +1638,96 @@ char* XMLElement::ParseAttributes( char* p )
prevAttribute = attrib;
}
// end of the tag
- else if ( *p == '>' ) {
+ else if (*p == '>') {
++p;
break;
}
// end of the tag
- else if ( *p == '/' && *(p+1) == '>' ) {
+ else if (*p == '/' && *(p+1) == '>') {
_closingType = CLOSED;
return p+2; // done; sealed element.
}
else {
- _document->SetError( XML_ERROR_PARSING_ELEMENT, start, p );
+ _document->SetError(XML_ERROR_PARSING_ELEMENT, start, p);
return 0;
}
}
return p;
}
-void XMLElement::DeleteAttribute( XMLAttribute* attribute )
+void XMLElement::DeleteAttribute(XMLAttribute* attribute)
{
- if ( attribute == 0 ) {
+ if (attribute == 0) {
return;
}
MemPool* pool = attribute->_memPool;
attribute->~XMLAttribute();
- pool->Free( attribute );
+ pool->Free(attribute);
}
//
// <ele></ele>
// <ele>foo<b>bar</b></ele>
//
-char* XMLElement::ParseDeep( char* p, StrPair* strPair )
+char* XMLElement::ParseDeep(char* p, StrPair* strPair)
{
// Read the element name.
- p = XMLUtil::SkipWhiteSpace( p );
+ p = XMLUtil::SkipWhiteSpace(p);
// The closing element is the </element> form. It is
// parsed just like a regular element then deleted from
// the DOM.
- if ( *p == '/' ) {
+ if (*p == '/') {
_closingType = CLOSING;
++p;
}
- p = _value.ParseName( p );
- if ( _value.Empty() ) {
+ p = _value.ParseName(p);
+ if (_value.Empty()) {
return 0;
}
- p = ParseAttributes( p );
- if ( !p || !*p || _closingType ) {
+ p = ParseAttributes(p);
+ if (!p || !*p || _closingType) {
return p;
}
- p = XMLNode::ParseDeep( p, strPair );
+ p = XMLNode::ParseDeep(p, strPair);
return p;
}
-XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const
+XMLNode* XMLElement::ShallowClone(XMLDocument* doc) const
{
- if ( !doc ) {
+ if (!doc) {
doc = _document;
}
- XMLElement* element = doc->NewElement( Value() ); // fixme: this will always allocate memory. Intern?
- for( const XMLAttribute* a=FirstAttribute(); a; a=a->Next() ) {
- element->SetAttribute( a->Name(), a->Value() ); // fixme: this will always allocate memory. Intern?
+ XMLElement* element = doc->NewElement(Value()); // fixme: this will always allocate memory. Intern?
+ for(const XMLAttribute* a=FirstAttribute(); a; a=a->Next()) {
+ element->SetAttribute(a->Name(), a->Value()); // fixme: this will always allocate memory. Intern?
}
return element;
}
-bool XMLElement::ShallowEqual( const XMLNode* compare ) const
+bool XMLElement::ShallowEqual(const XMLNode* compare) const
{
- TIXMLASSERT( compare );
+ TIXMLASSERT(compare);
const XMLElement* other = compare->ToElement();
- if ( other && XMLUtil::StringEqual( other->Name(), Name() )) {
+ if (other && XMLUtil::StringEqual(other->Name(), Name())) {
const XMLAttribute* a=FirstAttribute();
const XMLAttribute* b=other->FirstAttribute();
- while ( a && b ) {
- if ( !XMLUtil::StringEqual( a->Value(), b->Value() ) ) {
+ while (a && b) {
+ if (!XMLUtil::StringEqual(a->Value(), b->Value())) {
return false;
}
a = a->Next();
b = b->Next();
}
- if ( a || b ) {
+ if (a || b) {
// different count
return false;
}
@@ -1737,17 +1737,17 @@ bool XMLElement::ShallowEqual( const XMLNode* compare ) const
}
-bool XMLElement::Accept( XMLVisitor* visitor ) const
+bool XMLElement::Accept(XMLVisitor* visitor) const
{
- TIXMLASSERT( visitor );
- if ( visitor->VisitEnter( *this, _rootAttribute ) ) {
- for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
- if ( !node->Accept( visitor ) ) {
+ TIXMLASSERT(visitor);
+ if (visitor->VisitEnter(*this, _rootAttribute)) {
+ for (const XMLNode* node=FirstChild(); node; node=node->NextSibling()) {
+ if (!node->Accept(visitor)) {
break;
}
}
}
- return visitor->VisitExit( *this );
+ return visitor->VisitExit(*this);
}
@@ -1778,15 +1778,15 @@ const char* XMLDocument::_errorNames[XML_ERROR_COUNT] = {
};
-XMLDocument::XMLDocument( bool processEntities, Whitespace whitespace ) :
- XMLNode( 0 ),
- _writeBOM( false ),
- _processEntities( processEntities ),
- _errorID( XML_NO_ERROR ),
- _whitespace( whitespace ),
- _errorStr1( 0 ),
- _errorStr2( 0 ),
- _charBuffer( 0 )
+XMLDocument::XMLDocument(bool processEntities, Whitespace whitespace) :
+ XMLNode(0),
+ _writeBOM(false),
+ _processEntities(processEntities),
+ _errorID(XML_NO_ERROR),
+ _whitespace(whitespace),
+ _errorStr1(0),
+ _errorStr2(0),
+ _charBuffer(0)
{
// avoid VC++ C4355 warning about 'this' in initializer list (C4355 is off by default in VS2012+)
_document = this;
@@ -1814,93 +1814,93 @@ void XMLDocument::Clear()
_charBuffer = 0;
#if 0
- _textPool.Trace( "text" );
- _elementPool.Trace( "element" );
- _commentPool.Trace( "comment" );
- _attributePool.Trace( "attribute" );
+ _textPool.Trace("text");
+ _elementPool.Trace("element");
+ _commentPool.Trace("comment");
+ _attributePool.Trace("attribute");
#endif
#ifdef DEBUG
- if ( !hadError ) {
- TIXMLASSERT( _elementPool.CurrentAllocs() == _elementPool.Untracked() );
- TIXMLASSERT( _attributePool.CurrentAllocs() == _attributePool.Untracked() );
- TIXMLASSERT( _textPool.CurrentAllocs() == _textPool.Untracked() );
- TIXMLASSERT( _commentPool.CurrentAllocs() == _commentPool.Untracked() );
+ if (!hadError) {
+ TIXMLASSERT(_elementPool.CurrentAllocs() == _elementPool.Untracked());
+ TIXMLASSERT(_attributePool.CurrentAllocs() == _attributePool.Untracked());
+ TIXMLASSERT(_textPool.CurrentAllocs() == _textPool.Untracked());
+ TIXMLASSERT(_commentPool.CurrentAllocs() == _commentPool.Untracked());
}
#endif
}
-XMLElement* XMLDocument::NewElement( const char* name )
+XMLElement* XMLDocument::NewElement(const char* name)
{
- TIXMLASSERT( sizeof( XMLElement ) == _elementPool.ItemSize() );
- XMLElement* ele = new (_elementPool.Alloc()) XMLElement( this );
+ TIXMLASSERT(sizeof(XMLElement) == _elementPool.ItemSize());
+ XMLElement* ele = new (_elementPool.Alloc()) XMLElement(this);
ele->_memPool = &_elementPool;
- ele->SetName( name );
+ ele->SetName(name);
return ele;
}
-XMLComment* XMLDocument::NewComment( const char* str )
+XMLComment* XMLDocument::NewComment(const char* str)
{
- TIXMLASSERT( sizeof( XMLComment ) == _commentPool.ItemSize() );
- XMLComment* comment = new (_commentPool.Alloc()) XMLComment( this );
+ TIXMLASSERT(sizeof(XMLComment) == _commentPool.ItemSize());
+ XMLComment* comment = new (_commentPool.Alloc()) XMLComment(this);
comment->_memPool = &_commentPool;
- comment->SetValue( str );
+ comment->SetValue(str);
return comment;
}
-XMLText* XMLDocument::NewText( const char* str )
+XMLText* XMLDocument::NewText(const char* str)
{
- TIXMLASSERT( sizeof( XMLText ) == _textPool.ItemSize() );
- XMLText* text = new (_textPool.Alloc()) XMLText( this );
+ TIXMLASSERT(sizeof(XMLText) == _textPool.ItemSize());
+ XMLText* text = new (_textPool.Alloc()) XMLText(this);
text->_memPool = &_textPool;
- text->SetValue( str );
+ text->SetValue(str);
return text;
}
-XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
+XMLDeclaration* XMLDocument::NewDeclaration(const char* str)
{
- TIXMLASSERT( sizeof( XMLDeclaration ) == _commentPool.ItemSize() );
- XMLDeclaration* dec = new (_commentPool.Alloc()) XMLDeclaration( this );
+ TIXMLASSERT(sizeof(XMLDeclaration) == _commentPool.ItemSize());
+ XMLDeclaration* dec = new (_commentPool.Alloc()) XMLDeclaration(this);
dec->_memPool = &_commentPool;
- dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" );
+ dec->SetValue(str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"");
return dec;
}
-XMLUnknown* XMLDocument::NewUnknown( const char* str )
+XMLUnknown* XMLDocument::NewUnknown(const char* str)
{
- TIXMLASSERT( sizeof( XMLUnknown ) == _commentPool.ItemSize() );
- XMLUnknown* unk = new (_commentPool.Alloc()) XMLUnknown( this );
+ TIXMLASSERT(sizeof(XMLUnknown) == _commentPool.ItemSize());
+ XMLUnknown* unk = new (_commentPool.Alloc()) XMLUnknown(this);
unk->_memPool = &_commentPool;
- unk->SetValue( str );
+ unk->SetValue(str);
return unk;
}
-static FILE* callfopen( const char* filepath, const char* mode )
+static FILE* callfopen(const char* filepath, const char* mode)
{
- TIXMLASSERT( filepath );
- TIXMLASSERT( mode );
-#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
+ TIXMLASSERT(filepath);
+ TIXMLASSERT(mode);
+#if defined(_MSC_VER) && (_MSC_VER >= 1400) && (!defined WINCE)
FILE* fp = 0;
- errno_t err = fopen_s( &fp, filepath, mode );
- if ( err ) {
+ errno_t err = fopen_s(&fp, filepath, mode);
+ if (err) {
return 0;
}
#else
- FILE* fp = fopen( filepath, mode );
+ FILE* fp = fopen(filepath, mode);
#endif
return fp;
}
-void XMLDocument::DeleteNode( XMLNode* node ) {
- TIXMLASSERT( node );
- TIXMLASSERT(node->_document == this );
+void XMLDocument::DeleteNode(XMLNode* node) {
+ TIXMLASSERT(node);
+ TIXMLASSERT(node->_document == this);
if (node->_parent) {
- node->_parent->DeleteChild( node );
+ node->_parent->DeleteChild(node);
}
else {
// Isn't in the tree.
@@ -1914,16 +1914,16 @@ void XMLDocument::DeleteNode( XMLNode* node ) {
}
-XMLError XMLDocument::LoadFile( const char* filename )
+XMLError XMLDocument::LoadFile(const char* filename)
{
Clear();
- FILE* fp = callfopen( filename, "rb" );
- if ( !fp ) {
- SetError( XML_ERROR_FILE_NOT_FOUND, filename, 0 );
+ FILE* fp = callfopen(filename, "rb");
+ if (!fp) {
+ SetError(XML_ERROR_FILE_NOT_FOUND, filename, 0);
return _errorID;
}
- LoadFile( fp );
- fclose( fp );
+ LoadFile(fp);
+ fclose(fp);
return _errorID;
}
@@ -1936,53 +1936,53 @@ XMLError XMLDocument::LoadFile( const char* filename )
template
<bool = (sizeof(unsigned long) >= sizeof(size_t))>
struct LongFitsIntoSizeTMinusOne {
- static bool Fits( unsigned long value )
+ static bool Fits(unsigned long value)
{
return value < (size_t)-1;
}
};
template <>
-bool LongFitsIntoSizeTMinusOne<false>::Fits( unsigned long /*value*/ )
+bool LongFitsIntoSizeTMinusOne<false>::Fits(unsigned long /*value*/)
{
return true;
}
-XMLError XMLDocument::LoadFile( FILE* fp )
+XMLError XMLDocument::LoadFile(FILE* fp)
{
Clear();
- fseek( fp, 0, SEEK_SET );
- if ( fgetc( fp ) == EOF && ferror( fp ) != 0 ) {
- SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
+ fseek(fp, 0, SEEK_SET);
+ if (fgetc(fp) == EOF && ferror(fp) != 0) {
+ SetError(XML_ERROR_FILE_READ_ERROR, 0, 0);
return _errorID;
}
- fseek( fp, 0, SEEK_END );
- const long filelength = ftell( fp );
- fseek( fp, 0, SEEK_SET );
- if ( filelength == -1L ) {
- SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
+ fseek(fp, 0, SEEK_END);
+ const long filelength = ftell(fp);
+ fseek(fp, 0, SEEK_SET);
+ if (filelength == -1L) {
+ SetError(XML_ERROR_FILE_READ_ERROR, 0, 0);
return _errorID;
}
- if ( !LongFitsIntoSizeTMinusOne<>::Fits( filelength ) ) {
+ if (!LongFitsIntoSizeTMinusOne<>::Fits(filelength)) {
// Cannot handle files which won't fit in buffer together with null terminator
- SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
+ SetError(XML_ERROR_FILE_READ_ERROR, 0, 0);
return _errorID;
}
- if ( filelength == 0 ) {
- SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
+ if (filelength == 0) {
+ SetError(XML_ERROR_EMPTY_DOCUMENT, 0, 0);
return _errorID;
}
const size_t size = filelength;
- TIXMLASSERT( _charBuffer == 0 );
+ TIXMLASSERT(_charBuffer == 0);
_charBuffer = new char[size+1];
- size_t read = fread( _charBuffer, 1, size, fp );
- if ( read != size ) {
- SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
+ size_t read = fread(_charBuffer, 1, size, fp);
+ if (read != size) {
+ SetError(XML_ERROR_FILE_READ_ERROR, 0, 0);
return _errorID;
}
@@ -1993,48 +1993,48 @@ XMLError XMLDocument::LoadFile( FILE* fp )
}
-XMLError XMLDocument::SaveFile( const char* filename, bool compact )
+XMLError XMLDocument::SaveFile(const char* filename, bool compact)
{
- FILE* fp = callfopen( filename, "w" );
- if ( !fp ) {
- SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, filename, 0 );
+ FILE* fp = callfopen(filename, "w");
+ if (!fp) {
+ SetError(XML_ERROR_FILE_COULD_NOT_BE_OPENED, filename, 0);
return _errorID;
}
SaveFile(fp, compact);
- fclose( fp );
+ fclose(fp);
return _errorID;
}
-XMLError XMLDocument::SaveFile( FILE* fp, bool compact )
+XMLError XMLDocument::SaveFile(FILE* fp, bool compact)
{
// Clear any error from the last save, otherwise it will get reported
// for *this* call.
- SetError( XML_NO_ERROR, 0, 0 );
- XMLPrinter stream( fp, compact );
- Print( &stream );
+ SetError(XML_NO_ERROR, 0, 0);
+ XMLPrinter stream(fp, compact);
+ Print(&stream);
return _errorID;
}
-XMLError XMLDocument::Parse( const char* p, size_t len )
+XMLError XMLDocument::Parse(const char* p, size_t len)
{
Clear();
- if ( len == 0 || !p || !*p ) {
- SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
+ if (len == 0 || !p || !*p) {
+ SetError(XML_ERROR_EMPTY_DOCUMENT, 0, 0);
return _errorID;
}
- if ( len == (size_t)(-1) ) {
- len = strlen( p );
+ if (len == (size_t)(-1)) {
+ len = strlen(p);
}
- TIXMLASSERT( _charBuffer == 0 );
+ TIXMLASSERT(_charBuffer == 0);
_charBuffer = new char[ len+1 ];
- memcpy( _charBuffer, p, len );
+ memcpy(_charBuffer, p, len);
_charBuffer[len] = 0;
Parse();
- if ( Error() ) {
+ if (Error()) {
// clean up now essentially dangling memory.
// and the parse fail can put objects in the
// pools that are dead and inaccessible.
@@ -2048,21 +2048,21 @@ XMLError XMLDocument::Parse( const char* p, size_t len )
}
-void XMLDocument::Print( XMLPrinter* streamer ) const
+void XMLDocument::Print(XMLPrinter* streamer) const
{
- if ( streamer ) {
- Accept( streamer );
+ if (streamer) {
+ Accept(streamer);
}
else {
- XMLPrinter stdoutStreamer( stdout );
- Accept( &stdoutStreamer );
+ XMLPrinter stdoutStreamer(stdout);
+ Accept(&stdoutStreamer);
}
}
-void XMLDocument::SetError( XMLError error, const char* str1, const char* str2 )
+void XMLDocument::SetError(XMLError error, const char* str1, const char* str2)
{
- TIXMLASSERT( error >= 0 && error < XML_ERROR_COUNT );
+ TIXMLASSERT(error >= 0 && error < XML_ERROR_COUNT);
_errorID = error;
_errorStr1 = str1;
_errorStr2 = str2;
@@ -2070,246 +2070,246 @@ void XMLDocument::SetError( XMLError error, const char* str1, const char* str2 )
const char* XMLDocument::ErrorName() const
{
- TIXMLASSERT( _errorID >= 0 && _errorID < XML_ERROR_COUNT );
+ TIXMLASSERT(_errorID >= 0 && _errorID < XML_ERROR_COUNT);
const char* errorName = _errorNames[_errorID];
- TIXMLASSERT( errorName && errorName[0] );
+ TIXMLASSERT(errorName && errorName[0]);
return errorName;
}
void XMLDocument::PrintError() const
{
- if ( Error() ) {
+ if (Error()) {
static const int LEN = 20;
char buf1[LEN] = { 0 };
char buf2[LEN] = { 0 };
- if ( _errorStr1 ) {
- TIXML_SNPRINTF( buf1, LEN, "%s", _errorStr1 );
+ if (_errorStr1) {
+ TIXML_SNPRINTF(buf1, LEN, "%s", _errorStr1);
}
- if ( _errorStr2 ) {
- TIXML_SNPRINTF( buf2, LEN, "%s", _errorStr2 );
+ if (_errorStr2) {
+ TIXML_SNPRINTF(buf2, LEN, "%s", _errorStr2);
}
// Should check INT_MIN <= _errorID && _errorId <= INT_MAX, but that
// causes a clang "always true" -Wtautological-constant-out-of-range-compare warning
- TIXMLASSERT( 0 <= _errorID && XML_ERROR_COUNT - 1 <= INT_MAX );
- printf( "XMLDocument error id=%d '%s' str1=%s str2=%s\n",
- static_cast<int>( _errorID ), ErrorName(), buf1, buf2 );
+ TIXMLASSERT(0 <= _errorID && XML_ERROR_COUNT - 1 <= INT_MAX);
+ printf("XMLDocument error id=%d '%s' str1=%s str2=%s\n",
+ static_cast<int>(_errorID), ErrorName(), buf1, buf2);
}
}
void XMLDocument::Parse()
{
- TIXMLASSERT( NoChildren() ); // Clear() must have been called previously
- TIXMLASSERT( _charBuffer );
+ TIXMLASSERT(NoChildren()); // Clear() must have been called previously
+ TIXMLASSERT(_charBuffer);
char* p = _charBuffer;
- p = XMLUtil::SkipWhiteSpace( p );
- p = const_cast<char*>( XMLUtil::ReadBOM( p, &_writeBOM ) );
- if ( !*p ) {
- SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
+ p = XMLUtil::SkipWhiteSpace(p);
+ p = const_cast<char*>(XMLUtil::ReadBOM(p, &_writeBOM));
+ if (!*p) {
+ SetError(XML_ERROR_EMPTY_DOCUMENT, 0, 0);
return;
}
- ParseDeep(p, 0 );
+ ParseDeep(p, 0);
}
-XMLPrinter::XMLPrinter( FILE* file, bool compact, int depth ) :
- _elementJustOpened( false ),
- _firstElement( true ),
- _fp( file ),
- _depth( depth ),
- _textDepth( -1 ),
- _processEntities( true ),
- _compactMode( compact )
+XMLPrinter::XMLPrinter(FILE* file, bool compact, int depth) :
+ _elementJustOpened(false),
+ _firstElement(true),
+ _fp(file),
+ _depth(depth),
+ _textDepth(-1),
+ _processEntities(true),
+ _compactMode(compact)
{
- for( int i=0; i<ENTITY_RANGE; ++i ) {
+ for(int i=0; i<ENTITY_RANGE; ++i) {
_entityFlag[i] = false;
_restrictedEntityFlag[i] = false;
}
- for( int i=0; i<NUM_ENTITIES; ++i ) {
+ for(int i=0; i<NUM_ENTITIES; ++i) {
const char entityValue = entities[i].value;
- TIXMLASSERT( 0 <= entityValue && entityValue < ENTITY_RANGE );
+ TIXMLASSERT(0 <= entityValue && entityValue < ENTITY_RANGE);
_entityFlag[ (unsigned char)entityValue ] = true;
}
_restrictedEntityFlag[(unsigned char)'&'] = true;
_restrictedEntityFlag[(unsigned char)'<'] = true;
_restrictedEntityFlag[(unsigned char)'>'] = true; // not required, but consistency is nice
- _buffer.Push( 0 );
+ _buffer.Push(0);
}
-void XMLPrinter::Print( const char* format, ... )
+void XMLPrinter::Print(const char* format, ...)
{
va_list va;
- va_start( va, format );
+ va_start(va, format);
- if ( _fp ) {
- vfprintf( _fp, format, va );
+ if (_fp) {
+ vfprintf(_fp, format, va);
}
else {
- const int len = TIXML_VSCPRINTF( format, va );
+ const int len = TIXML_VSCPRINTF(format, va);
// Close out and re-start the va-args
- va_end( va );
- TIXMLASSERT( len >= 0 );
- va_start( va, format );
- TIXMLASSERT( _buffer.Size() > 0 && _buffer[_buffer.Size() - 1] == 0 );
- char* p = _buffer.PushArr( len ) - 1; // back up over the null terminator.
- TIXML_VSNPRINTF( p, len+1, format, va );
+ va_end(va);
+ TIXMLASSERT(len >= 0);
+ va_start(va, format);
+ TIXMLASSERT(_buffer.Size() > 0 && _buffer[_buffer.Size() - 1] == 0);
+ char* p = _buffer.PushArr(len) - 1; // back up over the null terminator.
+ TIXML_VSNPRINTF(p, len+1, format, va);
}
- va_end( va );
+ va_end(va);
}
-void XMLPrinter::PrintSpace( int depth )
+void XMLPrinter::PrintSpace(int depth)
{
- for( int i=0; i<depth; ++i ) {
- Print( " " );
+ for(int i=0; i<depth; ++i) {
+ Print(" ");
}
}
-void XMLPrinter::PrintString( const char* p, bool restricted )
+void XMLPrinter::PrintString(const char* p, bool restricted)
{
// Look for runs of bytes between entities to print.
const char* q = p;
- if ( _processEntities ) {
+ if (_processEntities) {
const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
- while ( *q ) {
- TIXMLASSERT( p <= q );
+ while (*q) {
+ TIXMLASSERT(p <= q);
// Remember, char is sometimes signed. (How many times has that bitten me?)
- if ( *q > 0 && *q < ENTITY_RANGE ) {
+ if (*q > 0 && *q < ENTITY_RANGE) {
// Check for entities. If one is found, flush
// the stream up until the entity, write the
// entity, and keep looking.
- if ( flag[(unsigned char)(*q)] ) {
- while ( p < q ) {
+ if (flag[(unsigned char)(*q)]) {
+ while (p < q) {
const size_t delta = q - p;
// %.*s accepts type int as "precision"
- const int toPrint = ( INT_MAX < delta ) ? INT_MAX : (int)delta;
- Print( "%.*s", toPrint, p );
+ const int toPrint = (INT_MAX < delta) ? INT_MAX : (int)delta;
+ Print("%.*s", toPrint, p);
p += toPrint;
}
bool entityPatternPrinted = false;
- for( int i=0; i<NUM_ENTITIES; ++i ) {
- if ( entities[i].value == *q ) {
- Print( "&%s;", entities[i].pattern );
+ for(int i=0; i<NUM_ENTITIES; ++i) {
+ if (entities[i].value == *q) {
+ Print("&%s;", entities[i].pattern);
entityPatternPrinted = true;
break;
}
}
- if ( !entityPatternPrinted ) {
- // TIXMLASSERT( entityPatternPrinted ) causes gcc -Wunused-but-set-variable in release
- TIXMLASSERT( false );
+ if (!entityPatternPrinted) {
+ // TIXMLASSERT(entityPatternPrinted) causes gcc -Wunused-but-set-variable in release
+ TIXMLASSERT(false);
}
++p;
}
}
++q;
- TIXMLASSERT( p <= q );
+ TIXMLASSERT(p <= q);
}
}
// Flush the remaining string. This will be the entire
// string if an entity wasn't found.
- TIXMLASSERT( p <= q );
- if ( !_processEntities || ( p < q ) ) {
- Print( "%s", p );
+ TIXMLASSERT(p <= q);
+ if (!_processEntities || (p < q)) {
+ Print("%s", p);
}
}
-void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )
+void XMLPrinter::PushHeader(bool writeBOM, bool writeDec)
{
- if ( writeBOM ) {
+ if (writeBOM) {
static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };
- Print( "%s", bom );
+ Print("%s", bom);
}
- if ( writeDec ) {
- PushDeclaration( "xml version=\"1.0\"" );
+ if (writeDec) {
+ PushDeclaration("xml version=\"1.0\"");
}
}
-void XMLPrinter::OpenElement( const char* name, bool compactMode )
+void XMLPrinter::OpenElement(const char* name, bool compactMode)
{
SealElementIfJustOpened();
- _stack.Push( name );
+ _stack.Push(name);
- if ( _textDepth < 0 && !_firstElement && !compactMode ) {
- Print( "\n" );
+ if (_textDepth < 0 && !_firstElement && !compactMode) {
+ Print("\n");
}
- if ( !compactMode ) {
- PrintSpace( _depth );
+ if (!compactMode) {
+ PrintSpace(_depth);
}
- Print( "<%s", name );
+ Print("<%s", name);
_elementJustOpened = true;
_firstElement = false;
++_depth;
}
-void XMLPrinter::PushAttribute( const char* name, const char* value )
+void XMLPrinter::PushAttribute(const char* name, const char* value)
{
- TIXMLASSERT( _elementJustOpened );
- Print( " %s=\"", name );
- PrintString( value, false );
- Print( "\"" );
+ TIXMLASSERT(_elementJustOpened);
+ Print(" %s=\"", name);
+ PrintString(value, false);
+ Print("\"");
}
-void XMLPrinter::PushAttribute( const char* name, int v )
+void XMLPrinter::PushAttribute(const char* name, int v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- PushAttribute( name, buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ PushAttribute(name, buf);
}
-void XMLPrinter::PushAttribute( const char* name, unsigned v )
+void XMLPrinter::PushAttribute(const char* name, unsigned v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- PushAttribute( name, buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ PushAttribute(name, buf);
}
-void XMLPrinter::PushAttribute( const char* name, bool v )
+void XMLPrinter::PushAttribute(const char* name, bool v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- PushAttribute( name, buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ PushAttribute(name, buf);
}
-void XMLPrinter::PushAttribute( const char* name, double v )
+void XMLPrinter::PushAttribute(const char* name, double v)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( v, buf, BUF_SIZE );
- PushAttribute( name, buf );
+ XMLUtil::ToStr(v, buf, BUF_SIZE);
+ PushAttribute(name, buf);
}
-void XMLPrinter::CloseElement( bool compactMode )
+void XMLPrinter::CloseElement(bool compactMode)
{
--_depth;
const char* name = _stack.Pop();
- if ( _elementJustOpened ) {
- Print( "/>" );
+ if (_elementJustOpened) {
+ Print("/>");
}
else {
- if ( _textDepth < 0 && !compactMode) {
- Print( "\n" );
- PrintSpace( _depth );
+ if (_textDepth < 0 && !compactMode) {
+ Print("\n");
+ PrintSpace(_depth);
}
- Print( "</%s>", name );
+ Print("</%s>", name);
}
- if ( _textDepth == _depth ) {
+ if (_textDepth == _depth) {
_textDepth = -1;
}
- if ( _depth == 0 && !compactMode) {
- Print( "\n" );
+ if (_depth == 0 && !compactMode) {
+ Print("\n");
}
_elementJustOpened = false;
}
@@ -2317,159 +2317,159 @@ void XMLPrinter::CloseElement( bool compactMode )
void XMLPrinter::SealElementIfJustOpened()
{
- if ( !_elementJustOpened ) {
+ if (!_elementJustOpened) {
return;
}
_elementJustOpened = false;
- Print( ">" );
+ Print(">");
}
-void XMLPrinter::PushText( const char* text, bool cdata )
+void XMLPrinter::PushText(const char* text, bool cdata)
{
_textDepth = _depth-1;
SealElementIfJustOpened();
- if ( cdata ) {
- Print( "<![CDATA[%s]]>", text );
+ if (cdata) {
+ Print("<![CDATA[%s]]>", text);
}
else {
- PrintString( text, true );
+ PrintString(text, true);
}
}
-void XMLPrinter::PushText( int value )
+void XMLPrinter::PushText(int value)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( value, buf, BUF_SIZE );
- PushText( buf, false );
+ XMLUtil::ToStr(value, buf, BUF_SIZE);
+ PushText(buf, false);
}
-void XMLPrinter::PushText( unsigned value )
+void XMLPrinter::PushText(unsigned value)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( value, buf, BUF_SIZE );
- PushText( buf, false );
+ XMLUtil::ToStr(value, buf, BUF_SIZE);
+ PushText(buf, false);
}
-void XMLPrinter::PushText( bool value )
+void XMLPrinter::PushText(bool value)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( value, buf, BUF_SIZE );
- PushText( buf, false );
+ XMLUtil::ToStr(value, buf, BUF_SIZE);
+ PushText(buf, false);
}
-void XMLPrinter::PushText( float value )
+void XMLPrinter::PushText(float value)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( value, buf, BUF_SIZE );
- PushText( buf, false );
+ XMLUtil::ToStr(value, buf, BUF_SIZE);
+ PushText(buf, false);
}
-void XMLPrinter::PushText( double value )
+void XMLPrinter::PushText(double value)
{
char buf[BUF_SIZE];
- XMLUtil::ToStr( value, buf, BUF_SIZE );
- PushText( buf, false );
+ XMLUtil::ToStr(value, buf, BUF_SIZE);
+ PushText(buf, false);
}
-void XMLPrinter::PushComment( const char* comment )
+void XMLPrinter::PushComment(const char* comment)
{
SealElementIfJustOpened();
- if ( _textDepth < 0 && !_firstElement && !_compactMode) {
- Print( "\n" );
- PrintSpace( _depth );
+ if (_textDepth < 0 && !_firstElement && !_compactMode) {
+ Print("\n");
+ PrintSpace(_depth);
}
_firstElement = false;
- Print( "<!--%s-->", comment );
+ Print("<!--%s-->", comment);
}
-void XMLPrinter::PushDeclaration( const char* value )
+void XMLPrinter::PushDeclaration(const char* value)
{
SealElementIfJustOpened();
- if ( _textDepth < 0 && !_firstElement && !_compactMode) {
- Print( "\n" );
- PrintSpace( _depth );
+ if (_textDepth < 0 && !_firstElement && !_compactMode) {
+ Print("\n");
+ PrintSpace(_depth);
}
_firstElement = false;
- Print( "<?%s?>", value );
+ Print("<?%s?>", value);
}
-void XMLPrinter::PushUnknown( const char* value )
+void XMLPrinter::PushUnknown(const char* value)
{
SealElementIfJustOpened();
- if ( _textDepth < 0 && !_firstElement && !_compactMode) {
- Print( "\n" );
- PrintSpace( _depth );
+ if (_textDepth < 0 && !_firstElement && !_compactMode) {
+ Print("\n");
+ PrintSpace(_depth);
}
_firstElement = false;
- Print( "<!%s>", value );
+ Print("<!%s>", value);
}
-bool XMLPrinter::VisitEnter( const XMLDocument& doc )
+bool XMLPrinter::VisitEnter(const XMLDocument& doc)
{
_processEntities = doc.ProcessEntities();
- if ( doc.HasBOM() ) {
- PushHeader( true, false );
+ if (doc.HasBOM()) {
+ PushHeader(true, false);
}
return true;
}
-bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )
+bool XMLPrinter::VisitEnter(const XMLElement& element, const XMLAttribute* attribute)
{
const XMLElement* parentElem = 0;
- if ( element.Parent() ) {
+ if (element.Parent()) {
parentElem = element.Parent()->ToElement();
}
- const bool compactMode = parentElem ? CompactMode( *parentElem ) : _compactMode;
- OpenElement( element.Name(), compactMode );
- while ( attribute ) {
- PushAttribute( attribute->Name(), attribute->Value() );
+ const bool compactMode = parentElem ? CompactMode(*parentElem) : _compactMode;
+ OpenElement(element.Name(), compactMode);
+ while (attribute) {
+ PushAttribute(attribute->Name(), attribute->Value());
attribute = attribute->Next();
}
return true;
}
-bool XMLPrinter::VisitExit( const XMLElement& element )
+bool XMLPrinter::VisitExit(const XMLElement& element)
{
- CloseElement( CompactMode(element) );
+ CloseElement(CompactMode(element));
return true;
}
-bool XMLPrinter::Visit( const XMLText& text )
+bool XMLPrinter::Visit(const XMLText& text)
{
- PushText( text.Value(), text.CData() );
+ PushText(text.Value(), text.CData());
return true;
}
-bool XMLPrinter::Visit( const XMLComment& comment )
+bool XMLPrinter::Visit(const XMLComment& comment)
{
- PushComment( comment.Value() );
+ PushComment(comment.Value());
return true;
}
-bool XMLPrinter::Visit( const XMLDeclaration& declaration )
+bool XMLPrinter::Visit(const XMLDeclaration& declaration)
{
- PushDeclaration( declaration.Value() );
+ PushDeclaration(declaration.Value());
return true;
}
-bool XMLPrinter::Visit( const XMLUnknown& unknown )
+bool XMLPrinter::Visit(const XMLUnknown& unknown)
{
- PushUnknown( unknown.Value() );
+ PushUnknown(unknown.Value());
return true;
}
diff --git a/src/ui.cpp b/src/ui.cpp
index 731d18b..a78686c 100644
--- a/src/ui.cpp
+++ b/src/ui.cpp
@@ -12,6 +12,8 @@ extern SDL_Window *window;
extern Player *player;
extern World *currentWorld;
+extern World *currentWorldToLeft;
+extern World *currentWorldToRight;
extern WorldWeather weather;
/*
@@ -42,12 +44,12 @@ typedef struct {
vec2 ad;
} FT_Info;
-static std::vector<FT_Info> ftdat16 ( 93, { { 0, 0 }, { 0, 0 }, { 0, 0 } } );
-static std::vector<GLuint> ftex16 ( 93, 0 );
+static std::vector<FT_Info> ftdat16 (93, { { 0, 0 }, { 0, 0 }, { 0, 0 } });
+static std::vector<GLuint> ftex16 (93, 0);
static bool ft16loaded = false;
-static std::vector<FT_Info> ftdat24 ( 93, { { 0, 0 }, { 0, 0 }, { 0, 0 } } );
-static std::vector<GLuint> ftex24 ( 93, 0 );
+static std::vector<FT_Info> ftdat24 (93, { { 0, 0 }, { 0, 0 }, { 0, 0 } });
+static std::vector<GLuint> ftex24 (93, 0);
static bool ft24loaded = false;
static auto *ftdat = &ftdat16;
@@ -61,7 +63,7 @@ static unsigned char fontColor[4] = {255,255,255,255};
static std::vector<std::pair<std::string,vec3>> dialogOptText;
static std::string dialogBoxText;
-static std::vector<vec3> merchArrowLoc ( 2, vec3 { 0, 0, 0 } );
+static std::vector<vec3> merchArrowLoc (2, vec3 { 0, 0, 0 });
static bool typeOutDone = true;
static bool typeOutSustain = false;
@@ -86,7 +88,7 @@ Mix_Chunk *sanic;
static GLuint pageTex = 0;
static bool pageTexReady = false;
-void loadFontSize( unsigned int size, std::vector<GLuint> &tex, std::vector<FT_Info> &dat )
+void loadFontSize(unsigned int size, std::vector<GLuint> &tex, std::vector<FT_Info> &dat)
{
FT_Set_Pixel_Sizes(ftf,0,size);
@@ -94,8 +96,8 @@ void loadFontSize( unsigned int size, std::vector<GLuint> &tex, std::vector<FT_I
* Pre-render 'all' the characters.
*/
- glDeleteTextures( 93, tex.data() );
- glGenTextures( 93, tex.data() ); // Generate new texture name/locations?
+ glDeleteTextures(93, tex.data());
+ glGenTextures(93, tex.data()); // Generate new texture name/locations?
for(char i=33;i<126;i++){
@@ -103,8 +105,8 @@ void loadFontSize( unsigned int size, std::vector<GLuint> &tex, std::vector<FT_I
* Load the character from the font family file.
*/
- if ( FT_Load_Char ( ftf, i, FT_LOAD_RENDER ) )
- UserError( "Error! Unsupported character " + i );
+ if (FT_Load_Char (ftf, i, FT_LOAD_RENDER))
+ UserError("Error! Unsupported character " + i);
/*
* Transfer the character's bitmap (?) to a texture for rendering.
@@ -113,8 +115,8 @@ void loadFontSize( unsigned int size, std::vector<GLuint> &tex, std::vector<FT_I
glBindTexture(GL_TEXTURE_2D,tex[i-33]);
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S ,GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T ,GL_CLAMP_TO_EDGE);
- glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER ,GL_LINEAR );
- glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER ,GL_LINEAR );
+ glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER ,GL_LINEAR );
+ glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER ,GL_LINEAR );
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
/*
@@ -124,9 +126,9 @@ void loadFontSize( unsigned int size, std::vector<GLuint> &tex, std::vector<FT_I
*/
- std::vector<uint32_t> buf ( ftf->glyph->bitmap.width * ftf->glyph->bitmap.rows, 0xFFFFFFFF );
+ std::vector<uint32_t> buf (ftf->glyph->bitmap.width * ftf->glyph->bitmap.rows, 0xFFFFFFFF);
- for( unsigned int j = buf.size(); j--; )
+ for(unsigned int j = buf.size(); j--;)
buf[j] ^= !ftf->glyph->bitmap.buffer[j] ? buf[j] : 0;
dat[i - 33].wh.x = ftf->glyph->bitmap.width;
@@ -136,8 +138,8 @@ void loadFontSize( unsigned int size, std::vector<GLuint> &tex, std::vector<FT_I
dat[i - 33].ad.x = ftf->glyph->advance.x >> 6;
dat[i - 33].ad.y = ftf->glyph->advance.y >> 6;
- glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, ftf->glyph->bitmap.width, ftf->glyph->bitmap.rows,
- 0, GL_RGBA, GL_UNSIGNED_BYTE, buf.data() );
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ftf->glyph->bitmap.width, ftf->glyph->bitmap.rows,
+ 0, GL_RGBA, GL_UNSIGNED_BYTE, buf.data());
}
}
@@ -193,7 +195,7 @@ namespace ui {
*/
void initFonts(void){
- if ( FT_Init_FreeType(&ftl) )
+ if (FT_Init_FreeType(&ftl))
UserError("Couldn't initialize freetype.");
#ifdef DEBUG
@@ -221,7 +223,7 @@ namespace ui {
*/
void setFontFace(const char *ttf){
- if ( FT_New_Face( ftl, ttf, 0, &ftf ) )
+ if (FT_New_Face(ftl, ttf, 0, &ftf))
UserError("Error! Couldn't open " + (std::string)ttf + ".");
#ifdef DEBUG
@@ -236,17 +238,17 @@ namespace ui {
*/
void setFontSize(unsigned int size){
- if ( size == 16 ) {
- if( !ft16loaded ) {
- loadFontSize( fontSize = size, ftex16, ftdat16 );
+ if (size == 16) {
+ if(!ft16loaded) {
+ loadFontSize(fontSize = size, ftex16, ftdat16);
ft16loaded = true;
}
ftex = &ftex16;
ftdat = &ftdat16;
fontSize = 16;
- } else if ( size == 24 ) {
- if ( !ft24loaded ) {
- loadFontSize( fontSize = size, ftex24, ftdat24 );
+ } else if (size == 24) {
+ if (!ft24loaded) {
+ loadFontSize(fontSize = size, ftex24, ftdat24);
ft24loaded = true;
}
ftex = &ftex24;
@@ -316,7 +318,7 @@ namespace ui {
* Draw a string at the specified coordinates.
*/
- float putString( const float x, const float y, std::string s ) {
+ float putString(const float x, const float y, std::string s) {
unsigned int i=0;
vec2 add, o = {x, y};
@@ -341,7 +343,7 @@ namespace ui {
i++;
}
- switch ( s[i] ) {
+ switch (s[i]) {
case '\n':
o.y -= fontSize * 1.05f;
o.x = x;
@@ -357,7 +359,7 @@ namespace ui {
o.x += fontSize / 2;
break;
default:
- add = putChar( floor(o.x), floor(o.y), s[i] );
+ add = putChar(floor(o.x), floor(o.y), s[i]);
o.x += add.x;
o.y += add.y;
break;
@@ -368,12 +370,12 @@ namespace ui {
return o.x; // i.e. the string width
}
- float putStringCentered( const float x, const float y, std::string s ) {
+ float putStringCentered(const float x, const float y, std::string s) {
unsigned int i = 0;
float width = 0;
do {
- switch ( s[i] ) {
+ switch (s[i]) {
case '\n':
// TODO
break;
@@ -395,7 +397,7 @@ namespace ui {
* Prevents typeOut from typing the next string it's given.
*/
- void dontTypeOut( void ) {
+ void dontTypeOut(void) {
typeOutSustain = true;
}
@@ -405,31 +407,31 @@ namespace ui {
*/
std::string ret;
- std::string typeOut( std::string str ) {
+ std::string typeOut(std::string str) {
static unsigned int tadv = TICKS_PER_SEC / 12;
static unsigned int tickk,
linc=0, // Contains the number of letters that should be drawn.
size=0; // Contains the full size of the current string.
// reset values if a new string is being passed.
- if ( !linc || ret.substr( 0, linc ) != str.substr( 0, linc ) ) {
+ if (!linc || ret.substr(0, linc) != str.substr(0, linc)) {
tickk = tickCount + tadv;
- ret = str.substr( 0, 1 );
+ ret = str.substr(0, 1);
size = str.size(); // Set the new target string size
linc = 1; // Reset the incrementers
- if ( (typeOutDone = typeOutSustain) )
+ if ((typeOutDone = typeOutSustain))
typeOutSustain = false;
}
- if ( typeOutDone )
+ if (typeOutDone)
return str;
// Draw the next letter if necessary.
- else if ( tickk <= tickCount ) {
+ else if (tickk <= tickCount) {
tickk = tickCount + tadv;
ret += str[linc];
- if ( linc < size )
+ if (linc < size)
linc++;
else
typeOutDone = true;
@@ -442,7 +444,7 @@ namespace ui {
* Draw a formatted string to the specified coordinates.
*/
- float putText( const float x, const float y, const char *str, ... ) {
+ float putText(const float x, const float y, const char *str, ...) {
va_list args;
std::unique_ptr<char[]> buf (new char[512]);
@@ -458,10 +460,10 @@ namespace ui {
va_end(args);
// draw the string and return the width
- return putString( x, y, buf.get() );
+ return putString(x, y, buf.get());
}
- void dialogBox( const char *name, const char *opt, bool passive, const char *text, ... ) {
+ void dialogBox(const char *name, const char *opt, bool passive, const char *text, ...) {
va_list dialogArgs;
std::unique_ptr<char[]> printfbuf (new char[512]);
@@ -483,13 +485,13 @@ namespace ui {
dialogOptChosen = 0;
- if ( opt ) {
+ if (opt) {
std::string soptbuf = opt;
char *sopt = strtok(&soptbuf[0], ":");
// cycle through options
while(sopt){
- dialogOptText.push_back(std::make_pair((std::string)sopt, vec3 {0,0,0}) );
+ dialogOptText.push_back(std::make_pair((std::string)sopt, vec3 {0,0,0}));
sopt = strtok(NULL,":");
}
}
@@ -533,7 +535,7 @@ namespace ui {
// cycle through options
while(sopt){
- dialogOptText.push_back(std::make_pair((std::string)sopt, vec3 {0,0,0}) );
+ dialogOptText.push_back(std::make_pair((std::string)sopt, vec3 {0,0,0}));
sopt = strtok(NULL,":");
}
}
@@ -556,19 +558,19 @@ namespace ui {
* Wait for a dialog box to be dismissed.
*/
- void waitForDialog ( void ) {
- while ( dialogBoxExists );
+ void waitForDialog (void) {
+ while (dialogBoxExists);
}
- void waitForCover ( void ) {
- while ( fadeIntensity < 255 )
+ void waitForCover (void) {
+ while (fadeIntensity < 255)
mainLoop();
fadeIntensity = 255;
}
- void waitForNothing ( unsigned int ms ) {
+ void waitForNothing (unsigned int ms) {
unsigned int target = millis() + ms;
- while ( millis() < target );
+ while (millis() < target);
}
void importantText(const char *text,...){
@@ -608,8 +610,8 @@ namespace ui {
}
- void drawPage( std::string path ) {
- pageTex = Texture::loadTexture( path );
+ void drawPage(std::string path) {
+ pageTex = Texture::loadTexture(path);
pageTexReady = true;
}
@@ -618,16 +620,16 @@ namespace ui {
float x,y,tmp;
std::string rtext;
- if ( pageTexReady ) {
- glEnable( GL_TEXTURE_2D );
- glBindTexture( GL_TEXTURE_2D, pageTex );
- glBegin( GL_QUADS );
- glTexCoord2i( 0, 0 ); glVertex2i( offset.x - 300, SCREEN_HEIGHT - 100 );
- glTexCoord2i( 1, 0 ); glVertex2i( offset.x + 300, SCREEN_HEIGHT - 100 );
- glTexCoord2i( 1, 1 ); glVertex2i( offset.x + 300, SCREEN_HEIGHT - 600 );
- glTexCoord2i( 0, 1 ); glVertex2i( offset.x - 300, SCREEN_HEIGHT - 600 );
+ if (pageTexReady) {
+ glEnable(GL_TEXTURE_2D);
+ glBindTexture(GL_TEXTURE_2D, pageTex);
+ glBegin(GL_QUADS);
+ glTexCoord2i(0, 0); glVertex2i(offset.x - 300, SCREEN_HEIGHT - 100);
+ glTexCoord2i(1, 0); glVertex2i(offset.x + 300, SCREEN_HEIGHT - 100);
+ glTexCoord2i(1, 1); glVertex2i(offset.x + 300, SCREEN_HEIGHT - 600);
+ glTexCoord2i(0, 1); glVertex2i(offset.x - 300, SCREEN_HEIGHT - 600);
glEnd();
- glDisable( GL_TEXTURE_2D );
+ glDisable(GL_TEXTURE_2D);
} else if (dialogBoxExists) {
@@ -648,7 +650,7 @@ namespace ui {
putStringCentered(offset.x,offset.y,rtext.c_str());
setFontSize(16);
}
- }else if ( dialogMerchant ) {
+ }else if (dialogMerchant) {
x=offset.x-SCREEN_WIDTH/6;
y=(offset.y+SCREEN_HEIGHT/2)-HLINE*8;
@@ -711,8 +713,8 @@ namespace ui {
for(i = 0; i < 2; i++){
if(((merchArrowLoc[i].x < merchArrowLoc[i].z) ?
(mouse.x > merchArrowLoc[i].x && mouse.x < merchArrowLoc[i].z) :
- (mouse.x < merchArrowLoc[i].x && mouse.x > merchArrowLoc[i].z) ) &&
- mouse.y > merchArrowLoc[i].y - 8 && mouse.y < merchArrowLoc[i].y + 8 ) {
+ (mouse.x < merchArrowLoc[i].x && mouse.x > merchArrowLoc[i].z)) &&
+ mouse.y > merchArrowLoc[i].y - 8 && mouse.y < merchArrowLoc[i].y + 8) {
glColor3ub(255,255, 0);
}else{
glColor3ub(255,255,255);
@@ -739,7 +741,7 @@ namespace ui {
// make text yellow if the mouse hovers over the text
if(mouse.x > dialogOptText[i].second.x && mouse.x < dialogOptText[i].second.z &&
- mouse.y > dialogOptText[i].second.y && mouse.y < dialogOptText[i].second.y + 16 ){
+ mouse.y > dialogOptText[i].second.y && mouse.y < dialogOptText[i].second.y + 16){
setFontColor(255, 255, 0);
putStringCentered(offset.x, dialogOptText[i].second.y, dialogOptText[i].first);
}
@@ -778,7 +780,7 @@ namespace ui {
if(mouse.x > dialogOptText[i].second.x &&
mouse.x < dialogOptText[i].second.z &&
mouse.y > dialogOptText[i].second.y &&
- mouse.y < dialogOptText[i].second.y + 16 ){ // fontSize
+ mouse.y < dialogOptText[i].second.y + 16){ // fontSize
setFontColor(255,255,0);
putStringCentered(offset.x,dialogOptText[i].second.y,dialogOptText[i].first);
}
@@ -787,9 +789,9 @@ namespace ui {
}
static unsigned int rtext_oldsize = 0;
- if ( rtext_oldsize != rtext.size() ) {
- if ( !isspace( rtext[(rtext_oldsize = rtext.size()) - 1] ) )
- Mix_PlayChannel( 1, dialogClick, 0 );
+ if (rtext_oldsize != rtext.size()) {
+ if (!isspace(rtext[(rtext_oldsize = rtext.size()) - 1]))
+ Mix_PlayChannel(1, dialogClick, 0);
}
}if(!fadeIntensity){
@@ -861,8 +863,8 @@ namespace ui {
void dialogAdvance(void){
unsigned char i;
- if ( pageTex ) {
- glDeleteTextures( 1, &pageTex );
+ if (pageTex) {
+ glDeleteTextures(1, &pageTex);
pageTex = 0;
pageTexReady = false;
return;
@@ -877,14 +879,14 @@ namespace ui {
if(mouse.x > dialogOptText[i].second.x &&
mouse.x < dialogOptText[i].second.z &&
mouse.y > dialogOptText[i].second.y &&
- mouse.y < dialogOptText[i].second.y + 16 ){ // fontSize
+ mouse.y < dialogOptText[i].second.y + 16){ // fontSize
dialogOptChosen = i + 1;
goto EXIT;
}
}
- if ( dialogMerchant ) {
- for ( i = 0; i < merchArrowLoc.size(); i++ ) {
+ if (dialogMerchant) {
+ for (i = 0; i < merchArrowLoc.size(); i++) {
// TODO neaten this if statement
@@ -922,8 +924,8 @@ EXIT:
SDL_Event e;
// update mouse coords
- mouse.x = premouse.x + offset.x - ( SCREEN_WIDTH / 2 );
- mouse.y = ( offset.y + SCREEN_HEIGHT / 2 ) - premouse.y;
+ mouse.x = premouse.x + offset.x - (SCREEN_WIDTH / 2);
+ mouse.y = (offset.y + SCREEN_HEIGHT / 2) - premouse.y;
static vec2 fr;
static Entity *ig;
@@ -943,7 +945,7 @@ EXIT:
break;
case SDL_MOUSEBUTTONUP:
- if ( ig ) {
+ if (ig) {
ig->vel.x = (fr.x - mouse.x) / 50.0f;
ig->vel.y = (fr.y - mouse.y) / 50.0f;
//ig->forcedMove = true; // kills vel.x too quickly
@@ -955,22 +957,22 @@ EXIT:
case SDL_MOUSEBUTTONDOWN:
// right click advances dialog
- if ( ( e.button.button & SDL_BUTTON_RIGHT ) && (dialogBoxExists | pageTexReady) )
+ if ((e.button.button & SDL_BUTTON_RIGHT) && (dialogBoxExists | pageTexReady))
dialogAdvance();
// left click uses item
- if ( ( e.button.button & SDL_BUTTON_LEFT ) && !dialogBoxExists )
+ if ((e.button.button & SDL_BUTTON_LEFT) && !dialogBoxExists)
player->inv->usingi = true;
- if( mouse.x > player->loc.x && mouse.x < player->loc.x + player->width &&
- mouse.y > player->loc.y && mouse.y < player->loc.y + player->height ) {
+ if(mouse.x > player->loc.x && mouse.x < player->loc.x + player->width &&
+ mouse.y > player->loc.y && mouse.y < player->loc.y + player->height) {
player->vel.y = .05;
fr = mouse;
ig = player;
} else {
- for ( auto &e : currentWorld->entity ) {
- if( mouse.x > e->loc.x && mouse.x < e->loc.x + e->width &&
- mouse.y > e->loc.y && mouse.y < e->loc.y + e->height ) {
+ for (auto &e : currentWorld->entity) {
+ if(mouse.x > e->loc.x && mouse.x < e->loc.x + e->width &&
+ mouse.y > e->loc.y && mouse.y < e->loc.y + e->height) {
e->vel.y = .05;
fr = mouse;
ig = e;
@@ -997,8 +999,8 @@ EXIT:
case SDL_KEYDOWN:
// space - make player jump
- if ( SDL_KEY == SDLK_SPACE ) {
- if ( player->ground ) {
+ if (SDL_KEY == SDLK_SPACE) {
+ if (player->ground) {
player->loc.y += HLINE * 2;
player->vel.y = .4;
player->ground = false;
@@ -1006,7 +1008,7 @@ EXIT:
break;
// only let other keys be handled if dialog allows it
- } else if ( !dialogBoxExists || dialogPassive ) {
+ } else if (!dialogBoxExists || dialogPassive) {
tmp = currentWorld;
switch(SDL_KEY){
case SDLK_t:
@@ -1017,7 +1019,7 @@ EXIT:
player->vel.x = -PLAYER_SPEED_CONSTANT;
player->left = left = true;
player->right = right = false;
- if ( !currentWorld->toLeft.empty() ) {
+ if (currentWorldToLeft) {
oldpos = player->loc;
if((tmp = currentWorld->goWorldLeft(player)) != currentWorld){
tmppos = player->loc;
@@ -1037,7 +1039,7 @@ EXIT:
player->vel.x = PLAYER_SPEED_CONSTANT;
player->right = right = true;
player->left = left = false;
- if ( !currentWorld->toRight.empty() ) {
+ if (currentWorldToRight) {
oldpos = player->loc;
if((tmp = currentWorld->goWorldRight(player)) != currentWorld){
tmppos = player->loc;
@@ -1055,12 +1057,12 @@ EXIT:
case SDLK_s:
break;
case SDLK_w:
- if ( inBattle ) {
+ if (inBattle) {
tmp = currentWorld;
- currentWorld = ((Arena *)currentWorld)->exitArena( player );
- if ( tmp != currentWorld )
+ currentWorld = ((Arena *)currentWorld)->exitArena(player);
+ if (tmp != currentWorld)
toggleBlackFast();
- } else if ( (tmp = currentWorld->goInsideStructure( player )) != currentWorld )
+ } else if ((tmp = currentWorld->goInsideStructure(player)) != currentWorld)
currentWorld = tmp;
break;
case SDLK_LSHIFT:
@@ -1099,12 +1101,12 @@ EXIT:
*/
case SDL_KEYUP:
- if ( SDL_KEY == SDLK_ESCAPE ) {
+ if (SDL_KEY == SDLK_ESCAPE) {
currentMenu = &pauseMenu;
player->save();
return;
}
- switch ( SDL_KEY ) {
+ switch (SDL_KEY) {
case SDLK_F3:
debug ^= true;
break;
@@ -1112,13 +1114,13 @@ EXIT:
weather = WorldWeather::Rain;
break;
case SDLK_i:
- if ( isCurrentWorldIndoors() && Indoorp(currentWorld)->isFloorAbove( player ) ) {
+ if (isCurrentWorldIndoors() && Indoorp(currentWorld)->isFloorAbove(player)) {
player->loc.y += getIndoorWorldFloorHeight();
player->ground = false;
}
break;
case SDLK_k:
- if ( isCurrentWorldIndoors() && Indoorp(currentWorld)->isFloorBelow( player ) ) {
+ if (isCurrentWorldIndoors() && Indoorp(currentWorld)->isFloorBelow(player)) {
player->loc.y -= getIndoorWorldFloorHeight();
player->ground = false;
}
@@ -1151,20 +1153,20 @@ EXIT:
break;
case SDLK_l:
currentWorld->addLight({player->loc.x + SCREEN_WIDTH/2, player->loc.y},{1.0f,1.0f,1.0f});
- currentWorld->light.back().follow(player);
- currentWorld->light.back().makeFlame();
+ currentWorld->getLastLight()->follow(player);
+ currentWorld->getLastLight()->makeFlame();
break;
case SDLK_f:
currentWorld->addLight({player->loc.x + SCREEN_WIDTH/2, player->loc.y},{1.0f,1.0f,1.0f});
break;
case SDLK_b:
- if ( debug )
+ if (debug)
posFlag ^= true;
else {
currentWorld->addStructure(FIRE_PIT, player->loc.x, player->loc.y, "", "");
currentWorld->addLight({player->loc.x + SCREEN_WIDTH/2, player->loc.y},{1.0f,1.0f,1.0f});
- currentWorld->light.back().follow(currentWorld->build.back());
- currentWorld->light.back().makeFlame();
+ currentWorld->getLastLight()->follow(currentWorld->build.back());
+ currentWorld->getLastLight()->makeFlame();
}
break;
case SDLK_F12:
@@ -1196,11 +1198,11 @@ EXIT:
}
// Flush preloaded AI functions if necessary
- if ( !dialogBoxExists && AIpreaddr.size() ) {
- while ( !AIpreaddr.empty() ) {
- AIpreaddr.front()->addAIFunc( AIpreload.front(), false );
- AIpreaddr.erase( AIpreaddr.begin() );
- AIpreload.erase( AIpreload.begin() );
+ if (!dialogBoxExists && AIpreaddr.size()) {
+ while (!AIpreaddr.empty()) {
+ AIpreaddr.front()->addAIFunc(AIpreload.front(), false);
+ AIpreaddr.erase(AIpreaddr.begin());
+ AIpreload.erase(AIpreload.begin());
}
}
}
@@ -1225,9 +1227,9 @@ EXIT:
fadeWhite = true;
fadeFast = true;
- Mix_PlayChannel( 1, battleStart, 0 );
+ Mix_PlayChannel(1, battleStart, 0);
}
-
+
void takeScreenshot(GLubyte* pixels){
std::vector<GLubyte> bgr (SCREEN_WIDTH * SCREEN_HEIGHT * 3, 0);
diff --git a/src/ui_menu.cpp b/src/ui_menu.cpp
index 775ea81..9c7fc9d 100644
--- a/src/ui_menu.cpp
+++ b/src/ui_menu.cpp
@@ -6,9 +6,9 @@ extern Menu *currentMenu;
extern Menu pauseMenu;
void Menu::
-gotoParent( void )
+gotoParent(void)
{
- if ( !parent ) {
+ if (!parent) {
currentMenu = NULL;
config::update();
} else
@@ -16,7 +16,7 @@ gotoParent( void )
}
void Menu::
-gotoChild( void )
+gotoChild(void)
{
currentMenu = child;
}
@@ -78,7 +78,7 @@ namespace ui {
return temp;
}
- void draw( void ) {
+ void draw(void) {
SDL_Event e;
setFontSize(24);
diff --git a/src/world.cpp b/src/world.cpp
index be8e682..434f619 100644
--- a/src/world.cpp
+++ b/src/world.cpp
@@ -98,20 +98,20 @@ const float bgDraw[4][3]={
*/
void World::
-setBackground( WorldBGType bgt )
+setBackground(WorldBGType bgt)
{
// load textures with a limit check
- switch ( (bgType = bgt) ) {
+ switch ((bgType = bgt)) {
case WorldBGType::Forest:
- bgTex = new Texturec( bgFiles );
+ bgTex = new Texturec(bgFiles);
break;
case WorldBGType::WoodHouse:
- bgTex = new Texturec( bgFilesIndoors );
+ bgTex = new Texturec(bgFilesIndoors);
break;
default:
- UserError( "Invalid world background type" );
+ UserError("Invalid world background type");
break;
}
}
@@ -124,23 +124,23 @@ setBackground( WorldBGType bgt )
*/
void World::
-setStyle( std::string pre )
+setStyle(std::string pre)
{
unsigned int i;
// get folder prefix
std::string prefix = pre.empty() ? "assets/style/classic/" : pre;
- for ( i = 0; i < arrAmt(buildPaths); i++ )
- sTexLoc.push_back( prefix + buildPaths[i] );
+ for (i = 0; i < arrAmt(buildPaths); i++)
+ sTexLoc.push_back(prefix + buildPaths[i]);
prefix += "bg/";
- for ( i = 0; i < arrAmt(bgPaths[0]); i++ )
- bgFiles.push_back( prefix + bgPaths[0][i] );
+ for (i = 0; i < arrAmt(bgPaths[0]); i++)
+ bgFiles.push_back(prefix + bgPaths[0][i]);
- for ( i = 0; i < arrAmt(bgPaths[1]); i++ )
- bgFilesIndoors.push_back( prefix + bgPaths[1][i] );
+ for (i = 0; i < arrAmt(bgPaths[1]); i++)
+ bgFilesIndoors.push_back(prefix + bgPaths[1][i]);
}
/**
@@ -152,7 +152,7 @@ setStyle( std::string pre )
*/
World::
-World( void )
+World(void)
{
bgmObj = NULL;
}
@@ -165,13 +165,10 @@ World( void )
*/
void World::
-deleteEntities( void )
+deleteEntities(void)
{
// free mobs
- while ( !mob.empty() ) {
- delete mob.back();
- mob.pop_back();
- }
+ mob.clear();
merchant.clear();
while(!npc.empty()){
@@ -180,16 +177,13 @@ deleteEntities( void )
}
// free structures
- while ( !build.empty() ) {
+ while (!build.empty()) {
delete build.back();
build.pop_back();
}
// free objects
- while ( !object.empty() ) {
- delete object.back();
- object.pop_back();
- }
+ object.clear();
// clear entity array
entity.clear();
@@ -201,10 +195,7 @@ deleteEntities( void )
light.clear();
// free villages
- while ( !village.empty() ) {
- delete village.back();
- village.pop_back();
- }
+ village.clear();
}
/**
@@ -215,7 +206,7 @@ deleteEntities( void )
*/
World::
-~World( void )
+~World(void)
{
// sdl2_mixer's object
if(bgmObj)
@@ -233,7 +224,7 @@ World::
*/
void World::
-generate( unsigned int width )
+generate(unsigned int width)
{
// iterator for `for` loops
std::vector<WorldData>::iterator wditer;
@@ -242,7 +233,7 @@ generate( unsigned int width )
float geninc = 0;
// check for valid width
- if ( (int)width <= 0 )
+ if ((int)width <= 0)
UserError("Invalid world dimensions");
// allocate space for world
@@ -260,9 +251,9 @@ generate( unsigned int width )
// create slopes from the points that were just defined, populate the rest of the WorldData structure
for(wditer = worldData.begin() + 1; wditer != worldData.end(); wditer++){
- if ( (*wditer).groundHeight && wditer + GROUND_HILLINESS < worldData.end() )
+ if ((*wditer).groundHeight && wditer + GROUND_HILLINESS < worldData.end())
// wditer + GROUND_HILLINESS can go out of bounds (invalid read)
- geninc = ( (*(wditer + GROUND_HILLINESS)).groundHeight - (*wditer).groundHeight ) / (float)GROUND_HILLINESS;
+ geninc = ((*(wditer + GROUND_HILLINESS)).groundHeight - (*wditer).groundHeight) / (float)GROUND_HILLINESS;
else
(*wditer).groundHeight = (*(wditer - 1)).groundHeight + geninc;
@@ -272,12 +263,12 @@ generate( unsigned int width )
(*wditer).grassHeight[1] = (randGet() % 16) / 3 + 2;
// bound checks
- if ( (*wditer).groundHeight < GROUND_HEIGHT_MINIMUM )
+ if ((*wditer).groundHeight < GROUND_HEIGHT_MINIMUM)
(*wditer).groundHeight = GROUND_HEIGHT_MINIMUM;
- else if ( (*wditer).groundHeight > GROUND_HEIGHT_MAXIMUM )
+ else if ((*wditer).groundHeight > GROUND_HEIGHT_MAXIMUM)
(*wditer).groundHeight = GROUND_HEIGHT_MAXIMUM;
- if( (*wditer).groundHeight <= 0 )
+ if((*wditer).groundHeight <= 0)
(*wditer).groundHeight = GROUND_HEIGHT_MINIMUM;
}
@@ -286,8 +277,8 @@ generate( unsigned int width )
worldStart = (width - GROUND_HILLINESS) * HLINE / 2 * -1;
// create empty star array, should be filled here as well...
- star = std::vector<vec2> (100, vec2 { 0, 400 } );
- for ( auto &s : star ) {
+ star = std::vector<vec2> (100, vec2 { 0, 400 });
+ for (auto &s : star) {
s.x = (getRand() % (-worldStart * 2)) + worldStart;
s.y = (getRand() % SCREEN_HEIGHT) + 100.0f;
}
@@ -300,43 +291,43 @@ generate( unsigned int width )
*/
void World::
-update( Player *p, unsigned int delta )
+update(Player *p, unsigned int delta)
{
// update player coords
p->loc.y += p->vel.y * delta;
p->loc.x +=(p->vel.x * p->speed) * delta;
- if ( p->loc.y > 5000 )
+ if (p->loc.y > 5000)
UserError("Too high for me m8.");
// update entity coords
- for ( auto &e : entity ) {
+ for (auto &e : entity) {
// dont let structures move?
- if ( e->type != STRUCTURET && e->canMove ) {
+ if (e->type != STRUCTURET && e->canMove) {
e->loc.x += e->vel.x * delta;
e->loc.y += e->vel.y * delta;
// update boolean directions
- if ( e->vel.x < 0 )
+ if (e->vel.x < 0)
e->left = true;
- else if ( e->vel.x > 0 )
+ else if (e->vel.x > 0)
e->left = false;
- } else if ( e->vel.y < 0 )
+ } else if (e->vel.y < 0)
e->loc.y += e->vel.y * delta;
}
// iterate through particles
- particles.erase( std::remove_if( particles.begin(), particles.end(), [&delta](Particles &part){return part.kill(delta);}), particles.end());
- for ( auto part = particles.begin(); part != particles.end(); part++ ) {
- if ( (*part).canMove ) {
+ particles.erase(std::remove_if(particles.begin(), particles.end(), [&delta](Particles &part){return part.kill(delta);}), particles.end());
+ for (auto part = particles.begin(); part != particles.end(); part++) {
+ if ((*part).canMove) {
(*part).loc.y += (*part).vel.y * delta;
(*part).loc.x += (*part).vel.x * delta;
- for ( auto &b : build ) {
- if ( b->bsubtype == FOUNTAIN ) {
- if ( (*part).loc.x >= b->loc.x && (*part).loc.x <= b->loc.x + b->width ) {
- if ( (*part).loc.y <= b->loc.y + b->height * .25)
- particles.erase( part );
+ for (auto &b : build) {
+ if (b->bsubtype == FOUNTAIN) {
+ if ((*part).loc.x >= b->loc.x && (*part).loc.x <= b->loc.x + b->width) {
+ if ((*part).loc.y <= b->loc.y + b->height * .25)
+ particles.erase(part);
}
}
@@ -345,9 +336,9 @@ update( Player *p, unsigned int delta )
}
// handle music fades
- if ( ui::dialogImportant ) {
+ if (ui::dialogImportant) {
//Mix_FadeOutMusic(2000);
- } else if( !Mix_PlayingMusic() )
+ } else if(!Mix_PlayingMusic())
Mix_FadeInMusic(bgmObj,-1,2000);
}
@@ -359,10 +350,10 @@ update( Player *p, unsigned int delta )
*/
void World::
-setBGM( std::string path )
+setBGM(std::string path)
{
- if( !path.empty() )
- bgmObj = Mix_LoadMUS( (bgm = path).c_str() );
+ if(!path.empty())
+ bgmObj = Mix_LoadMUS((bgm = path).c_str());
}
/**
@@ -372,18 +363,18 @@ setBGM( std::string path )
*/
void World::
-bgmPlay( World *prev ) const
+bgmPlay(World *prev) const
{
- if ( prev ) {
- if ( bgm != prev->bgm ) {
+ if (prev) {
+ if (bgm != prev->bgm) {
// new world, new music
- Mix_FadeOutMusic( 800 );
- Mix_PlayMusic( bgmObj, -1 );
+ Mix_FadeOutMusic(800);
+ Mix_PlayMusic(bgmObj, -1);
}
} else {
// first call
- Mix_FadeOutMusic( 800 );
- Mix_PlayMusic( bgmObj, -1 );
+ Mix_FadeOutMusic(800);
+ Mix_PlayMusic(bgmObj, -1);
}
}
@@ -409,22 +400,22 @@ void World::draw(Player *p){
// shade value for GLSL
float shadeAmbient = -worldShade / 50.0f + 0.5f; // -0.5f to 1.5f
- if ( shadeAmbient < 0 )
+ if (shadeAmbient < 0)
shadeAmbient = 0;
- else if ( shadeAmbient > 0.9f )
+ else if (shadeAmbient > 0.9f)
shadeAmbient = 1;
/*
* Draw background images.
*/
- glEnable( GL_TEXTURE_2D );
+ glEnable(GL_TEXTURE_2D);
// the sunny wallpaper is faded with the night depending on tickCount
- bgTex->bind( 0 );
+ bgTex->bind(0);
int alpha;
- switch( weather ) {
+ switch(weather) {
case WorldWeather::Snowy:
alpha = 150;
break;
@@ -435,36 +426,36 @@ void World::draw(Player *p){
alpha = 255 - worldShade * 4;
break;
}
- safeSetColorA( 255, 255, 255, alpha );
+ safeSetColorA(255, 255, 255, alpha);
- glBegin( GL_QUADS );
- glTexCoord2i( 0, 0 ); glVertex2i( offset.x - SCREEN_WIDTH/2-5, offset.y + SCREEN_HEIGHT/2 );
- glTexCoord2i( 1, 0 ); glVertex2i( offset.x + SCREEN_WIDTH/2+5, offset.y + SCREEN_HEIGHT/2 );
- glTexCoord2i( 1, 1 ); glVertex2i( offset.x + SCREEN_WIDTH/2+5, offset.y - SCREEN_HEIGHT/2 );
- glTexCoord2i( 0, 1 ); glVertex2i( offset.x - SCREEN_WIDTH/2-5, offset.y - SCREEN_HEIGHT/2 );
+ glBegin(GL_QUADS);
+ glTexCoord2i(0, 0); glVertex2i(offset.x - SCREEN_WIDTH/2-5, offset.y + SCREEN_HEIGHT/2);
+ glTexCoord2i(1, 0); glVertex2i(offset.x + SCREEN_WIDTH/2+5, offset.y + SCREEN_HEIGHT/2);
+ glTexCoord2i(1, 1); glVertex2i(offset.x + SCREEN_WIDTH/2+5, offset.y - SCREEN_HEIGHT/2);
+ glTexCoord2i(0, 1); glVertex2i(offset.x - SCREEN_WIDTH/2-5, offset.y - SCREEN_HEIGHT/2);
glEnd();
bgTex->bindNext();
- safeSetColorA( 255, 255, 255, !alpha ? 255 : worldShade * 4);
+ safeSetColorA(255, 255, 255, !alpha ? 255 : worldShade * 4);
- glBegin( GL_QUADS );
- glTexCoord2i( 0, 0 ); glVertex2i( offset.x - SCREEN_WIDTH/2-5, offset.y + SCREEN_HEIGHT/2 );
- glTexCoord2i( 1, 0 ); glVertex2i( offset.x + SCREEN_WIDTH/2+5, offset.y + SCREEN_HEIGHT/2 );
- glTexCoord2i( 1, 1 ); glVertex2i( offset.x + SCREEN_WIDTH/2+5, offset.y - SCREEN_HEIGHT/2 );
- glTexCoord2i( 0, 1 ); glVertex2i( offset.x - SCREEN_WIDTH/2-5, offset.y - SCREEN_HEIGHT/2 );
+ glBegin(GL_QUADS);
+ glTexCoord2i(0, 0); glVertex2i(offset.x - SCREEN_WIDTH/2-5, offset.y + SCREEN_HEIGHT/2);
+ glTexCoord2i(1, 0); glVertex2i(offset.x + SCREEN_WIDTH/2+5, offset.y + SCREEN_HEIGHT/2);
+ glTexCoord2i(1, 1); glVertex2i(offset.x + SCREEN_WIDTH/2+5, offset.y - SCREEN_HEIGHT/2);
+ glTexCoord2i(0, 1); glVertex2i(offset.x - SCREEN_WIDTH/2-5, offset.y - SCREEN_HEIGHT/2);
glEnd();
- glDisable( GL_TEXTURE_2D );
+ glDisable(GL_TEXTURE_2D);
// draw the stars if the time deems it appropriate
- //if (((( weather == WorldWeather::Dark ) & ( tickCount % DAY_CYCLE )) < DAY_CYCLE / 2) ||
- // ((( weather == WorldWeather::Sunny ) & ( tickCount % DAY_CYCLE )) > DAY_CYCLE * .75) ){
- if ( worldShade > 0 ) {
+ //if ((((weather == WorldWeather::Dark) & (tickCount % DAY_CYCLE)) < DAY_CYCLE / 2) ||
+ // (((weather == WorldWeather::Sunny) & (tickCount % DAY_CYCLE)) > DAY_CYCLE * .75)){
+ if (worldShade > 0) {
- safeSetColorA( 255, 255, 255, 255 - (getRand() % 30 - 15) );
+ safeSetColorA(255, 255, 255, 255 - (getRand() % 30 - 15));
- for ( i = 0; i < 100; i++ ) {
+ for (i = 0; i < 100; i++) {
glRectf(star[i].x + offset.x * .9,
star[i].y,
star[i].x + offset.x * .9 + HLINE,
@@ -475,40 +466,40 @@ void World::draw(Player *p){
// draw remaining background items
- glEnable( GL_TEXTURE_2D );
+ glEnable(GL_TEXTURE_2D);
bgTex->bindNext();
- safeSetColorA( 150 + shadeBackground * 2, 150 + shadeBackground * 2, 150 + shadeBackground * 2, 255 );
-
- glBegin( GL_QUADS );
- for ( i = 0; i <= (int)(worldData.size() * HLINE / 1920); i++ ) {
- glTexCoord2i( 0, 1 ); glVertex2i( width / 2 * -1 + (1920 * i ) + offset.x * .85, GROUND_HEIGHT_MINIMUM );
- glTexCoord2i( 1, 1 ); glVertex2i( width / 2 * -1 + (1920 * (i + 1)) + offset.x * .85, GROUND_HEIGHT_MINIMUM );
- glTexCoord2i( 1, 0 ); glVertex2i( width / 2 * -1 + (1920 * (i + 1)) + offset.x * .85, GROUND_HEIGHT_MINIMUM + 1080 );
- glTexCoord2i( 0, 0 ); glVertex2i( width / 2 * -1 + (1920 * i ) + offset.x * .85, GROUND_HEIGHT_MINIMUM + 1080 );
+ safeSetColorA(150 + shadeBackground * 2, 150 + shadeBackground * 2, 150 + shadeBackground * 2, 255);
+
+ glBegin(GL_QUADS);
+ for (i = 0; i <= (int)(worldData.size() * HLINE / 1920); i++) {
+ glTexCoord2i(0, 1); glVertex2i(width / 2 * -1 + (1920 * i) + offset.x * .85, GROUND_HEIGHT_MINIMUM);
+ glTexCoord2i(1, 1); glVertex2i(width / 2 * -1 + (1920 * (i + 1)) + offset.x * .85, GROUND_HEIGHT_MINIMUM);
+ glTexCoord2i(1, 0); glVertex2i(width / 2 * -1 + (1920 * (i + 1)) + offset.x * .85, GROUND_HEIGHT_MINIMUM + 1080);
+ glTexCoord2i(0, 0); glVertex2i(width / 2 * -1 + (1920 * i) + offset.x * .85, GROUND_HEIGHT_MINIMUM + 1080);
}
glEnd();
- for ( i = 0; i < 4; i++ ) {
+ for (i = 0; i < 4; i++) {
bgTex->bindNext();
- safeSetColorA( bgDraw[i][0] + shadeBackground * 2, bgDraw[i][0] + shadeBackground * 2, bgDraw[i][0] + shadeBackground * 2, bgDraw[i][1] );
-
- glBegin( GL_QUADS );
- for( int j = worldStart; j <= -worldStart; j += 600 ){
- glTexCoord2i( 0, 1 ); glVertex2i( j + offset.x * bgDraw[i][2], GROUND_HEIGHT_MINIMUM );
- glTexCoord2i( 1, 1 ); glVertex2i( (j + 600) + offset.x * bgDraw[i][2], GROUND_HEIGHT_MINIMUM );
- glTexCoord2i( 1, 0 ); glVertex2i( (j + 600) + offset.x * bgDraw[i][2], GROUND_HEIGHT_MINIMUM + 400 );
- glTexCoord2i( 0, 0 ); glVertex2i( j + offset.x * bgDraw[i][2], GROUND_HEIGHT_MINIMUM + 400 );
+ safeSetColorA(bgDraw[i][0] + shadeBackground * 2, bgDraw[i][0] + shadeBackground * 2, bgDraw[i][0] + shadeBackground * 2, bgDraw[i][1]);
+
+ glBegin(GL_QUADS);
+ for(int j = worldStart; j <= -worldStart; j += 600){
+ glTexCoord2i(0, 1); glVertex2i(j + offset.x * bgDraw[i][2], GROUND_HEIGHT_MINIMUM);
+ glTexCoord2i(1, 1); glVertex2i((j + 600) + offset.x * bgDraw[i][2], GROUND_HEIGHT_MINIMUM);
+ glTexCoord2i(1, 0); glVertex2i((j + 600) + offset.x * bgDraw[i][2], GROUND_HEIGHT_MINIMUM + 400);
+ glTexCoord2i(0, 0); glVertex2i(j + offset.x * bgDraw[i][2], GROUND_HEIGHT_MINIMUM + 400);
}
glEnd();
}
- glDisable( GL_TEXTURE_2D );
+ glDisable(GL_TEXTURE_2D);
// draw black under backgrounds
- glColor3ub( 0, 0, 0 );
- glRectf( worldStart, GROUND_HEIGHT_MINIMUM, -worldStart, 0 );
+ glColor3ub(0, 0, 0);
+ glRectf(worldStart, GROUND_HEIGHT_MINIMUM, -worldStart, 0);
pOffset = (offset.x + p->width / 2 - worldStart) / HLINE;
@@ -534,14 +525,14 @@ void World::draw(Player *p){
glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);
glUseProgram(shaderProgram);
- std::for_each( particles.begin(), particles.end(), [](Particles part) { if ( part.behind ) part.draw(); });
+ std::for_each(particles.begin(), particles.end(), [](Particles part) { if (part.behind) part.draw(); });
glUseProgram(0);
- for ( auto &b : build ) {
- if ( b->bsubtype == STALL_MARKET ) {
- for ( auto &n : npc ) {
- if ( n->type == MERCHT && ((Merchant *)n)->inside == b ) {
+ for (auto &b : build) {
+ if (b->bsubtype == STALL_MARKET) {
+ for (auto &n : npc) {
+ if (n->type == MERCHT && ((Merchant *)n)->inside == b) {
n->draw();
break;
}
@@ -552,9 +543,9 @@ void World::draw(Player *p){
// draw light elements?
- glEnable( GL_TEXTURE_2D );
+ glEnable(GL_TEXTURE_2D);
- glActiveTexture( GL_TEXTURE0 );
+ glActiveTexture(GL_TEXTURE0);
bgTex->bindNext();
for(auto &l : light){
@@ -585,22 +576,22 @@ void World::draw(Player *p){
}
}
- for ( uint i = 0; i < light.size(); i++ )
+ for (uint i = 0; i < light.size(); i++)
flameArray[i] = light[i].fireFlicker;
- glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
- glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
- glUseProgram( shaderProgram );
- glUniform1i( glGetUniformLocation( shaderProgram, "sampler"), 0 );
- glUniform1f( glGetUniformLocation( shaderProgram, "amb" ), shadeAmbient );
+ glUseProgram(shaderProgram);
+ glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);
+ glUniform1f(glGetUniformLocation(shaderProgram, "amb"), shadeAmbient);
- if ( light.size() == 0)
- glUniform1i( glGetUniformLocation( shaderProgram, "numLight"), 0);
+ if (light.size() == 0)
+ glUniform1i(glGetUniformLocation(shaderProgram, "numLight"), 0);
else {
- glUniform1i ( glGetUniformLocation( shaderProgram, "numLight" ), light.size());
- glUniform2fv( glGetUniformLocation( shaderProgram, "lightLocation"), light.size(), pointArray );
- glUniform3f ( glGetUniformLocation( shaderProgram, "lightColor" ), 1.0f, 1.0f, 1.0f );
+ glUniform1i (glGetUniformLocation(shaderProgram, "numLight"), light.size());
+ glUniform2fv(glGetUniformLocation(shaderProgram, "lightLocation"), light.size(), pointArray);
+ glUniform3f (glGetUniformLocation(shaderProgram, "lightColor"), 1.0f, 1.0f, 1.0f);
glUniform1fv(glGetUniformLocation(shaderProgram,"fireFlicker"), light.size(),flameArray);
}
@@ -608,7 +599,7 @@ void World::draw(Player *p){
* Draw the dirt.
*/
- glBegin( GL_QUADS );
+ glBegin(GL_QUADS);
// faulty
/*glTexCoord2i(0 ,0);glVertex2i(pOffset - (SCREEN_WIDTH / 1.5),0);
@@ -616,20 +607,20 @@ void World::draw(Player *p){
glTexCoord2i(64,1);glVertex2i(pOffset + (SCREEN_WIDTH / 1.5),GROUND_HEIGHT_MINIMUM);
glTexCoord2i(0 ,1);glVertex2i(pOffset - (SCREEN_WIDTH / 1.5),GROUND_HEIGHT_MINIMUM);*/
- for ( i = iStart; i < iEnd; i++ ) {
- if ( worldData[i].groundHeight <= 0 ) {
+ for (i = iStart; i < iEnd; i++) {
+ if (worldData[i].groundHeight <= 0) {
worldData[i].groundHeight = GROUND_HEIGHT_MINIMUM - 1;
- glColor4ub( 0, 0, 0, 255 );
+ glColor4ub(0, 0, 0, 255);
} else
- safeSetColorA( 150, 150, 150, 255 );
+ safeSetColorA(150, 150, 150, 255);
- glTexCoord2i( 0, 0 ); glVertex2i(worldStart + i * HLINE , worldData[i].groundHeight - GRASS_HEIGHT );
- glTexCoord2i( 1, 0 ); glVertex2i(worldStart + i * HLINE + HLINE , worldData[i].groundHeight - GRASS_HEIGHT );
+ glTexCoord2i(0, 0); glVertex2i(worldStart + i * HLINE , worldData[i].groundHeight - GRASS_HEIGHT);
+ glTexCoord2i(1, 0); glVertex2i(worldStart + i * HLINE + HLINE , worldData[i].groundHeight - GRASS_HEIGHT);
- glTexCoord2i( 1, (int)(worldData[i].groundHeight / 64) + worldData[i].groundColor ); glVertex2i(worldStart + i * HLINE + HLINE, 0 );
- glTexCoord2i( 0, (int)(worldData[i].groundHeight / 64) + worldData[i].groundColor ); glVertex2i(worldStart + i * HLINE , 0 );
+ glTexCoord2i(1, (int)(worldData[i].groundHeight / 64) + worldData[i].groundColor); glVertex2i(worldStart + i * HLINE + HLINE, 0);
+ glTexCoord2i(0, (int)(worldData[i].groundHeight / 64) + worldData[i].groundColor); glVertex2i(worldStart + i * HLINE , 0);
- if ( worldData[i].groundHeight == GROUND_HEIGHT_MINIMUM - 1 )
+ if (worldData[i].groundHeight == GROUND_HEIGHT_MINIMUM - 1)
worldData[i].groundHeight = 0;
}
@@ -642,42 +633,42 @@ void World::draw(Player *p){
* Draw the grass/the top of the ground.
*/
- glEnable( GL_TEXTURE_2D );
+ glEnable(GL_TEXTURE_2D);
- glActiveTexture( GL_TEXTURE0 );
+ glActiveTexture(GL_TEXTURE0);
bgTex->bindNext();
- glUseProgram( shaderProgram );
- glUniform1i( glGetUniformLocation( shaderProgram, "sampler"), 0);
+ glUseProgram(shaderProgram);
+ glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);
float cgh[2];
- for ( i = iStart; i < iEnd - GROUND_HILLINESS; i++ ) {
+ for (i = iStart; i < iEnd - GROUND_HILLINESS; i++) {
// load the current line's grass values
- if ( worldData[i].groundHeight )
- memcpy( cgh, worldData[i].grassHeight, 2 * sizeof( float ));
+ if (worldData[i].groundHeight)
+ memcpy(cgh, worldData[i].grassHeight, 2 * sizeof(float));
else
- memset( cgh, 0 , 2 * sizeof( float ));
+ memset(cgh, 0 , 2 * sizeof(float));
// flatten the grass if the player is standing on it.
- if( !worldData[i].grassUnpressed ){
+ if(!worldData[i].grassUnpressed){
cgh[0] /= 4;
cgh[1] /= 4;
}
// actually draw the grass.
- safeSetColorA( 255, 255, 255, 255 );
-
- glBegin( GL_QUADS );
- glTexCoord2i( 0, 0 ); glVertex2i( worldStart + i * HLINE , worldData[i].groundHeight + cgh[0] );
- glTexCoord2i( 1, 0 ); glVertex2i( worldStart + i * HLINE + HLINE / 2, worldData[i].groundHeight + cgh[0] );
- glTexCoord2i( 1, 1 ); glVertex2i( worldStart + i * HLINE + HLINE / 2, worldData[i].groundHeight - GRASS_HEIGHT );
- glTexCoord2i( 0, 1 ); glVertex2i( worldStart + i * HLINE , worldData[i].groundHeight - GRASS_HEIGHT );
- glTexCoord2i( 0, 0 ); glVertex2i( worldStart + i * HLINE + HLINE / 2, worldData[i].groundHeight + cgh[1] );
- glTexCoord2i( 1, 0 ); glVertex2i( worldStart + i * HLINE + HLINE , worldData[i].groundHeight + cgh[1] );
- glTexCoord2i( 1, 1 ); glVertex2i( worldStart + i * HLINE + HLINE , worldData[i].groundHeight - GRASS_HEIGHT );
- glTexCoord2i( 0, 1 ); glVertex2i( worldStart + i * HLINE + HLINE / 2, worldData[i].groundHeight - GRASS_HEIGHT );
+ safeSetColorA(255, 255, 255, 255);
+
+ glBegin(GL_QUADS);
+ glTexCoord2i(0, 0); glVertex2i(worldStart + i * HLINE , worldData[i].groundHeight + cgh[0]);
+ glTexCoord2i(1, 0); glVertex2i(worldStart + i * HLINE + HLINE / 2, worldData[i].groundHeight + cgh[0]);
+ glTexCoord2i(1, 1); glVertex2i(worldStart + i * HLINE + HLINE / 2, worldData[i].groundHeight - GRASS_HEIGHT);
+ glTexCoord2i(0, 1); glVertex2i(worldStart + i * HLINE , worldData[i].groundHeight - GRASS_HEIGHT);
+ glTexCoord2i(0, 0); glVertex2i(worldStart + i * HLINE + HLINE / 2, worldData[i].groundHeight + cgh[1]);
+ glTexCoord2i(1, 0); glVertex2i(worldStart + i * HLINE + HLINE , worldData[i].groundHeight + cgh[1]);
+ glTexCoord2i(1, 1); glVertex2i(worldStart + i * HLINE + HLINE , worldData[i].groundHeight - GRASS_HEIGHT);
+ glTexCoord2i(0, 1); glVertex2i(worldStart + i * HLINE + HLINE / 2, worldData[i].groundHeight - GRASS_HEIGHT);
glEnd();
}
@@ -695,34 +686,34 @@ void World::draw(Player *p){
glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);
glUseProgram(shaderProgram);
- std::for_each( particles.begin(), particles.end(), [](Particles part) { if ( !part.behind ) part.draw(); });
+ std::for_each(particles.begin(), particles.end(), [](Particles part) { if (!part.behind) part.draw(); });
glUseProgram(0);
- for ( auto &n : npc ) {
- if ( n->type != MERCHT )
+ for (auto &n : npc) {
+ if (n->type != MERCHT)
n->draw();
}
- for ( auto &m : mob )
- m->draw();
+ for (auto &m : mob)
+ m.draw();
- for ( auto &o : object )
- o->draw();
+ for (auto &o : object)
+ o.draw();
/*
* Handle grass-squishing.
*/
// calculate the line that the player is on
- int ph = ( p->loc.x + p->width / 2 - worldStart ) / HLINE;
+ int ph = (p->loc.x + p->width / 2 - worldStart) / HLINE;
// flatten grass under the player if the player is on the ground
- if ( p->ground ) {
- for ( i = 0; i < (int)(worldData.size() - GROUND_HILLINESS); i++ )
- worldData[i].grassUnpressed = !( i < ph + 6 && i > ph - 6 );
+ if (p->ground) {
+ for (i = 0; i < (int)(worldData.size() - GROUND_HILLINESS); i++)
+ worldData[i].grassUnpressed = !(i < ph + 6 && i > ph - 6);
} else {
- for ( i = 0; i < (int)(worldData.size() - GROUND_HILLINESS); i++ )
+ for (i = 0; i < (int)(worldData.size() - GROUND_HILLINESS); i++)
worldData[i].grassUnpressed = true;
}
@@ -741,7 +732,7 @@ void World::draw(Player *p){
*/
void World::
-singleDetect( Entity *e )
+singleDetect(Entity *e)
{
std::string killed;
unsigned int i,j;
@@ -751,12 +742,12 @@ singleDetect( Entity *e )
* Kill any dead entities.
*/
- if ( e->alive && e->health <= 0 ) {
+ if (e->alive && e->health <= 0) {
e->alive = false;
e->health = 0;
- for ( i = 0; i < entity.size(); i++) {
- if ( entity[i] == e ){
- switch ( e->type ) {
+ for (i = 0; i < entity.size(); i++) {
+ if (entity[i] == e){
+ switch (e->type) {
case STRUCTURET:
killed = "structure";
for(j=0;j<build.size();j++){
@@ -789,13 +780,12 @@ singleDetect( Entity *e )
break;
case OBJECTT:
killed = "object";
- for(j=0;j<object.size();j++){
- if(object[j]==e){
- delete object[j];
- object.erase(object.begin()+j);
- break;
- }
- }
+ for (auto o = std::begin(object); o != std::end(object); o++) {
+ if (&(*o) == e) {
+ object.erase(o);
+ break;
+ }
+ }
break;
default:
break;
@@ -806,36 +796,36 @@ singleDetect( Entity *e )
}
}
std::cout << "RIP " << e->name << "." << std::endl;
- exit( 0 );
+ exit(0);
}
// handle only living entities
- if ( e->alive ) {
+ if (e->alive) {
// forced movement gravity
- if ( e->forcedMove ) {
- if ( e->vel.x > .0005 || e->vel.x < -.0005 )
+ if (e->forcedMove) {
+ if (e->vel.x > .0005 || e->vel.x < -.0005)
e->vel.x *= .6;
else
e->forcedMove = false;
}
- if ( e->type == MOBT && Mobp(e)->subtype == MS_TRIGGER )
+ if (e->type == MOBT && Mobp(e)->subtype == MS_TRIGGER)
return;
// calculate the line that this entity is currently standing on
l = (e->loc.x + e->width / 2 - worldStart) / HLINE;
- if ( l < 0 )
+ if (l < 0)
l = 0;
i = l;
- if ( i > lineCount - 1 )
+ if (i > lineCount - 1)
i = lineCount - 1;
// if the entity is under the world/line, pop it back to the surface
- if ( e->loc.y < worldData[i].groundHeight ) {
+ if (e->loc.y < worldData[i].groundHeight) {
int dir = e->vel.x < 0 ? -1 : 1;
- if ( i + (dir * 2) < worldData.size() && worldData[i + (dir * 2)].groundHeight - 30 > worldData[i + dir].groundHeight ) {
- e->loc.x -= ( PLAYER_SPEED_CONSTANT + 2.7 ) * e->speed * 2 * dir;
+ if (i + (dir * 2) < worldData.size() && worldData[i + (dir * 2)].groundHeight - 30 > worldData[i + dir].groundHeight) {
+ e->loc.x -= (PLAYER_SPEED_CONSTANT + 2.7) * e->speed * 2 * dir;
e->vel.x = 0;
} else {
e->loc.y = worldData[i].groundHeight - .001 * deltaTime;
@@ -848,12 +838,12 @@ singleDetect( Entity *e )
// handle gravity if the entity is above the line
else {
- if ( e->type == STRUCTURET ) {
+ if (e->type == STRUCTURET) {
e->loc.y = worldData[i].groundHeight;
e->vel.y = 0;
e->ground = true;
return;
- } else if ( e->vel.y > -2 )
+ } else if (e->vel.y > -2)
e->vel.y -= GRAVITY_CONSTANT * deltaTime;
}
@@ -880,37 +870,37 @@ singleDetect( Entity *e )
*/
void World::
-detect( Player *p )
+detect(Player *p)
{
int l;
// handle the player
- std::thread( &World::singleDetect, this, p ).detach();
+ std::thread(&World::singleDetect, this, p).detach();
// handle other entities
- for ( auto &e : entity )
- std::thread( &World::singleDetect, this, e ).detach();
+ for (auto &e : entity)
+ std::thread(&World::singleDetect, this, e).detach();
// handle particles
- for ( auto &part : particles ) {
+ for (auto &part : particles) {
// get particle's current world line
l = (part.loc.x + part.width / 2 - worldStart) / HLINE;
- if ( l < 0 )
+ if (l < 0)
l = 0;
- if ( l > (int)(lineCount - 1) )
+ if (l > (int)(lineCount - 1))
l = lineCount - 1;
- part.update( GRAVITY_CONSTANT, worldData[l].groundHeight );
+ part.update(GRAVITY_CONSTANT, worldData[l].groundHeight);
}
// handle particle creation
- for ( auto &b : build ) {
- switch ( b->bsubtype ) {
+ for (auto &b : build) {
+ switch (b->bsubtype) {
case FOUNTAIN:
- for ( unsigned int r = (randGet() % 25) + 11; r--; ) {
+ for (unsigned int r = (randGet() % 25) + 11; r--;) {
addParticle(randGet() % HLINE * 3 + b->loc.x + b->width / 2, // x
b->loc.y + b->height, // y
HLINE * 1.25, // width
@@ -926,7 +916,7 @@ detect( Player *p )
break;
case FIRE_PIT:
- for(unsigned int r = (randGet() % 20) + 11; r--; ) {
+ for(unsigned int r = (randGet() % 20) + 11; r--;) {
addParticle(randGet() % (int)(b->width / 2) + b->loc.x + b->width / 4, // x
b->loc.y + 3 * HLINE, // y
HLINE, // width
@@ -948,14 +938,14 @@ detect( Player *p )
}
// draws the village welcome message if the player enters the village bounds
- for ( auto &v : village ) {
- if ( p->loc.x > v->start.x && p->loc.x < v->end.x ) {
- if ( !v->in ) {
- ui::passiveImportantText( 5000, "Welcome to %s", v->name.c_str() );
- v->in = true;
+ for (auto &v : village) {
+ if (p->loc.x > v.start.x && p->loc.x < v.end.x) {
+ if (!v.in) {
+ ui::passiveImportantText(5000, "Welcome to %s", v.name.c_str());
+ v.in = true;
}
} else
- v->in = false;
+ v.in = false;
}
}
@@ -971,19 +961,26 @@ void World::addStructure(BUILD_SUB sub, float x,float y, std::string tex, std::s
entity.push_back(build.back());
}
+Village *World::
+addVillage(std::string name, World *world)
+{
+ village.emplace_back(name.c_str(), world);
+ return &village.back();
+}
+
void World::addMob(int t,float x,float y){
- mob.push_back(new Mob(t));
- mob.back()->spawn(x,y);
+ mob.emplace_back(t);
+ mob.back().spawn(x,y);
- entity.push_back(mob.back());
+ entity.push_back(&mob.back());
}
void World::addMob(int t,float x,float y,void (*hey)(Mob *)){
- mob.push_back(new Mob(t));
- mob.back()->spawn(x,y);
- mob.back()->hey = hey;
+ mob.emplace_back(t);
+ mob.back().spawn(x,y);
+ mob.back().hey = hey;
- entity.push_back(mob.back());
+ entity.push_back(&mob.back());
}
void World::addNPC(float x,float y){
@@ -1001,57 +998,91 @@ void World::addMerchant(float x, float y){
entity.push_back(npc.back());
}
-void World::addObject( std::string in, std::string p, float x, float y){
- object.push_back(new Object(in,p));
- object.back()->spawn(x,y);
+void World::addObject(std::string in, std::string p, float x, float y){
+ object.emplace_back(in, p);
+ object.back().spawn(x, y);
- entity.push_back(object.back());
+ entity.push_back(&object.back());
}
void World::
-addParticle( float x, float y, float w, float h, float vx, float vy, Color color, int d )
+addParticle(float x, float y, float w, float h, float vx, float vy, Color color, int d)
{
- particles.emplace_back( x, y, w, h, vx, vy, color, d );
+ particles.emplace_back(x, y, w, h, vx, vy, color, d);
particles.back().canMove = true;
}
void World::
-addParticle( float x, float y, float w, float h, float vx, float vy, Color color, int d, bool gravity )
+addParticle(float x, float y, float w, float h, float vx, float vy, Color color, int d, unsigned char flags)
{
- particles.emplace_back( x, y, w, h, vx, vy, color, d );
+ particles.emplace_back(x, y, w, h, vx, vy, color, d);
particles.back().canMove = true;
- particles.back().gravity = gravity;
+ particles.back().gravity = flags & (1 << 0);
+ particles.back().bounce = flags & (1 << 1);
}
void World::
-addLight( vec2 loc, Color color )
+addLight(vec2 loc, Color color)
+{
+ if (light.size() < 64)
+ light.push_back(Light(loc, color, 1));
+}
+
+Light *World::
+getLastLight(void)
+{
+ return &light.back();
+}
+
+Mob *World::
+getLastMob(void)
+{
+ return &mob.back();
+}
+
+std::string World::
+getSTextureLocation(unsigned int index) const
{
- if ( light.size() < 64 )
- light.push_back( Light( loc, color, 1 ) );
+ if (index > sTexLoc.size())
+ return "";
+
+ return sTexLoc[ index ];
}
std::string World::
-setToLeft( std::string file )
+setToLeft(std::string file)
{
return (toLeft = file);
}
std::string World::
-setToRight( std::string file )
+setToRight(std::string file)
{
return (toRight = file);
}
+std::string World::
+getToLeft(void) const
+{
+ return toLeft;
+}
+
+std::string World::
+getToRight(void) const
+{
+ return toRight;
+}
+
World *World::
-goWorldLeft( Player *p )
+goWorldLeft(Player *p)
{
World *tmp;
// check if player is at world edge
- if( !toLeft.empty() && p->loc.x < worldStart + HLINE * 15.0f ) {
+ if(!toLeft.empty() && p->loc.x < worldStart + HLINE * 15.0f) {
// load world (`toLeft` conditional confirms existance)
- tmp = loadWorldFromPtr( currentWorldToLeft );
+ tmp = loadWorldFromPtr(currentWorldToLeft);
// adjust player location
p->loc.x = tmp->worldStart + HLINE * 20;
@@ -1064,10 +1095,10 @@ goWorldLeft( Player *p )
}
bool World::
-goWorldLeft( NPC *e )
+goWorldLeft(NPC *e)
{
// check if entity is at world edge
- if( !toLeft.empty() && e->loc.x < worldStart + HLINE * 15.0f ) {
+ if(!toLeft.empty() && e->loc.x < worldStart + HLINE * 15.0f) {
currentWorldToLeft->addNPC(e->loc.x,e->loc.y);
e->alive = false;
@@ -1082,12 +1113,12 @@ goWorldLeft( NPC *e )
}
World *World::
-goWorldRight( Player *p )
+goWorldRight(Player *p)
{
World *tmp;
- if( !toRight.empty() && p->loc.x + p->width > -worldStart - HLINE * 15 ) {
- tmp = loadWorldFromPtr( currentWorldToRight );
+ if(!toRight.empty() && p->loc.x + p->width > -worldStart - HLINE * 15) {
+ tmp = loadWorldFromPtr(currentWorldToRight);
p->loc.x = tmp->worldStart - HLINE * -15.0f;
p->loc.y = GROUND_HEIGHT_MINIMUM;
@@ -1099,22 +1130,22 @@ goWorldRight( Player *p )
}
World *World::
-goInsideStructure( Player *p )
+goInsideStructure(Player *p)
{
World *tmp;
std::string current;
- if ( inside.empty() ) {
- for ( auto &b : build ) {
- if ( p->loc.x > b->loc.x &&
- p->loc.x + p->width < b->loc.x + b->width ) {
+ if (inside.empty()) {
+ for (auto &b : build) {
+ if (p->loc.x > b->loc.x &&
+ p->loc.x + p->width < b->loc.x + b->width) {
- if ( b->inside.empty() )
+ if (b->inside.empty())
return this;
inside.push_back(currentXML.c_str() + xmlFolder.size());
- tmp = loadWorldFromXML( b->inside );
+ tmp = loadWorldFromXML(b->inside);
ui::toggleBlackFast();
ui::waitForCover();
@@ -1127,9 +1158,9 @@ goInsideStructure( Player *p )
}
} else {
current = currentXML.c_str() + xmlFolder.size();
- tmp = loadWorldFromXML( inside.back() );
- for ( auto &b : tmp->build ) {
- if ( current == b->inside ) {
+ tmp = loadWorldFromXML(inside.back());
+ for (auto &b : tmp->build) {
+ if (current == b->inside) {
inside.pop_back();
ui::toggleBlackFast();
@@ -1150,39 +1181,39 @@ goInsideStructure( Player *p )
}
void World::
-addHole( unsigned int start, unsigned int end )
+addHole(unsigned int start, unsigned int end)
{
- if ( end > worldData.size() )
+ if (end > worldData.size())
end = worldData.size();
-
- for ( unsigned int i = start; i < end; i++ )
+
+ for (unsigned int i = start; i < end; i++)
worldData[i].groundHeight = 0;
}
void World::
-addHill( const ivec2 peak, const unsigned int width )
+addHill(const ivec2 peak, const unsigned int width)
{
int start = peak.x - width / 2, end = start + width, offset = 0;
const float thing = peak.y - worldData[start].groundHeight;
const float period = PI / width;
- if ( start < 0 ) {
+ if (start < 0) {
offset = -start;
start = 0;
}
- if ( end > (signed)worldData.size() )
+ if (end > (signed)worldData.size())
end = worldData.size();
- for ( int i = start; i < end; i++ ) {
+ for (int i = start; i < end; i++) {
worldData[i].groundHeight += thing * sin((i - start + offset) * period);
- if ( worldData[i].groundHeight > peak.y )
+ if (worldData[i].groundHeight > peak.y)
worldData[i].groundHeight = peak.y;
}
}
int World::
-getTheWidth( void ) const
+getTheWidth(void) const
{
return worldStart * -2;
}
@@ -1207,9 +1238,9 @@ void World::save(void){
}
for(auto &m : mob){
- data.append(std::to_string((int)m->loc.x) + "\n");
- data.append(std::to_string((int)m->loc.y) + "\n");
- data.append(std::to_string((int)m->alive) + "\n");
+ data.append(std::to_string((int)m.loc.x) + "\n");
+ data.append(std::to_string((int)m.loc.y) + "\n");
+ data.append(std::to_string((int)m.alive) + "\n");
}
data.append("dOnE\0");
@@ -1253,13 +1284,13 @@ void World::load(void){
for(auto &m : mob){
std::getline(iss,line);
if(line == "dOnE")return;
- m->loc.x = std::stoi(line);
+ m.loc.x = std::stoi(line);
std::getline(iss,line);
if(line == "dOnE")return;
- m->loc.y = std::stoi(line);
+ m.loc.y = std::stoi(line);
std::getline(iss,line);
if(line == "dOnE")return;
- m->alive = std::stoi(line);
+ m.alive = std::stoi(line);
}
while(std::getline(iss,line)){
@@ -1270,12 +1301,12 @@ void World::load(void){
delete[] filedata;
}
-float getIndoorWorldFloorHeight( void )
+float getIndoorWorldFloorHeight(void)
{
return INDOOR_FLOOR_HEIGHTT + INDOOR_FLOOR_THICKNESS;
}
-bool isCurrentWorldIndoors( void ) {
+bool isCurrentWorldIndoors(void) {
return !inside.empty();
}
@@ -1289,28 +1320,28 @@ IndoorWorld::~IndoorWorld(void){
}
void IndoorWorld::
-addFloor( unsigned int width )
+addFloor(unsigned int width)
{
- if ( floor.empty() )
- generate( width );
- floor.emplace_back( width, floor.size() * INDOOR_FLOOR_HEIGHTT + INDOOR_FLOOR_THICKNESS );
- fstart.push_back( 0 );
+ if (floor.empty())
+ generate(width);
+ floor.emplace_back(width, floor.size() * INDOOR_FLOOR_HEIGHTT + INDOOR_FLOOR_THICKNESS);
+ fstart.push_back(0);
}
void IndoorWorld::
-addFloor( unsigned int width, unsigned int start )
+addFloor(unsigned int width, unsigned int start)
{
- if ( floor.empty() )
- generate( width );
- floor.emplace_back( width, floor.size() * INDOOR_FLOOR_HEIGHTT + INDOOR_FLOOR_THICKNESS );
- fstart.push_back( start );
+ if (floor.empty())
+ generate(width);
+ floor.emplace_back(width, floor.size() * INDOOR_FLOOR_HEIGHTT + INDOOR_FLOOR_THICKNESS);
+ fstart.push_back(start);
}
bool IndoorWorld::
-moveToFloor( Entity *e, unsigned int _floor )
+moveToFloor(Entity *e, unsigned int _floor)
{
- if ( _floor > floor.size() )
+ if (_floor > floor.size())
return false;
e->loc.y = floor[_floor - 1][0];
@@ -1318,39 +1349,39 @@ moveToFloor( Entity *e, unsigned int _floor )
}
bool IndoorWorld::
-isFloorAbove( Entity *e )
+isFloorAbove(Entity *e)
{
- for ( unsigned int i = 0; i < floor.size(); i++ ) {
- if ( floor[i][0] + INDOOR_FLOOR_HEIGHTT - 100 > e->loc.y )
+ for (unsigned int i = 0; i < floor.size(); i++) {
+ if (floor[i][0] + INDOOR_FLOOR_HEIGHTT - 100 > e->loc.y)
return (i + 1) != floor.size();
}
return false;
}
bool IndoorWorld::
-isFloorBelow( Entity *e )
+isFloorBelow(Entity *e)
{
- for ( unsigned int i = 0; i < floor.size(); i++ ) {
- if ( floor[i][0] + INDOOR_FLOOR_HEIGHTT - 100 > e->loc.y )
+ for (unsigned int i = 0; i < floor.size(); i++) {
+ if (floor[i][0] + INDOOR_FLOOR_HEIGHTT - 100 > e->loc.y)
return i > 0;
}
return false;
}
void IndoorWorld::
-singleDetect( Entity *e )
+singleDetect(Entity *e)
{
unsigned int floornum = 0;
float start, end;
- if ( !e->alive )
+ if (!e->alive)
return;
- if ( e->type == MOBT && Mobp(e)->subtype == MS_TRIGGER )
+ if (e->type == MOBT && Mobp(e)->subtype == MS_TRIGGER)
return;
- for ( ; floornum < floor.size(); floornum++ ) {
- if ( floor[floornum][0] + INDOOR_FLOOR_HEIGHTT - 100 > e->loc.y ) {
- if ( e->loc.y < floor[floornum][0] ) {
+ for (; floornum < floor.size(); floornum++) {
+ if (floor[floornum][0] + INDOOR_FLOOR_HEIGHTT - 100 > e->loc.y) {
+ if (e->loc.y < floor[floornum][0]) {
e->loc.y = floor[floornum][0];
e->vel.y = 0;
e->ground = true;
@@ -1359,21 +1390,21 @@ singleDetect( Entity *e )
}
}
- if ( e->vel.y > -2 )
+ if (e->vel.y > -2)
e->vel.y -= GRAVITY_CONSTANT * deltaTime;
- if ( e->ground ) {
- e->loc.y = ceil( e->loc.y );
+ if (e->ground) {
+ e->loc.y = ceil(e->loc.y);
e->vel.y = 0;
}
start = worldStart + fstart[floornum] * HLINE;
end = start + floor[floornum].size() * HLINE;
- if ( e->loc.x < start ) {
+ if (e->loc.x < start) {
e->vel.x = 0;
e->loc.x = start + HLINE / 2;
- } else if ( e->loc.x + e->width + HLINE > end ) {
+ } else if (e->loc.x + e->width + HLINE > end) {
e->vel.x = 0;
e->loc.x = end - e->width - HLINE;
}
@@ -1381,19 +1412,19 @@ singleDetect( Entity *e )
}
void IndoorWorld::
-draw( Player *p )
+draw(Player *p)
{
unsigned int i,f;
int x;
// draw lights
- for ( auto &l : light ) {
- if ( l.belongsTo ) {
+ for (auto &l : light) {
+ if (l.belongsTo) {
l.loc.x = l.following->loc.x + SCREEN_WIDTH / 2;
- l.loc.y = ( l.following->loc.y > SCREEN_HEIGHT / 2 ) ? SCREEN_HEIGHT / 2 : l.following->loc.y;
+ l.loc.y = (l.following->loc.y > SCREEN_HEIGHT / 2) ? SCREEN_HEIGHT / 2 : l.following->loc.y;
}
- if ( l.flame ) {
- l.fireFlicker = .9 + ( (rand() % 2) / 10.0f );
+ if (l.flame) {
+ l.fireFlicker = .9 + ((rand() % 2) / 10.0f);
l.fireLoc.x = l.loc.x + (rand() % 2 - 1) * 3;
l.fireLoc.y = l.loc.y + (rand() % 2 - 1) * 3;
} else
@@ -1420,16 +1451,16 @@ draw( Player *p )
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
- glUseProgram( shaderProgram );
+ glUseProgram(shaderProgram);
glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);
- glUniform1f(glGetUniformLocation(shaderProgram, "amb" ), 0.02f + light.size()/50.0f);
+ glUniform1f(glGetUniformLocation(shaderProgram, "amb"), 0.02f + light.size()/50.0f);
- if ( light.empty() )
+ if (light.empty())
glUniform1i(glGetUniformLocation(shaderProgram, "numLight"), 0);
else {
- glUniform1i (glGetUniformLocation(shaderProgram, "numLight" ), light.size());
+ glUniform1i (glGetUniformLocation(shaderProgram, "numLight"), light.size());
glUniform2fv(glGetUniformLocation(shaderProgram, "lightLocation"), light.size(), pointArray);
- glUniform3f (glGetUniformLocation(shaderProgram, "lightColor" ), 1.0f, 1.0f, 1.0f);
+ glUniform3f (glGetUniformLocation(shaderProgram, "lightColor"), 1.0f, 1.0f, 1.0f);
glUniform1fv(glGetUniformLocation(shaderProgram, "fireFlicker"), light.size(), flameArray);
}
@@ -1439,10 +1470,10 @@ draw( Player *p )
glColor4ub(255,255,255,255);
glBegin(GL_QUADS);
- glTexCoord2i(0,1); glVertex2i( worldStart - SCREEN_WIDTH / 2,0);
+ glTexCoord2i(0,1); glVertex2i(worldStart - SCREEN_WIDTH / 2,0);
glTexCoord2i((-worldStart*2+SCREEN_WIDTH)/512,1);glVertex2i(-worldStart + SCREEN_WIDTH / 2,0);
glTexCoord2i((-worldStart*2+SCREEN_WIDTH)/512,0);glVertex2i(-worldStart + SCREEN_WIDTH / 2,SCREEN_HEIGHT);
- glTexCoord2i(0,0); glVertex2i( worldStart - SCREEN_WIDTH / 2,SCREEN_HEIGHT);
+ glTexCoord2i(0,0); glVertex2i(worldStart - SCREEN_WIDTH / 2,SCREEN_HEIGHT);
glEnd();
glUseProgram(0);
@@ -1451,18 +1482,18 @@ draw( Player *p )
* Draw the ground.
*/
- glUseProgram( shaderProgram );
- glUniform1i( glGetUniformLocation(shaderProgram, "sampler"), 0 );
- glBegin( GL_QUADS );
- safeSetColor( 150, 100, 50 );
- for ( f = 0; f < floor.size(); f++ ) {
+ glUseProgram(shaderProgram);
+ glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);
+ glBegin(GL_QUADS);
+ safeSetColor(150, 100, 50);
+ for (f = 0; f < floor.size(); f++) {
i = 0;
- for ( h : floor[f] ) {
+ for (h : floor[f]) {
x = worldStart + fstart[f] * HLINE + (i * HLINE);
- glVertex2i( x , h );
- glVertex2i( x + HLINE, h );
- glVertex2i( x + HLINE, h - INDOOR_FLOOR_THICKNESS );
- glVertex2i( x , h - INDOOR_FLOOR_THICKNESS );
+ glVertex2i(x , h );
+ glVertex2i(x + HLINE, h );
+ glVertex2i(x + HLINE, h - INDOOR_FLOOR_THICKNESS);
+ glVertex2i(x , h - INDOOR_FLOOR_THICKNESS);
i++;
}
}
@@ -1478,14 +1509,14 @@ draw( Player *p )
glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);
glUseProgram(shaderProgram);
- std::for_each( particles.begin(), particles.end(), [](Particles &part) { part.draw(); });
+ std::for_each(particles.begin(), particles.end(), [](Particles &part) { part.draw(); });
glUseProgram(0);
- /*for ( auto &part : particles )
+ /*for (auto &part : particles)
part.draw();*/
- for ( auto &e : entity )
+ for (auto &e : entity)
e->draw();
p->draw();
@@ -1499,8 +1530,8 @@ Arena::Arena(World *leave,Player *p,Mob *m){
mmob = m;
mmob->aggressive = false;
- mob.push_back(m);
- entity.push_back(m);
+ mob.push_back(*m);
+ entity.push_back(&mob.back());
battleNest.push_back(leave);
battleNestLoc.push_back(p->loc);
@@ -1512,9 +1543,9 @@ Arena::~Arena(void){
World *Arena::exitArena(Player *p){
World *tmp;
- if ( !mmob->alive &&
- p->loc.x + p->width / 2 > mob[0]->loc.x &&
- p->loc.x + p->width / 2 < mob[0]->loc.x + HLINE * 12 ) {
+ if (!mmob->alive &&
+ p->loc.x + p->width / 2 > mob[0].loc.x &&
+ p->loc.x + p->width / 2 < mob[0].loc.x + HLINE * 12) {
tmp = battleNest.front();
battleNest.erase(battleNest.begin());
@@ -1534,9 +1565,9 @@ World *Arena::exitArena(Player *p){
}
}
-std::string getWorldWeatherStr( WorldWeather ww )
+std::string getWorldWeatherStr(WorldWeather ww)
{
- switch ( ww ) {
+ switch (ww) {
case WorldWeather::Sunny:
return "Sunny";
break;
@@ -1556,22 +1587,22 @@ static bool loadedLeft = false;
static bool loadedRight = false;
World *loadWorldFromXML(std::string path){
- if ( !currentXML.empty() )
+ if (!currentXML.empty())
currentWorld->save();
return loadWorldFromXMLNoSave(path);
}
-World *loadWorldFromPtr( World *ptr )
+World *loadWorldFromPtr(World *ptr)
{
World *tmp = ptr;
loadedLeft = true;
- currentWorldToLeft = loadWorldFromXML( tmp->toLeft );
+ currentWorldToLeft = loadWorldFromXML(tmp->getToLeft());
loadedLeft = false;
loadedRight = true;
- currentWorldToRight = loadWorldFromXML( tmp->toRight );
+ currentWorldToRight = loadWorldFromXML(tmp->getToRight());
loadedRight = false;
return tmp;
@@ -1582,7 +1613,7 @@ World *loadWorldFromPtr( World *ptr )
*/
World *
-loadWorldFromXMLNoSave( std::string path ) {
+loadWorldFromXMLNoSave(std::string path) {
XMLDocument xml;
XMLElement *wxml;
XMLElement *vil;
@@ -1596,14 +1627,14 @@ loadWorldFromXMLNoSave( std::string path ) {
std::string name, sptr;
// no file? -> no world
- if ( path.empty() )
+ if (path.empty())
return NULL;
currentXML = std::string(xmlFolder + path);
- xml.LoadFile( currentXML.c_str() );
+ xml.LoadFile(currentXML.c_str());
// attempt to load a <World> tag
- if ( (wxml = xml.FirstChildElement("World")) ) {
+ if ((wxml = xml.FirstChildElement("World"))) {
wxml = wxml->FirstChildElement();
vil = xml.FirstChildElement("World")->FirstChildElement("village");
tmp = new World();
@@ -1611,7 +1642,7 @@ loadWorldFromXMLNoSave( std::string path ) {
}
// attempt to load an <IndoorWorld> tag
- else if( (wxml = xml.FirstChildElement("IndoorWorld")) ) {
+ else if((wxml = xml.FirstChildElement("IndoorWorld"))) {
wxml = wxml->FirstChildElement();
vil = NULL;
tmp = new IndoorWorld();
@@ -1623,39 +1654,39 @@ loadWorldFromXMLNoSave( std::string path ) {
UserError("XML Error: Cannot find a <World> or <IndoorWorld> tag in " + currentXML + "!");
// iterate through world tags
- while ( wxml ) {
+ while (wxml) {
name = wxml->Name();
// world linkage
- if ( name == "link" ) {
+ if (name == "link") {
// links world to the left
- if ( (ptr = wxml->Attribute("left")) ) {
- tmp->setToLeft( ptr );
+ if ((ptr = wxml->Attribute("left"))) {
+ tmp->setToLeft(ptr);
// load the left world if it isn't
- if ( !loadedLeft ) {
+ if (!loadedLeft) {
loadedLeft = true;
- currentWorldToLeft = loadWorldFromXMLNoSave( ptr );
+ currentWorldToLeft = loadWorldFromXMLNoSave(ptr);
loadedLeft = false;
}
}
// links world to the right
- else if ( (ptr = wxml->Attribute("right")) ) {
- tmp->setToRight( ptr );
+ else if ((ptr = wxml->Attribute("right"))) {
+ tmp->setToRight(ptr);
// load the right world if it isn't
- if ( !loadedRight ) {
+ if (!loadedRight) {
loadedRight = true;
- currentWorldToRight = loadWorldFromXMLNoSave( ptr );
+ currentWorldToRight = loadWorldFromXMLNoSave(ptr);
loadedRight = false;
}
}
// tells what world is outside, if in a structure
- else if ( Indoor && (ptr = wxml->Attribute("outside")) )
- inside.push_back( ptr );
+ else if (Indoor && (ptr = wxml->Attribute("outside")))
+ inside.push_back(ptr);
// error, invalid link tag
else
@@ -1664,26 +1695,26 @@ loadWorldFromXMLNoSave( std::string path ) {
}
// style tags
- else if ( name == "style" ) {
+ else if (name == "style") {
// set style folder
- tmp->setStyle( wxml->StrAttribute("folder") );
+ tmp->setStyle(wxml->StrAttribute("folder"));
// set background folder
- if ( wxml->QueryUnsignedAttribute("background", &flooor) != XML_NO_ERROR )
+ if (wxml->QueryUnsignedAttribute("background", &flooor) != XML_NO_ERROR)
UserError("XML Error: No background given in <style> in " + currentXML + "!");
- tmp->setBackground( (WorldBGType)flooor );
+ tmp->setBackground((WorldBGType)flooor);
// set BGM file
- tmp->setBGM( wxml->StrAttribute("bgm") );
+ tmp->setBGM(wxml->StrAttribute("bgm"));
}
// world generation (for outdoor areas)
- else if ( name == "generation" ) {
+ else if (name == "generation") {
// random gen.
- if ( !Indoor && wxml->StrAttribute("type") == "Random" )
- tmp->generate( wxml->UnsignedAttribute("width") );
+ if (!Indoor && wxml->StrAttribute("type") == "Random")
+ tmp->generate(wxml->UnsignedAttribute("width"));
else {
- if ( Indoor )
+ if (Indoor)
UserError("XML Error: <generation> tags can't be in <IndoorWorld> tags (in " + currentXML + ")!");
else
UserError("XML Error: Invalid <generation> tag in " + currentXML + "!");
@@ -1691,86 +1722,86 @@ loadWorldFromXMLNoSave( std::string path ) {
}
// mob creation
- else if ( name == "mob" ) {
+ else if (name == "mob") {
// type info
- if ( wxml->QueryUnsignedAttribute("type", &flooor) != XML_NO_ERROR )
+ if (wxml->QueryUnsignedAttribute("type", &flooor) != XML_NO_ERROR)
UserError("XML Error: Invalid type value in <mob> in " + currentXML + "!");
// spawn at coordinate if desired
- if ( wxml->QueryFloatAttribute( "x", &spawnx ) == XML_NO_ERROR )
- tmp->addMob( flooor, spawnx, wxml->FloatAttribute("y"));
+ if (wxml->QueryFloatAttribute("x", &spawnx) == XML_NO_ERROR)
+ tmp->addMob(flooor, spawnx, wxml->FloatAttribute("y"));
else
- tmp->addMob( flooor, 0, 100 );
+ tmp->addMob(flooor, 0, 100);
// aggressive tag
- if ( wxml->QueryBoolAttribute( "aggressive", &dialog ) == XML_NO_ERROR )
- tmp->mob.back()->aggressive = dialog;
+ if (wxml->QueryBoolAttribute("aggressive", &dialog) == XML_NO_ERROR)
+ tmp->getLastMob()->aggressive = dialog;
// indoor spawning floor selection
- if ( Indoor && wxml->QueryUnsignedAttribute( "floor", &flooor ) == XML_NO_ERROR )
- Indoorp(tmp)->moveToFloor( tmp->npc.back(), flooor );
+ if (Indoor && wxml->QueryUnsignedAttribute("floor", &flooor) == XML_NO_ERROR)
+ Indoorp(tmp)->moveToFloor(tmp->npc.back(), flooor);
// custom health value
- if ( wxml->QueryFloatAttribute( "health", &spawnx) == XML_NO_ERROR )
- tmp->mob.back()->health = tmp->mob.back()->maxHealth = spawnx;
+ if (wxml->QueryFloatAttribute("health", &spawnx) == XML_NO_ERROR)
+ tmp->getLastMob()->health = tmp->getLastMob()->maxHealth = spawnx;
}
// npc creation
- else if ( name == "npc" ) {
+ else if (name == "npc") {
const char *npcname;
// spawn at coordinates if desired
- if ( wxml->QueryFloatAttribute( "x", &spawnx ) == XML_NO_ERROR)
- tmp->addNPC( spawnx, 100 );
+ if (wxml->QueryFloatAttribute("x", &spawnx) == XML_NO_ERROR)
+ tmp->addNPC(spawnx, 100);
else
- tmp->addNPC( 0, 100 );
+ tmp->addNPC(0, 100);
// name override
- if ( (npcname = wxml->Attribute("name")) ) {
+ if ((npcname = wxml->Attribute("name"))) {
delete[] tmp->npc.back()->name;
tmp->npc.back()->name = new char[strlen(npcname) + 1];
- strcpy( tmp->npc.back()->name, npcname );
+ strcpy(tmp->npc.back()->name, npcname);
}
// dialog enabling
dialog = false;
- if ( wxml->QueryBoolAttribute( "hasDialog", &dialog ) == XML_NO_ERROR && dialog )
- tmp->npc.back()->addAIFunc( commonAIFunc, false );
+ if (wxml->QueryBoolAttribute("hasDialog", &dialog) == XML_NO_ERROR && dialog)
+ tmp->npc.back()->addAIFunc(commonAIFunc, false);
else
tmp->npc.back()->dialogIndex = 9999;
- if ( Indoor && wxml->QueryUnsignedAttribute( "floor", &flooor ) == XML_NO_ERROR )
- Indoorp(tmp)->moveToFloor( tmp->npc.back(), flooor );
+ if (Indoor && wxml->QueryUnsignedAttribute("floor", &flooor) == XML_NO_ERROR)
+ Indoorp(tmp)->moveToFloor(tmp->npc.back(), flooor);
// custom health value
- if ( wxml->QueryFloatAttribute( "health", &spawnx) == XML_NO_ERROR )
- tmp->mob.back()->health = tmp->mob.back()->maxHealth = spawnx;
+ if (wxml->QueryFloatAttribute("health", &spawnx) == XML_NO_ERROR)
+ tmp->npc.back()->health = tmp->npc.back()->maxHealth = spawnx;
}
// structure creation
- else if ( name == "structure" ) {
- tmp->addStructure( (BUILD_SUB) wxml->UnsignedAttribute("type"),
- wxml->QueryFloatAttribute( "x", &spawnx ) != XML_NO_ERROR ?
+ else if (name == "structure") {
+ tmp->addStructure((BUILD_SUB) wxml->UnsignedAttribute("type"),
+ wxml->QueryFloatAttribute("x", &spawnx) != XML_NO_ERROR ?
getRand() % tmp->getTheWidth() / 2.0f : spawnx,
100,
wxml->StrAttribute("texture"),
wxml->StrAttribute("inside")
- );
- } else if ( name == "trigger" ) {
- tmp->addMob( MS_TRIGGER, wxml->FloatAttribute("x"), 0, commonTriggerFunc );
- tmp->mob.back()->heyid = wxml->Attribute("id");
- } else if ( name == "page" ) {
- tmp->addMob( MS_PAGE, wxml->FloatAttribute("x"), 0, commonPageFunc );
- tmp->mob.back()->heyid = wxml->Attribute("id");
- } else if ( name == "hill" ) {
- tmp->addHill( ivec2 { wxml->IntAttribute("peakx"), wxml->IntAttribute("peaky") }, wxml->UnsignedAttribute("width") );
- } else if ( name == "time" ) {
- tickCount = std::stoi( wxml->GetText() );
- } else if ( Indoor && name == "floor" ) {
- if ( wxml->QueryFloatAttribute("start",&spawnx) == XML_NO_ERROR )
- Indoorp(tmp)->addFloor( wxml->UnsignedAttribute("width"), spawnx );
+ );
+ } else if (name == "trigger") {
+ tmp->addMob(MS_TRIGGER, wxml->FloatAttribute("x"), 0, commonTriggerFunc);
+ tmp->getLastMob()->heyid = wxml->Attribute("id");
+ } else if (name == "page") {
+ tmp->addMob(MS_PAGE, wxml->FloatAttribute("x"), 0, commonPageFunc);
+ tmp->getLastMob()->heyid = wxml->Attribute("id");
+ } else if (name == "hill") {
+ tmp->addHill(ivec2 { wxml->IntAttribute("peakx"), wxml->IntAttribute("peaky") }, wxml->UnsignedAttribute("width"));
+ } else if (name == "time") {
+ tickCount = std::stoi(wxml->GetText());
+ } else if (Indoor && name == "floor") {
+ if (wxml->QueryFloatAttribute("start",&spawnx) == XML_NO_ERROR)
+ Indoorp(tmp)->addFloor(wxml->UnsignedAttribute("width"), spawnx);
else
- Indoorp(tmp)->addFloor( wxml->UnsignedAttribute("width") );
+ Indoorp(tmp)->addFloor(wxml->UnsignedAttribute("width"));
}
spawnx = 0;
@@ -1779,10 +1810,8 @@ loadWorldFromXMLNoSave( std::string path ) {
Village *vptr;
- if(vil){
- tmp->village.push_back(new Village(vil->Attribute("name"), tmp));
- vptr = tmp->village.back();
-
+ if (vil) {
+ vptr = tmp->addVillage(vil->Attribute("name"), tmp);
vil = vil->FirstChildElement();
}
@@ -1795,56 +1824,56 @@ loadWorldFromXMLNoSave( std::string path ) {
* READS DATA ABOUT STRUCTURE CONTAINED IN VILLAGE
*/
- if ( name == "structure" ) {
+ if (name == "structure") {
tmp->addStructure((BUILD_SUB)vil->UnsignedAttribute("type"),
vil->QueryFloatAttribute("x", &spawnx) != XML_NO_ERROR ? randx : spawnx,
100,
vil->StrAttribute("texture"),
vil->StrAttribute("inside"));
- } else if ( name == "stall" ) {
+ } else if (name == "stall") {
sptr = vil->StrAttribute("type");
// handle markets
- if ( sptr == "market" ) {
+ if (sptr == "market") {
// create a structure and a merchant, and pair them
- tmp->addStructure( STALL_MARKET,
+ tmp->addStructure(STALL_MARKET,
vil->QueryFloatAttribute("x", &spawnx) != XML_NO_ERROR ? randx : spawnx,
100,
vil->StrAttribute("texture"),
vil->StrAttribute("inside")
- );
- tmp->addMerchant( 0, 100 );
+ );
+ tmp->addMerchant(0, 100);
tmp->merchant.back()->inside = tmp->build.back();
}
// handle traders
- else if ( sptr == "trader") {
- tmp->addStructure( STALL_TRADER,
+ else if (sptr == "trader") {
+ tmp->addStructure(STALL_TRADER,
vil->QueryFloatAttribute("x", &spawnx) != XML_NO_ERROR ? randx : spawnx,
100,
vil->StrAttribute("texture"),
vil->StrAttribute("inside")
- );
+ );
}
// loop through buy/sell/trade tags
XMLElement *sxml = vil->FirstChildElement();
std::string tag;
- while ( sxml ) {
+ while (sxml) {
tag = sxml->Name();
- if ( tag == "buy" ) {
+ if (tag == "buy") {
// TODO
- } else if ( tag == "sell" ) {
+ } else if (tag == "sell") {
// TODO
- } else if ( tag == "trade" ) {
- tmp->merchant.back()->trade.push_back( Trade( sxml->IntAttribute("quantity"),
+ } else if (tag == "trade") {
+ tmp->merchant.back()->trade.push_back(Trade(sxml->IntAttribute("quantity"),
sxml->StrAttribute("item"),
sxml->IntAttribute("quantity1"),
sxml->StrAttribute("item1")
- ));
+ ));
}
sxml = sxml->NextSiblingElement();
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-05 20:20:32 +0000