bool ISpell::spawn(CEntity *entity, CMap *map, const Map::CEntity *entityInfo) {
if( !IComponent::spawn(entity,map,entityInfo) ) return false;
Map::CEntity *tempEntity = CEntityFactory::getSingletonPtr()->getInfo(_spellName);
// Comprobamos que los atributos obligatorios existen
assert( tempEntity->hasAttribute("ID") && "Debe tener id, mirar archivo spellType");
// Leemos los atributos obligatorios de arma
_spellID = (SpellType::Enum)tempEntity->getIntAttribute("ID");
_duration = tempEntity->getFloatAttribute("Duration")*1000;
return true;
} // spawn+
void CScreamer::secondarySkill() {
_secondarySkillIsActive = true;
Map::CEntity* screamerShieldInfo = CEntityFactory::getSingletonPtr()->getInfo("ScreamerShield");
float screamerShieldRadius = screamerShieldInfo->getFloatAttribute("physic_radius");
// Creamos una entidad ScreamerShield
// Obtenemos la informacion asociada al arquetipo del escudo del screamer
Vector3 shootPosition = _entity->getPosition() + ( (_entity->getOrientation() * Vector3::NEGATIVE_UNIT_Z ) * (_capsuleRadius + screamerShieldRadius) );
shootPosition.y += _heightShoot;
// Creamos la entidad y la activamos
_screamerShield = CEntityFactory::getSingletonPtr()->createEntity(
screamerShieldInfo,
Logic::CServer::getSingletonPtr()->getMap(),
shootPosition,
_entity->getOrientation()
);
// Activamos la entidad creada
_screamerShield->activate();
_screamerShield->start();
// Enviamos el mensaje SET_OWNER para que el escudo se mueva
// acorde a los movimientos del player
shared_ptr<CMessageSetOwner> setOwnerMsg = make_shared<CMessageSetOwner>();
setOwnerMsg->setOwner(_entity);
_screamerShield->emitMessage(setOwnerMsg);
// Sonido del escudo
std::shared_ptr<CMessageAudio> audioMsg = std::make_shared<CMessageAudio>();
audioMsg->setAudioName("character/screamerShield.wav");
audioMsg->isLoopable(true);
audioMsg->is3dSound(true);
_screamerShield->emitMessage(audioMsg);
// Enviamos un mensaje para indicar que se bloquee el disparo
shared_ptr<CMessageBlockShoot> canShootMsg = make_shared<CMessageBlockShoot>();
canShootMsg->canShoot(false);
_entity->emitMessage(canShootMsg);
// Mandamos al jugador que tiene la habilidad disponible
std::shared_ptr<CMessageHud> hudMsg = std::make_shared<CMessageHud>();
hudMsg->setType(CMessageHud::HudType::SECONDARY_ACTIVE);
_entity->emitMessage(hudMsg);
} // secondarySkill
bool CSoulReaperAmmo::spawn(CEntity* entity, CMap *map, const Map::CEntity *entityInfo) {
Map::CEntity* weapon = CEntityFactory::getSingletonPtr()->getInfo(_weaponName);
if( !IWeaponAmmo::spawn(entity, map, weapon) ) return false;
// Nos aseguramos de tener todos los atributos que necesitamos
assert( weapon->hasAttribute("PrimaryFireCooldown") );
// Cooldown del disparo principal
_defaultPrimaryFireCooldown = _primaryFireCooldown = weapon->getFloatAttribute("PrimaryFireCooldown") * 1000;
_friend[_friends] = _entity->getComponent<Logic::CSoulReaper>("CSoulReaper");
if(_friend[_friends])
++_friends;
_friend[_friends] = _entity->getComponent<Logic::CSoulReaperFeedback>("CSoulReaperFeedback");
if(_friend[_friends])
++_friends;
if(_friends == 0)
assert("\nTiene que tenes alguno de los dos componentes");
return true;
}
void CScreamer::createExplotion() {
Map::CEntity* screamerInfo = CEntityFactory::getSingletonPtr()->getInfo("Screamer");
float height = screamerInfo->getFloatAttribute("heightShoot");
// EntitiesHit sera el buffer que contendra la lista de entidades que ha colisionado
// con el overlap
vector<CEntity*> entitiesHit;
// Hacemos una query de overlap con la geometria de una esfera en la posicion
// en la que se encuentra la granada con el radio que se indique de explosion
Physics::SphereGeometry explotionGeom = Physics::CGeometryFactory::getSingletonPtr()->createSphere(_screamerExplotionRadius);
Vector3 explotionPos = _entity->getPosition();
explotionPos.y += height;
Physics::CServer::getSingletonPtr()->overlapMultiple(explotionGeom, explotionPos, entitiesHit);
int nbHits = entitiesHit.size();
// Mandamos el mensaje de daño a cada una de las entidades que hayamos golpeado
// Además aplicamos un desplazamiento al jugador
for(int i = 0; i < nbHits; ++i) {
// Si la entidad golpeada es valida y es un player
if( entitiesHit[i] != NULL && entitiesHit[i]->isPlayer() ) {
// Emitimos el mensaje de instakill
// @todo mandar un mensaje de instakill en vez de un mensaje de daño
shared_ptr<CMessageDamaged> dmgMsg = make_shared<CMessageDamaged>();
dmgMsg->setDamage(_screamerExplotionDamage);
dmgMsg->setEnemy(_entity);
entitiesHit[i]->emitMessage(dmgMsg);
}
}
// Creamos las particulas de la explosion
Map::CEntity* entityInfo = CEntityFactory::getSingletonPtr()->getInfo("ScreamerExplotion");
CEntity* explotion = CEntityFactory::getSingletonPtr()->createEntity(entityInfo, _entity->getMap(), explotionPos, Quaternion::IDENTITY );
explotion->activate();
explotion->start();
} // createExplotion
bool CCoolDownServer::spawn(CEntity* entity, CMap *map, const Map::CEntity *entityInfo) {
if(!ISpell::spawn(entity,map,entityInfo)) return false;
Map::CEntity *tempEntity = CEntityFactory::getSingletonPtr()->getInfo(_spellName);
// Nos aseguramos de tener todos los atributos que necesitamos
assert( tempEntity->hasAttribute("PercentageCooldown") );
_percentage = tempEntity->getFloatAttribute("PercentageCooldown");
_weaponryAmmo.resize(WeaponType::eSIZE);
// Rellenamos el vector con los punteros a los componentes correspondientes
_weaponryAmmo[WeaponType::eSOUL_REAPER] = _entity->getComponent<Logic::CSoulReaperAmmo>("CSoulReaperAmmo");
_weaponryAmmo[WeaponType::eSNIPER]= _entity->getComponent<Logic::CSniperAmmo>("CSniperAmmo");
_weaponryAmmo[WeaponType::eSHOTGUN]= _entity->getComponent<Logic::CShotGunAmmo>("CShotGunAmmo");
_weaponryAmmo[WeaponType::eMINIGUN]= _entity->getComponent<Logic::CMiniGunAmmo>("CMiniGunAmmo");
_weaponryAmmo[WeaponType::eIRON_HELL_GOAT]= _entity->getComponent<Logic::CIronHellGoatAmmo>("CIronHellGoatAmmo");
_weaponryShoot.push_back( _entity->getComponent<Logic::CIronHellGoat>("CIronHellGoat"));
_weaponryShoot.push_back( _entity->getComponent<Logic::CMiniGun>("CMiniGun"));
return true;
} // spawn
bool CHudWeapons::spawn(CEntity *entity, CMap *map, const Map::CEntity *entityInfo) {
if(!IComponent::spawn(entity,map,entityInfo))
return false;
_scene = _entity->getMap()->getScene();
_graphicsEntities = new TGraphicsWeapon[WeaponType::eSIZE];
// Por ahora leo a mano cada una de las armas que tiene el usuario
for(int i = WeaponType::eSOUL_REAPER; i < WeaponType::eSIZE; ++i){
WeaponType::Enum current = (WeaponType::Enum)i;
std::string strWeapon = WeaponType::toString(current);
Map::CEntity* weapon = CEntityFactory::getSingletonPtr()->getInfo(strWeapon);
//_graphicsEntities[i]._graphicsEntity = createGraphicsEntity(weapon, entityInfo->getStringAttribute(weapon+"Model"));
_graphicsEntities[current].defaultYaw = _graphicsEntities[current].defaultPitch = _graphicsEntities[current].defaultRoll = 0;
if(weapon->hasAttribute("ModelYaw"))
_graphicsEntities[current].defaultYaw = weapon->getFloatAttribute("ModelYaw");
if(weapon->hasAttribute("ModelPitch"))
_graphicsEntities[current].defaultPitch = weapon->getFloatAttribute("ModelPitch");
if(weapon->hasAttribute("ModelRoll"))
_graphicsEntities[current].defaultRoll = weapon->getFloatAttribute("ModelRoll");
//Esto puede petar si no esta, pero creo q es obligatorio
if(!weapon->hasAttribute("Offset"))
assert("seguro que no tiene offset?");
_graphicsEntities[current].offset = weapon->getVector3Attribute("Offset");
/*
// Ahora voy a crear los overlays por cada arma en 3D
Graphics::CServer *server = Graphics::CServer::getSingletonPtr();
_overlayWeapon3D[current] = server->createOverlay( "_overlay3D"+strWeapon, _scene );
std::string modelWeapon = weapon->getStringAttribute("Model");
_graphicsEntities[current].graphicsEntity = _overlayWeapon3D[current]->add3D(strWeapon, modelWeapon,_graphicsEntities[current].offset);
assert(_graphicsEntities[current].graphicsEntity != 0 && "error al cargar la entidad grafica");
//_weaponsEntities[current] = _overlayWeapon3D[current]->add3D(currentOnText, modelWeapon, &offsetPositionWeapon);
_graphicsEntities[current].graphicsEntity->setOrientation(Math::setQuaternion(_graphicsEntities[current].defaultYaw, _graphicsEntities[current].defaultPitch, _graphicsEntities[current].defaultRoll));
_overlayWeapon3D[current]->setVisible(false);
_overlayWeapon3D[current]->setZBuffer(15);
/*/
std::string modelWeapon = weapon->getStringAttribute("Model");
_graphicsEntities[current].graphicsEntity = _scene->getCamera()->addEntityChild(strWeapon, modelWeapon, _graphicsEntities[current].offset);
// Este render queue se usa para simular los overlays. Poner en esta cola solo lo que queramos
// que se renderice como un overlay!!
_graphicsEntities[current].graphicsEntity->setRenderQueue(95);
// Esta mascara se utiliza para excluir el elemento del efecto de motion blur
_graphicsEntities[current].graphicsEntity->setVisibilityMask(1 << 0);
_graphicsEntities[current].graphicsEntity->setOrientation(Math::setQuaternion(_graphicsEntities[current].defaultYaw, _graphicsEntities[current].defaultPitch, _graphicsEntities[current].defaultRoll));
_graphicsEntities[current].graphicsEntity->setVisible(false);
/* */
}
//_overlayWeapon3D[WeaponType::eSOUL_REAPER]->setVisible(true);
_graphicsEntities[WeaponType::eSOUL_REAPER].graphicsEntity->setVisible(true);
if(!_graphicsEntities)
return false;
// Usamos un pequeño truco para calcular a la velocidad a la que tiene que incrementar
// el ruido de carga
// Primero obtenemos el tiempo máximo de carga del Iron Hell Goat
Map::CEntity* info = CEntityFactory::getSingletonPtr()->getInfo("ironHellGoat");
assert( info->hasAttribute("PrimaryFireLoadTime") );
// Una vez conocido el tiempo de carga, como sabemos que vamos a utilizar fixed ticks
// de 16 msecs, calculamos cuantos ticks van a pasar (aproximadamente) hasta que se
// tiene el arma cargada.
unsigned int nbTicks = (info->getIntAttribute("PrimaryFireLoadTime") * 1000) / 16;
// Calculamos el incremento de la velocidad distribuyendola uniformemente entre los
// ticks de carga
_unstableLoadAnim.speedInc = (_unstableLoadAnim.maxVerticalSpeed - _unstableLoadAnim.initVerticalSpeed) / (float)nbTicks;
_unstableLoadAnim.noiseInc = (_unstableLoadAnim.maxNoiseSpeed - _unstableLoadAnim.initNoiseSpeed) / (float)nbTicks;
return true;
} // spawn