Castle Class Reference

The Castle handles all things related to the Castles Building, treasure, physics and collisions. More...

#include <castle.h>

Public Member Functions
	Castle (scene::ISceneManager *smgr, Physics *physics, IrrlichtDevice *device, video::IVideoDriver *driver, core::vector3df center)
	Default constructor. More...
bool	buildCastle (core::vector3df center)
	Build the castle. More...
core::vector3df	getSideSize (char side)
	Get size from a side. More...
void	setTreasure ()
	Set treasure in the castle. More...
core::vector3df	calculateAbsoluteCenter ()
	Get center of the castle in Irrlicht world coordinates. More...
bool	checkTarget ()
	Check if target is moved TARGET_OFFSET is the max offset of the target from initial position. More...

Public Attributes
video::SColor	COLOR_LIGHT
video::SColor	COLOR_DARK

Private Member Functions
void	createBlock (core::vector3df position, core::vector3df scale, core::vector3df rotation, char side, video::SColor color=randomColor())
	Create the block of the castle at a specified position, rotation and scaling. More...
void	addToPhysicsWorld ()

Private Attributes
scene::ISceneManager *	smgr
video::IVideoDriver *	driver
core::vector3df	position
scene::IMeshSceneNode *	node
	Last node used. More...
IrrlichtDevice *	device
std::multimap< char, scene::IMeshSceneNode * >	nodes
	Associative array for blocks. More...
Target *	target
	Target node. More...
core::vector3df	initialTargetPos
	Initial position of the first block. More...
Physics *	physics

Detailed Description

The Castle handles all things related to the Castles Building, treasure, physics and collisions.

Constructor & Destructor Documentation

Castle()

Castle::Castle	(	scene::ISceneManager *	smgr,
		Physics *	physics,
		IrrlichtDevice *	device,
		video::IVideoDriver *	driver,
		core::vector3df	center
	)

Default constructor.

Given irrlicht and bullet instances, this will initialize colors and start building The color palette of the castle is based of 2 type of color randomly generated. COLOR_LIGHT which represent light colors COLOR_DARK which represent dark colors.

See also

createBlock()

buildCastle()

randomColor()

                                                                                                                                 {
    this->smgr = smgr;
    this->nodes.clear();
    this->driver = driver;
    this->device = device;
    this->physics = physics;
    this->position = center;
    this->COLOR_DARK = randomColor();
    this->COLOR_LIGHT = randomColor();
    this->position = center;
    if(this->buildCastle(this->position)){
        this->addToPhysicsWorld();
        this->setTreasure();
    }
}

Member Function Documentation

addToPhysicsWorld()

void Castle::addToPhysicsWorld ( )

private

Deprecated:

Useless method

                              {


}

buildCastle()

bool Castle::buildCastle

(

core::vector3df

center

)

Build the castle.

Given the position, this method will start building the castle from that position. For now it will get data of the castle from xml file in media/Castle

Parameters

center

vector3df position from where to start building

Returns

