//--------------------------------------------------------------
// CBounceEffect::isEntityValidTarget()
//--------------------------------------------------------------
bool CBounceEffect::isEntityValidTarget(CEntityBase *entity, CEntityBase *actor) const
{
#ifdef NL_DEBUG
nlassert(entity);
#endif
if (entity->isDead())
return false;
if (entity->getId().getType() == RYZOMID::player)
return true;
if ( entity->getContextualProperty().getValue().attackable() )
return true;
CCreature * creature = CreatureManager.getCreature( entity->getId() );
if (creature && actor)
{
if (creature->checkFactionAttackable( actor->getId() ))
{
return true;
}
}
return false;
} // checkTargetValidity //
//--------------------------------------------------------------
// initFromAiAction
//--------------------------------------------------------------
bool CMagicAiActionDoT::initFromAiAction( const CStaticAiAction *aiAction, CMagicPhrase *phrase )
{
#ifdef NL_DEBUG
nlassert(phrase);
nlassert(aiAction);
#endif
if (aiAction->getType() != AI_ACTION::DoTSpell )
return false;
// read parameters
const COTSpellParams &data = aiAction->getData().OTSpell;
CCreature *creature = CreatureManager.getCreature( phrase->getActor() );
if (creature && creature->getForm())
_TotalDamageValue = (uint16)(data.SpellParamValue + data.SpellPowerFactor * creature->getForm()->getAttackLevel());
else
_TotalDamageValue = (uint16)data.SpellParamValue;
_EffectDuration = data.Duration;
_UpdateFrequency = data.UpdateFrequency;
_AffectedScore = data.AffectedScore;
_DamageType = data.DamageType;
_Stackable = data.Stackable;
_DurationType = data.EffectDurationType;
phrase->setMagicFxType(MAGICFX::toMagicFx( _DamageType, true), 3);
return true;
} // initFromAiAction //
bool CMagicActionBasicDamage::initFromAiAction(CStaticAiAction const* aiAction, CMagicPhrase* phrase)
{
#ifdef NL_DEBUG
nlassert(phrase);
nlassert(aiAction);
#endif
if (aiAction->getType() != AI_ACTION::DamageSpell ) return false;
sint32 damageBonus = 0;
CCreature *creature = CreatureManager.getCreature( phrase->getActor() );
if (creature && creature->getForm())
damageBonus = sint32(aiAction->getData().Spell.SpellPowerFactor * creature->getForm()->getAttackLevel());
switch(aiAction->getData().Spell.AffectedScore)
{
case SCORES::sap:
_DmgSap = sint32(aiAction->getData().Spell.SpellParamValue + damageBonus);
break;
case SCORES::stamina:
_DmgSta = sint32(aiAction->getData().Spell.SpellParamValue + damageBonus);
break;
case SCORES::hit_points:
_DmgHp = sint32(aiAction->getData().Spell.SpellParamValue + damageBonus);
break;
default:
return false;
};
_VampirismValue = (sint32)aiAction->getData().Spell.SpellParamValue2;
_DmgType = aiAction->getData().Spell.DamageType;
phrase->setMagicFxType(MAGICFX::toMagicFx( _DmgType, false), 1);
return true;
}
//--------------------------------------------------------------
// initFromAiAction
//--------------------------------------------------------------
bool CMagicAiActionDamageAura::initFromAiAction( const CStaticAiAction *aiAction, CMagicPhrase *phrase )
{
#ifdef NL_DEBUG
nlassert(phrase);
nlassert(aiAction);
#endif
if (aiAction->getType() != AI_ACTION::EoTSpell )
return false;
// read parameters
const COTEffectSpellParams &data = aiAction->getData().OTEffectSpell;
CCreature *creature = CreatureManager.getCreature( phrase->getActor() );
if (creature && creature->getForm())
_DamagePerUpdate = (uint16)(data.SpellParamValue2 + data.SpellPowerFactor * creature->getForm()->getAttackLevel());
else
_DamagePerUpdate = (uint16)data.SpellParamValue2;
_EffectFamily = AI_ACTION::toEffectFamily(data.EffectFamily, aiAction->getType());
_EffectDuration = data.Duration;
_Range = data.SpellParamValue;
_CycleLength = data.UpdateFrequency;
phrase->setMagicFxType(MAGICFX::toMagicFx( _EffectFamily), 3);
return true;
} // initFromAiAction //
//-----------------------------------------------
// CHarvestPhrase harvestCorpseResult
//-----------------------------------------------
void CHarvestPhrase::harvestCorpseResult()
{
H_AUTO(CHarvestPhrase_harvestCorpseResult);
// get harvester character
CCharacter *character = PlayerManager.getChar( _ActorRowId );
if (character == NULL)
{
//nlwarning("<cbHarvestResult> Invalid player Id %s", playerId.toString().c_str() );
return;
}
// get harvested corpse
const CEntityId &harvestedEntity = character->harvestedEntity();
CCreature *creature = CreatureManager.getCreature( harvestedEntity );
if (creature == NULL)
{
nlwarning("<cbHarvestResult> Invalid creature Id %s", harvestedEntity.toString().c_str() );
// reset harvest info
character->resetHarvestInfos();
character->endHarvest();
return;
}
const vector< CCreatureRawMaterial> &mps = creature->getMps();
if ( character->harvestedMpIndex() >= mps.size() || character->harvestedMpQuantity() > mps[character->harvestedMpIndex()].Quantity )
{
// reset harvest info
character->resetHarvestInfos();
return;
}
uint16 quality = _MaxQuality;
// create the mp items if any
if (quality > 0)
{
if ( !character->createItemInInventory(INVENTORIES::bag, quality, character->harvestedMpQuantity(), _RawMaterialId, character->getId()) )
{
// CMissionEventItem event(CMissionEvent::Harvest,playerId,harvestedEntity,_RawMaterialId,quality,character->harvestedMpQuantity());
// character->processMissionEvent(event);
// error creating the object, hand probably not empty
// character->resetHarvestInfos();
// return;
}
else
{
const CStaticItem *item = CSheets::getForm(_RawMaterialId);
if (item)
{
///\todo nico: check if this event exists
// CMissionEventHarvest event(_RawMaterialId ,character->harvestedMpQuantity(),quality);
// character->processMissionEvent( event );
SM_STATIC_PARAMS_3(params, STRING_MANAGER::integer, STRING_MANAGER::item, STRING_MANAGER::integer);
params[0].Int = (sint32)character->harvestedMpQuantity();
params[1].SheetId = _RawMaterialId;
params[2].Int = (sint32)quality;
STRING_MANAGER::sendStringToClient( character->getEntityRowId(), "HARVEST_SUCCESS", params );
}
}
}
// the mp have been destroyed -> do nothing
else
{
}
// remove the quantity of mp harvested from the ressource
creature->removeMp( character->harvestedMpIndex(), character->harvestedMpQuantity() );
// reset harvest info
character->resetHarvestInfos();
} // harvestCorpseResult //
bool CRenderManager::update()
{
glColor3f(1.0f,1.0f,1.0f);
// get camera
CCamera *camera = CV_GAME_MANAGER->getControlManager()->getCamera();
// transform view
camera->transformView();
// Draw the map and items that fall into view frustum.
// 1. extract approximate logical location of camera in the level map.
vector2i center = CConversions::realToLogical(camera->getPosition());
GLint centerX = center[0];
GLint centerY = center[1];
bool isFPS = CV_GAME_MANAGER->getControlManager()->isFPS();
if (isFPS)
{
// fog only in FPS mode
glEnable(GL_FOG);
}
/*
In FPS mode we can't use height to determine visible offset.
We have to use some extent read from config (CV_CAMERA_FPS_EXTENT).
*/
GLint diff = (GLint)(isFPS?cameraFPSExtent:camera->getPosition()[1]*10.0f);
// 2. create a bounding square making its center logical position calculate above.
GLint minX = (centerX-diff>=0?centerX-diff:0);
GLint minY = (centerY-diff>=0?centerY-diff:0);
GLint maxX = (centerX+diff<(GLint)CV_LEVEL_MAP_SIZE?centerX+diff:CV_LEVEL_MAP_SIZE-1);
GLint maxY = (centerY+diff<(GLint)CV_LEVEL_MAP_SIZE?centerY+diff:CV_LEVEL_MAP_SIZE-1);
// 3. go through all block that fall into this bounding square and check if they fall
// int out view frustum. If not then just exclude them.
CBlock *block;
GLint blockVisible = 0,
allVerticesCount = 0,
creaturesVisible = 0,
maxVertInput = 0,
maxTexInput = 0;
tmpVboVertexBufferSize = 0;
tmpVboTexCoordBufferSize = 0;
vector3f vertA,
vertB,
vertC;
GLfloat **verts,
*texCoords;
CLevelManager *lManager = CV_GAME_MANAGER->getLevelManager();
CAnimatedTerrainManager *atManager = CV_GAME_MANAGER->getAnimatedTerrainManager();
CFrustum *frustum = CV_GAME_MANAGER->getControlManager()->getViewFrustum();
bool lavaWater = false;
GLfloat delta = CV_GAME_MANAGER->getDeltaTime();
renderedBlocks.clear();
for (GLint y=minY; y<=maxY; y++)
{
for (GLint x=minX; x<=maxX; x++)
{
block = lManager->getBlock(x,y);
if (block)
{
//block->getBoundingBox()->draw(); // just for testing
if (frustum->containsBBOX(block->getBoundingBox()))
{
blockVisible++;
block->updateTexture(delta);
lavaWater = (block->isLava() || block->isWater());
if (lavaWater)
{
atManager->updateBlock(block);
}
renderedBlocks.push_back(block);
// draw block objects
if (block->getBlockObjects()->size()>0)
{
for (std::vector<CBlockObject*>::iterator rmIter = block->getBlockObjects()->begin(); rmIter != block->getBlockObjects()->end(); rmIter++)
{
CBlockObject *bObj = *rmIter;
bObj->moveTo();
glRotatef(bObj->getRotateY(),0.0f,1.0f,0.0f);
bObj->drawModel(delta);
glRotatef(-bObj->getRotateY(),0.0f,1.0f,0.0f);
bObj->moveBack();
}
}
bool isRoom = block->isRoom();
if (isRoom)
{
std::vector<GLuint> *dls = block->getDisplayLists();
if (dls->size()!=0)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,textureAtlasColor);
glBegin(GL_QUADS);
{
for (std::vector<GLuint>::iterator dlIter = dls->begin(); dlIter != dls->end(); dlIter++)
{
glCallList(*dlIter);
}
}
glEnd();
glDisable(GL_TEXTURE_2D);
}
}
for (GLint f=CBlock::BFS_FRONT; f<=CBlock::BFS_CEILING; f++)
{
if ((!isFPS && f==CBlock::BFS_CEILING) || (isFPS && f==CBlock::BFS_TOP) || (isRoom && f!=CBlock::BFS_CEILING))
{
continue;
}
if (block->isFaceVisible((CBlock::BLOCK_FACE_SELECTOR)f))
{
verts = block->getVertices();
texCoords = block->getTextureCoordinates((CBlock::BLOCK_FACE_SELECTOR)f);
if (lavaWater && f<=CBlock::BFS_RIGHT)
{
/*
Lava and water have only lowers row of wall sections drawn.
If they are drawn at all.
*/
maxVertInput = CV_FBLR_W_L_FACE_VERT_FLOATS;
maxTexInput = CV_FBLR_W_L_FACE_TEX_FLOATS;
}
else
{
maxVertInput = f>=CBlock::BFS_TOP?CV_TBWLC_FACE_VERT_FLOATS:CV_FBLR_FACE_VERT_FLOATS;
maxTexInput = f>=CBlock::BFS_TOP?CV_TBWLC_FACE_TEX_FLOATS:CV_FBLR_FACE_TEX_FLOATS;
}
if (tmpVboVertexBufferSize+maxVertInput>CV_MAX_VERTEX_BUFFER*3)
{
vbo->setElementsCount(CVBO::IDT_vertex,tmpVboVertexBufferSize/3);
vbo->setElementsCount(CVBO::IDT_texture0,tmpVboTexCoordBufferSize/2);
vbo->setElementsCount(CVBO::IDT_texture1,tmpVboTexCoordBufferSize/2);
vbo->draw();
allVerticesCount+=tmpVboVertexBufferSize;
tmpVboVertexBufferSize=0;
tmpVboTexCoordBufferSize=0;
}
memcpy(tmpVboVertexBuffer+tmpVboVertexBufferSize, verts[f], sizeof(GLfloat)*maxVertInput);
tmpVboVertexBufferSize+=maxVertInput;
memcpy(tmpVboTexCoordBuffer+tmpVboTexCoordBufferSize, texCoords, sizeof(GLfloat)*maxTexInput);
tmpVboTexCoordBufferSize+=maxTexInput;
}
}
}
}
}
}
if (tmpVboVertexBufferSize>0)
{
vbo->setElementsCount(CVBO::IDT_vertex,tmpVboVertexBufferSize/3);
vbo->setElementsCount(CVBO::IDT_texture0,tmpVboTexCoordBufferSize/2);
vbo->setElementsCount(CVBO::IDT_texture1,tmpVboTexCoordBufferSize/2);
vbo->draw();
allVerticesCount+=tmpVboVertexBufferSize;
}
// draw creatures
CCreatureManager *cManager = CV_GAME_MANAGER->getCreatureManager();
GLint cCount = cManager->getCreatureVector()->size();
if (cCount>0)
{
CCreature *creature = NULL;
for (std::vector<CCreature*>::iterator cIter = cManager->getCreatureVector()->begin(); cIter != cManager->getCreatureVector()->end(); cIter++)
{
creature = (*cIter);
if (creature)
{
sBoundingBox *cBBOX = creature->getModel()->getBoundingBox();
cBBOX->translate(creature->getPosition());
if (frustum->containsBBOX(cBBOX))
{
creature->draw(delta);
creaturesVisible++;
}
cBBOX->translate(-creature->getPosition());
}
}
}
// draw transparent block objects
for (std::vector<CBlock*>::iterator vbIter = renderedBlocks.begin(); vbIter != renderedBlocks.end(); vbIter++)
{
block = *vbIter;
if (block->getBlockObjects()->size()>0)
{
for (std::vector<CBlockObject*>::iterator rmIter = block->getBlockObjects()->begin(); rmIter != block->getBlockObjects()->end(); rmIter++)
{
CBlockObject *bObj = *rmIter;
bObj->moveTo();
glRotatef(bObj->getRotateY(),0.0f,1.0f,0.0f);
bObj->drawEffect();
glRotatef(-bObj->getRotateY(),0.0f,1.0f,0.0f);
bObj->moveBack();
}
}
}
glDisable(GL_FOG);
if (!isFPS)
{
handlePickedObjects();
}
CV_GAME_MANAGER->getTextPrinter()->print((GLfloat)0,(GLfloat)(CV_SETTINGS_WINDOW_HEIGHT-15*3),"Visible blocks: %d",blockVisible);
CV_GAME_MANAGER->getTextPrinter()->print((GLfloat)0,(GLfloat)(CV_SETTINGS_WINDOW_HEIGHT-15*2),"Visible creatures: %d",creaturesVisible);
CV_GAME_MANAGER->getTextPrinter()->print((GLfloat)0,(GLfloat)(CV_SETTINGS_WINDOW_HEIGHT-15),"Triangles drawn: %d",(allVerticesCount/4)*2);
// render the lights representations. usefull for debugging
CV_GAME_MANAGER->getLightingManager()->drawLightSources(frustum);
return true;
}