bool true if castle is successfully builded or false if something went wrong

                                            {

        irr::io::IXMLReader* xml = this->device->getFileSystem()->createXMLReader("media/castle/castle.xml");  //create xml reader
        if (!xml)
            return false;

        const stringw sideTag(L"side"); //we'll be looking for this tag in the xml
        core::stringw currentSection; //keep track of our current section
        const stringw blockTag(L"block"); //constant for blocktag
        core::stringc position, lastposition;
        float width, height, distance = 0.f;
        // core::vector3d<f32> * edges = new core::vector3d<f32>[8];
        f32 offsets[4]={0,0,0,0};
        u32 reading = -1 ;
        core::vector3df pos;
        core::aabbox3d<f32> box;
        core::matrix4 transformer;
        std::multimap<char, scene::IMeshSceneNode*>::iterator first, last;
        //while there is more to read
        log1("Reading XML castle file and building castle");
        while (xml->read())
        {
            //check the node type
            switch (xml->getNodeType()){
                //we found a new element
                case irr::io::EXN_ELEMENT:{

                    //we currently are in the empty or mygame section and find the side tag so we set our current block
                    if (currentSection.empty() && sideTag.equals_ignore_case(xml->getNodeName()))
                    {
                        currentSection = sideTag;
                        position = xml->getAttributeValueSafe(L"position");
                        distance = xml->getAttributeValueAsFloat(L"distance");
                        reading++;
                        // maybe a switch case is better

                        if(!this->nodes.empty() && position[0]){ // assert

                        if(reading == 1) offsets[reading] = BLOCKS_OFFSET+getMeshSize(first->second)[0]/2;
                        if(reading == 2 && last != this->nodes.end()) offsets[reading] = BLOCKS_OFFSET+getMeshSize(last->second)[0]/2;
                        if(reading == 3) offsets[reading] = BLOCKS_OFFSET+getMeshSize(first->second)[0]/2;
                        }

                    } else if (currentSection.equals_ignore_case(sideTag) && blockTag.equals_ignore_case(xml->getNodeName())){
                        //read in the key
                         core::vector3df scale = core::vector3df(1.f,1.f,1.f);
                        width = xml->getAttributeValueAsFloat(L"width");
                        height = xml->getAttributeValueAsFloat(L"height");
                        scale = core::vector3df(width,height,1);

                        switch(position[0]){
                            case 'f':
                                    pos = core::vector3df(
                                    center.X + offsets[0] +scale.X/2, scale.Y/2 , center.Z );
                                    this->createBlock(pos,scale, core::vector3df(0,0,0), 'f', this->COLOR_LIGHT);
                                    offsets[0] += (width+BLOCKS_OFFSET);
                                    break;
                            case 'l':
                                    pos = core::vector3df(
                                    center.X+scale.X/2, scale.Y/2 , scale.X/2+center.Z+offsets[1]);
                                    this->createBlock(pos,scale,core::vector3df(0,90,0), 'l', this->COLOR_DARK);
                                    offsets[1] += (width+BLOCKS_OFFSET);
                            break;
                            case 'b':
                                    pos = core::vector3df(
                                    center.X+scale.X/2+offsets[2], scale.Y/2,
                                    center.Z+distance+getMeshSize(this->node)[0]+BLOCKS_OFFSET*5
                                    );
                                    this->createBlock(pos,scale,core::vector3df(0,0,0), 'b', this->COLOR_LIGHT);
                                    offsets[2] += (width+BLOCKS_OFFSET);



                            break;
                            case 'r':
                                    pos = core::vector3df(
                                    center.X+distance-getMeshSize(this->node)[2], scale.Y/2 , scale.X/2+center.Z+offsets[3]);
                                    this->createBlock(pos,scale,core::vector3df(0,90,0), 'r', this->COLOR_DARK);
                                    offsets[3] += (width+BLOCKS_OFFSET);


                            break;
                            default:break;
                        }
                        if(!this->nodes.empty()){
                        first = this->nodes.begin();
                        last = this->nodes.end();
                        }

                    }

                }
                break;

                // found the end of an element(side)
                case irr::io::EXN_ELEMENT_END:
                    if(currentSection.equals_ignore_case(xml->getNodeName())) {position = ""; currentSection = ""; };
                break;

                default: break;
            }
        }

        // delete the xml reader
        xml->drop();
        return true;

}

calculateAbsoluteCenter()

core::vector3df Castle::calculateAbsoluteCenter

(

)

Get center of the castle in Irrlicht world coordinates.

                                             {
    core::vector3df relativeCenter = this->position;
    relativeCenter.X+= this->getSideSize('f').X * 0.5f;
    relativeCenter.Z+= this->getSideSize('l').X * 0.5f;
    return relativeCenter;
}

checkTarget()

bool Castle::checkTarget

(

)

Check if target is moved TARGET_OFFSET is the max offset of the target from initial position.

That means if it will be hitted, if the actual position is greater than previos+targetoffset, the player lose I didn't have so much time to build a more sophisticated system, sry!

                        {
    core::vector3df diff = (this->target->getIrrNode()->getAbsolutePosition() - this->initialTargetPos);
    diff = core::vector3df(abs(diff.X),abs(diff.Y),abs(diff.Z));
    return (diff.X >= TARGET_OFFSET || diff.Z >= TARGET_OFFSET);
}

createBlock()

void Castle::createBlock ( core::vector3df  position, core::vector3df  scale, core::vector3df  rotation, char  side, video::SColor  color = randomColor()  )

private

Create the block of the castle at a specified position, rotation and scaling.

Parameters

position	vector3df position
scale	vector3df extent of the block
rotation	vector3df rotation of the block
side	char the side of the block
color	SColor color of the block. Optional.

                                                                                                                          {
      this->node = this->smgr->addCubeSceneNode(1,0,-1);
      this->node->setPosition(position);
      this->node->setScale(scale);
      this->node->setMaterialFlag(video::EMF_LIGHTING,false);
      this->smgr->getMeshManipulator()->setVertexColors(this->node->getMesh(),color);
      logVector(2,"Position castle block at", position);
        #if (DEBUG_OUTPUT_MASK & 2)
          this->node->setDebugDataVisible((scene::E_DEBUG_SCENE_TYPE)scene::EDS_BBOX_BUFFERS);
        #endif
      assert(this->node != 0);
      if(this->node){
        this->nodes.insert(std::make_pair(side, this->node));
        this->physics->createCastleBlock(this->node,rotation,scale,position);
      }
}

getSideSize()

core::vector3df Castle::getSideSize

(

char

side

)

Get size from a side.

There is a problem: left/right side blocks scale is defined with X and a rotation(90°). So Z is 1. Whenever you call this function you get the width(X) not the actual size based on the irrlicht axis and the overall bounding box. Height is correct. So this will return the sum of the width attribute in xml of a specified side. (f = front, b=back, l=left, r=right )

Parameters

side	char letter of the side (f = front, b=back, l=left, r=right )

Returns

vector3df

                                          {
    core::vector3df size_side = core::vector3df(0,0,0) ;
    std::pair<
        std::multimap<char, scene::IMeshSceneNode*>::iterator,
        std::multimap<char, scene::IMeshSceneNode*>::iterator
        > blocks;
    blocks = this->nodes.equal_range(side);
    for(std::multimap<char, scene::IMeshSceneNode*>::iterator it = blocks.first; it != blocks.second; ++it){
        size_side.X+= it->second->getScale().X;
        size_side.Y+= it->second->getScale().Y;
        size_side.Z+= it->second->getScale().Z;
    }
    return size_side;
}

setTreasure()

void Castle::setTreasure

(

)

Set treasure in the castle.

                        {
//    core::vector3df position = this->calculateAbsoluteCenter();
    f32 x = this->getSideSize('f').X * getRand(100)/150;
    f32 z = this->getSideSize('l').X * getRand(100)/100;
    core::vector3df position = core::vector3df(0.5f+this->position.X + x,0,this->position.Z + z);
    this->target = new Target(position,this->smgr,this->driver,this->physics);
    this->initialTargetPos = position;
    log1("Treasure positioned");
}

Member Data Documentation

COLOR_DARK

video::SColor Castle::COLOR_DARK

COLOR_LIGHT

video::SColor Castle::COLOR_LIGHT

device

IrrlichtDevice* Castle::device

private

driver

video::IVideoDriver* Castle::driver

private

initialTargetPos

core::vector3df Castle::initialTargetPos

private

Initial position of the first block.

node

scene::IMeshSceneNode* Castle::node

private

Last node used.

nodes

std::multimap<char, scene::IMeshSceneNode*> Castle::nodes

private

Associative array for blocks.

This memorize of each side f, l, r, b, the nodes of the blocks

physics

Physics* Castle::physics

private

position

core::vector3df Castle::position

private

smgr

scene::ISceneManager* Castle::smgr

private

target

Target* Castle::target

private

Target node.

---

The documentation for this class was generated from the following files:

• src/enviroment/castle.h
• src/enviroment/castle.cpp