Object::Object(Sint16 xcord, Sint16 ycord, const ParameterMap& param): parameters(param), state(NOTHING), event(NULL), otype(OTYPE_COMMON), delete_flag(false) { onum=++scenario->max_obj_num; /* Parameters */ if (hasParam(parameters,"anim")) { ParameterMap anim_param=getParameters(parameters["anim"],':'); anim_orig=loadAnimation(anim_param); } else if (hasParam(parameters,"image")) { ParameterMap anim_param; anim_param["image"]=parameters["image"]; anim_param["image_hor_frames"]="1"; anim_orig=loadAnimation(anim_param); } else anim_orig=EmptyAnimationPtr(new EmptyAnimation()); if (hasParam(parameters,"name")) name=parameters["name"]; else name="Object"; if (hasParam(parameters,"w")) pos.w=atoi(parameters["w"].c_str()); else if (anim_orig->isValid()) pos.w=anim_orig->getFrameDim().w; else pos.w=(Uint16)(DATA_LVLPLAYER_W*sqrt(config.lvlscale>=0 ? config.lvlscale : -1/config.lvlscale)+0.5); if (hasParam(parameters,"h")) pos.h=atoi(parameters["h"].c_str()); else if (anim_orig->isValid()) pos.h=anim_orig->getFrameDim().h; else pos.h=(Uint16)(DATA_LVLPLAYER_H*sqrt(config.lvlscale>=0 ? config.lvlscale : -1/config.lvlscale)+0.5); pos.x=xcord; pos.y=ycord; animation=anim_orig; }
Erik::Erik(Sint16 xcord, Sint16 ycord, const ParameterMap& param): Player(xcord,ycord,param), jump(V_JUMP), jump2(V_JUMP2) { weapon=Weapon(-1,W_PRESSURE,WS_PRESSURE); /* Parameters */ if (hasParam(parameters,"anim_erik_jump_left")) anim_erik_jump_left=loadAnimation(getParameters(parameters["anim_erik_jump_left"],':')); if (hasParam(parameters,"anim_erik_jump_right")) anim_erik_jump_right=loadAnimation(getParameters(parameters["anim_erik_jump_right"],':')); if (hasParam(parameters,"anim_erik_jump2_left")) anim_erik_jump2_left=loadAnimation(getParameters(parameters["anim_erik_jump2_left"],':')); if (hasParam(parameters,"anim_erik_jump2_right")) anim_erik_jump2_right=loadAnimation(getParameters(parameters["anim_erik_jump2_right"],':')); if (hasParam(parameters,"anim_erik_start_run_left")) anim_erik_start_run_left=loadAnimation(getParameters(parameters["anim_erik_start_run_left"],':')); if (hasParam(parameters,"anim_erik_start_run_right")) anim_erik_start_run_right=loadAnimation(getParameters(parameters["anim_erik_start_run_right"],':')); if (hasParam(parameters,"anim_erik_run_left")) anim_erik_run_left=loadAnimation(getParameters(parameters["anim_erik_run_left"],':')); if (hasParam(parameters,"anim_erik_run_right")) anim_erik_run_right=loadAnimation(getParameters(parameters["anim_erik_run_right"],':')); if (hasParam(parameters,"anim_erik_swim_left")) anim_erik_swim_left=loadAnimation(getParameters(parameters["anim_erik_swim_left"],':')); if (hasParam(parameters,"anim_erik_swim_right")) anim_erik_swim_right=loadAnimation(getParameters(parameters["anim_erik_swim_right"],':')); if (hasParam(parameters,"anim_erik_swim_up_left")) anim_erik_swim_up_left=loadAnimation(getParameters(parameters["anim_erik_swim_up_left"],':')); if (hasParam(parameters,"anim_erik_swim_up_right")) anim_erik_swim_up_right=loadAnimation(getParameters(parameters["anim_erik_swim_up_right"],':')); if (hasParam(parameters,"anim_erik_hit_water_left")) anim_erik_hit_water_left=loadAnimation(getParameters(parameters["anim_erik_hit_water_left"],':')); if (hasParam(parameters,"anim_erik_hit_water_right")) anim_erik_hit_water_right=loadAnimation(getParameters(parameters["anim_erik_hit_water_right"],':')); if (!hasParam(parameters,"audio_hit")) au_hit=scenario->sndcache->loadWAV("erikhit.wav"); if (hasParam(parameters,"audio_jump")) au_jump=scenario->sndcache->loadWAV(parameters["audio_jump"]); else au_jump=scenario->sndcache->loadWAV("rboots.wav"); if (hasParam(parameters,"audio_run")) au_jump=scenario->sndcache->loadWAV(parameters["audio_run"]); else au_run=NULL; }
bool EnemyTool::loadAnimations(std::string graphicpath, std::string fname) { SpriteMap* gfx = ((SpriteMap*) graphic); int nCols = 0, nRows = 0; // Carga el archivo de config y lee FILE* f = fopen(fname.c_str(), "rb"); // Si el archivo es inválido, no se puede hacer nada if (f == NULL) return false; // 1. Ancho y alto de imagen (?) if (fscanf(f, "%d %d", &nCols, &nRows) < 2) return false; // creamos el gráfico de la herramienta graphic = new SpriteMap(graphicpath, nCols, nRows, game->getGfxEngine()); // 2. Leer las animaciones loadAnimation(UP, "up", f); loadAnimation(DOWN, "down", f); loadAnimation(LEFT, "left", f); loadAnimation(RIGHT, "right", f); fclose(f); return true; }
Baleog::Baleog(Sint16 xcord, Sint16 ycord, const ParameterMap& param): Player(xcord,ycord,param) { weapon=Weapon(-1,W_STRIKE); /* Parameters */ if (hasParam(parameters,"anim_baleog_sword_left")) anim_baleog_sword_left=loadAnimation(getParameters(parameters["anim_baleog_sword_left"],':')); else anim_baleog_sword_left=loadAnimation(scenario->imgcache->loadImage(8,"BaleogCyborg_Slash_left.png"),8,BP_MD,ATYPE_ONCE); if (hasParam(parameters,"anim_baleog_sword_right")) anim_baleog_sword_right=loadAnimation(getParameters(parameters["anim_baleog_sword_right"],':')); else anim_baleog_sword_right=loadAnimation(scenario->imgcache->loadImage(8,"BaleogCyborg_Slash_right.png"),8,BP_MD,ATYPE_ONCE); if (hasParam(parameters,"audio_sword")) au_sword=scenario->sndcache->loadWAV(parameters["audio_sword"]); else au_sword=scenario->sndcache->loadWAV("swrdsw2.wav"); }
Zombie::Zombie(Sint16 xcord, Sint16 ycord, const ParameterMap& param): Monster(xcord,ycord,param), T_Attack_Bite(1500) { weapon=Weapon(-1,W_STRIKE); /* Parameters */ if (!hasParam(parameters,"anim_left")) anim_left=loadAnimation(scenario->imgcache->loadImage(2,"olaf1_left.bmp"),2,BP_MD,ATYPE_LOOP,2); if (!hasParam(parameters,"anim_right")) anim_right=loadAnimation(scenario->imgcache->loadImage(2,"olaf1_right.bmp"),2,BP_MD,ATYPE_LOOP,2); if (!hasParam(parameters,"maxspeedx")) maxspeedx=80; if (hasParam(parameters,"audio_attack")) au_attack=scenario->sndcache->loadWAV(parameters["audio_attack"]); else au_attack=scenario->sndcache->loadWAV("clang.wav"); }
bool RoleShow::init() { bool bRet = false; if(!CCNode::init()) { return bRet; } m_location = CCPointZero; m_size = CCSizeZero; bulletSpeed = 10; heroAngle = 2; m_blackBullet = 0; m_ironmanBullet = 0; m_ironmanBulletTwo = 0; wolfBullectIndex = 0; pFiregun = NULL; epIndexOrien = true; loadAnimation(); schedule(schedule_selector(RoleShow::process)); schedule(schedule_selector(RoleShow::roleChangeAngle),0.037f); schedule(schedule_selector(RoleShow::addBullet),0.3); bRet = true; return bRet; }
void AnimatedModel::load(const std::string & file) { LuaScript script(file); loadImage(script); loadTexturePack(script); loadAnimation(script); setUp(); }
void EffectManager::addEffect(EffectDef &effect, int duration, int magnitude, bool item, int trigger, int passive_id, int source_type) { int effect_type = getType(effect.type); // if we're already immune, don't add negative effects if (immunity_damage && (effect_type == EFFECT_DAMAGE || effect_type == EFFECT_DAMAGE_PERCENT)) return; else if (immunity_slow && effect_type == EFFECT_SPEED && magnitude < 100) return; else if (immunity_stun && effect_type == EFFECT_STUN) return; else if (immunity_knockback && effect_type == EFFECT_KNOCKBACK) return; // only allow one knockback effect at a time if (effect_type == EFFECT_KNOCKBACK && knockback_speed != 0) return; for (size_t i=effect_list.size(); i>0; i--) { if (effect_list[i-1].name == effect.id) { if (trigger > -1 && effect_list[i-1].trigger == trigger) return; // trigger effects can only be cast once per trigger if (!effect.can_stack) removeEffect(i-1); } // if we're adding an immunity effect, remove all negative effects if (effect_type == EFFECT_IMMUNITY) clearNegativeEffects(); else if (effect_type == EFFECT_IMMUNITY_DAMAGE) clearNegativeEffects(EFFECT_IMMUNITY_DAMAGE); else if (effect_type == EFFECT_IMMUNITY_SLOW) clearNegativeEffects(EFFECT_IMMUNITY_SLOW); else if (effect_type == EFFECT_IMMUNITY_STUN) clearNegativeEffects(EFFECT_IMMUNITY_STUN); else if (effect_type == EFFECT_IMMUNITY_KNOCKBACK) clearNegativeEffects(EFFECT_IMMUNITY_KNOCKBACK); } Effect e; e.name = effect.id; e.icon = effect.icon; e.type = effect_type; e.render_above = effect.render_above; if (effect.animation != "") { anim->increaseCount(effect.animation); e.animation = loadAnimation(effect.animation); e.animation_name = effect.animation; } e.ticks = e.duration = duration; e.magnitude = e.magnitude_max = magnitude; e.item = item; e.trigger = trigger; e.passive_id = passive_id; e.source_type = source_type; effect_list.push_back(e); }
void setAnimation(ComponentHandle cmp, const Path& path) { auto& animable = m_animables[{cmp.index}]; unloadAnimation(animable.animation); animable.animation = loadAnimation(path); animable.time = 0; }
Barrel::Barrel(Ogre::Vector3 position, Ogre::Quaternion orientation, const std::string& name, Ogre::SceneNode* sceneNode, Ogre::Real speed, Ogre::Radian turnSpeed, Ogre::Entity& entityMesh) : MovableEntity(position, orientation, name, sceneNode, speed, turnSpeed), selected(false), node(NULL) { animation = NULL; loadAnimation(); for(unsigned int i = 0; i < numModels; ++i) { modelNodes.push_back(sceneNode); animationState = entityMesh.getAnimationState("Sneak"); animationState->setEnabled(true); animationState->setLoop(true); animationSpeeds.push_back(Ogre::Real(1.5f)); animationStates.push_back(animationState); } std::string selectid = Factory::getID() + "." + name + "/selected"; Ogre::Entity* pointerMesh = Game::getScene()->createEntity(selectid, "target.mesh"); pointerMesh->setMaterialName("target"); node = sceneNode->createChildSceneNode(); node->attachObject(pointerMesh); node->setVisible(selected); node->setPosition(position); }
void EffectManager::addEffect(std::string id, int icon, int duration, int magnitude, std::string type, std::string animation, bool additive, bool item, int trigger, bool render_above, int passive_id, int source_type) { // if we're already immune, don't add negative effects if (immunity) { if (type == "damage") return; else if (type == "speed" && magnitude < 100) return; else if (type == "stun") return; } // only allow one forced_move effect // TODO remove this limitation if (forced_move) { if (type == "forced_move") return; } for (unsigned i=0; i<effect_list.size(); i++) { if (effect_list[i].id == id) { if (trigger > -1 && effect_list[i].trigger == trigger) return; // trigger effects can only be cast once per trigger if (effect_list[i].duration <= duration && effect_list[i].type != "death_sentence") { effect_list[i].ticks = effect_list[i].duration = duration; if (effect_list[i].animation) effect_list[i].animation->reset(); } if (effect_list[i].duration > duration && effect_list[i].type == "death_sentence") { effect_list[i].ticks = effect_list[i].duration = duration; if (effect_list[i].animation) effect_list[i].animation->reset(); } if (additive) break; // this effect will stack if (effect_list[i].magnitude_max <= magnitude) { effect_list[i].magnitude = effect_list[i].magnitude_max = magnitude; if (effect_list[i].animation) effect_list[i].animation->reset(); } return; // we already have this effect } // if we're adding an immunity effect, remove all negative effects if (type == "immunity") { clearNegativeEffects(); } } Effect e; e.id = id; e.icon = icon; e.ticks = e.duration = duration; e.magnitude = e.magnitude_max = magnitude; e.type = type; e.item = item; e.trigger = trigger; e.render_above = render_above; e.passive_id = passive_id; e.source_type = source_type; if (animation != "") { anim->increaseCount(animation); e.animation = loadAnimation(animation); e.animation_name = animation; } effect_list.push_back(e); }
void GargoyleEnemy::setSummoned(int strength, int damage, int count, const sf::Time& ttl) { m_isSummoned = true; m_spellStrength = strength; m_spellCount = count; m_spellAdditionalDamage = damage; loadSpells(); loadAnimation(m_spellStrength - 1); setAlly(ttl); }
bool MD5Animation::init(const char* filename) { if (!loadAnimation(filename)) { return false; } shutDownAnimation(); return true; }
EmptyAnimationPtr Object::loadAnimation(string anim_name, double scale_factor, BasePointType abp_type, Uint16 aanimation_type, double afps, AllignType aallign_type) { /* Parse animation data file */ ifstream file; string tmpline; string loadfile=config.datadir+config.anim_file; file.open(loadfile.c_str()); if (!file) { cout << "Failed to open the animation data file: " << loadfile << " => Couldn't load " << anim_name << " animation!\n" << endl; return EmptyAnimationPtr(new EmptyAnimation()); } else { string arg1,arg2,arg3,arg4,arg5,arg6; string tmp_anim_name=""; string imagename=""; Uint16 astart_pos=0; Uint16 aframes=1; Uint16 description_type=DESC_NONE; while (getline(file,tmpline)) { arg1=arg2=arg3=arg4=arg5=arg6=""; std::istringstream tmpstream(tmpline); tmpstream >> arg1 >> arg2 >> arg3 >> arg4 >> arg5 >> arg6; if (arg1 == "DESCRIPTION") { description_type=DESC_NONE; } else if (arg1 == "ANIMATION") { if (arg2 == "LVLANIM") { description_type=DESC_ANIM_LVLANIM; } else { description_type=DESC_NONE; } } if (description_type==DESC_ANIM_LVLANIM) { if (arg1.empty() || arg2.empty() || arg3.empty() || arg4.empty()) { } else { tmp_anim_name=arg1; imagename=arg2; astart_pos=(Uint16)atoi(arg3.c_str()); aframes=(Uint16)atoi(arg4.c_str()); if (anim_name==tmp_anim_name) { return loadAnimation(imgcache->loadImage(imagename,scale_factor),aframes,abp_type,aanimation_type,afps,astart_pos,aallign_type); } } } } } cout << "Animation " << anim_name << " not found!" << endl; return EmptyAnimationPtr(new EmptyAnimation()); }
Loot::Loot(const Loot &other) { stack.item = other.stack.item; stack.quantity = other.stack.quantity; pos.x = other.pos.x; pos.y = other.pos.y; loadAnimation(other.gfx); animation->syncTo(other.animation); currency = other.currency; tip = other.tip; }
Loot::Loot(const Loot &other) { stack.item = other.stack.item; stack.quantity = other.stack.quantity; pos.x = other.pos.x; pos.y = other.pos.y; loadAnimation(other.gfx); animation->syncTo(other.animation); tip = other.tip; dropped_by_hero = other.dropped_by_hero; }
Bomb::Bomb(Sint16 xcord, Sint16 ycord, const ParameterMap& param): Item(xcord,ycord,param) { /* Parameters */ if (!hasParam(parameters,"image")) anim_orig=loadAnimation(scenario->imgcache->loadImage(1,"bomb_fire.bmp")); if (hasParam(parameters,"image_bomb")) triggered_bomb_param["image"]=parameters["image_bomb"]; else triggered_bomb_param["image"]="bomb_fire.bmp"; if (hasParam(parameters,"countdown")) triggered_bomb_param["countdown"]="3000"; else triggered_bomb_param["countdown"]=parameters["countdown"]; if (hasParam(parameters,"audio_bomb")) triggered_bomb_param["audio_bomb"]=parameters["audio_bomb"]; else triggered_bomb_param["audio_bomb"]="explsn.wav"; }
void Loader::loadAnimations() { if(m_pScene->HasAnimations ()) { for(int i =0;i<m_pScene->mNumAnimations;i++) { CMC_AnimateData * animate = new CMC_AnimateData(); animate->m_name = m_pScene->mAnimations[i]->mName.C_Str (); loadAnimation (m_pScene->mRootNode,i,animate); m_model->m_animates.push_back (animate); } } }
Loot::Loot(const Loot &other) { stack.item = other.stack.item; stack.quantity = other.stack.quantity; pos.x = other.pos.x; pos.y = other.pos.y; loadAnimation(other.gfx); if (animation) animation->syncTo(other.animation); tip = other.tip; dropped_by_hero = other.dropped_by_hero; on_ground = other.on_ground; sound_played = other.sound_played; }
ModelInterface::ModelInterface(TextureManager* manager, const QString filename) : has_animations(false) , meshes(0) , animations(0) , bones(0) , textureManager(manager) { if(filename.contains("/")) { int index = filename.lastIndexOf("/") + 1; filePath = filename.left(index); fileName = filename.right(filename.size() - index); } else fileName = filename; Assimp::Importer importer; importer.SetPropertyInteger(AI_CONFIG_PP_LBW_MAX_WEIGHTS, 4); const aiScene* scene = importer.ReadFile(filename.toStdString(), aiProcess_GenSmoothNormals | aiProcess_Triangulate | aiProcess_CalcTangentSpace/* | aiProcess_FlipUVs*/); if(!scene || scene->mFlags == AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) { throw QString("The file wasn't successfuly opened"); return; } if(scene->HasAnimations()) { has_animations = true; bones = loadBones(scene); buildSkeleton(scene->mRootNode, NULL); animations = new Animations(); animations->setBones(bones); for(uint i = 0; i < scene->mNumAnimations; ++i) animations->add(loadAnimation(scene->mAnimations[i], i)); } meshes = new Meshes(); for(uint i = 0; i < scene->mNumMeshes; ++i) meshes->add(loadMesh(scene->mMeshes[i], scene->mMaterials[scene->mMeshes[i]->mMaterialIndex], i)); initialize(scene); // try delete scene probably crash }
EffectManager& EffectManager::operator= (const EffectManager &emSource) { effect_list.resize(emSource.effect_list.size()); for (unsigned i=0; i<effect_list.size(); i++) { effect_list[i].id = emSource.effect_list[i].id; effect_list[i].icon = emSource.effect_list[i].icon; effect_list[i].ticks = emSource.effect_list[i].ticks; effect_list[i].duration = emSource.effect_list[i].duration; effect_list[i].type = emSource.effect_list[i].type; effect_list[i].magnitude = emSource.effect_list[i].magnitude; effect_list[i].magnitude_max = emSource.effect_list[i].magnitude_max; effect_list[i].item = emSource.effect_list[i].item; effect_list[i].trigger = emSource.effect_list[i].trigger; effect_list[i].render_above = emSource.effect_list[i].render_above; effect_list[i].passive_id = emSource.effect_list[i].passive_id; if (emSource.effect_list[i].animation_name != "") { effect_list[i].animation_name = emSource.effect_list[i].animation_name; anim->increaseCount(effect_list[i].animation_name); effect_list[i].animation = loadAnimation(effect_list[i].animation_name); } } damage = emSource.damage; hpot = emSource.hpot; mpot = emSource.mpot; speed = emSource.speed; immunity = emSource.immunity; stun = emSource.stun; forced_speed = emSource.forced_speed; forced_move = emSource.forced_move; revive = emSource.revive; convert = emSource.convert; death_sentence = emSource.death_sentence; fear = emSource.fear; bonus_offense = emSource.bonus_offense; bonus_defense = emSource.bonus_defense; bonus_physical = emSource.bonus_physical; bonus_mental = emSource.bonus_mental; for (unsigned i=0; i<STAT_COUNT; i++) { bonus[i] = emSource.bonus[i]; } triggered_others = emSource.triggered_others; triggered_block = emSource.triggered_block; triggered_hit = emSource.triggered_hit; triggered_halfdeath = emSource.triggered_halfdeath; triggered_joincombat = emSource.triggered_joincombat; triggered_death = emSource.triggered_death; return *this; }
Monster::Monster(Sint16 xcord, Sint16 ycord, const ParameterMap& param): Character(xcord,ycord,param), Dai(0), Dattack(0) { state=STATE_FALL; otype|=OTYPE_MONSTER; enemy_types|=OTYPE_PLAYER; dense_types|=OTYPE_PLAYER; /* Parameters */ if (hasParam(parameters,"anim_left")) anim_left=loadAnimation(getParameters(parameters["anim_left"],':')); else anim_left.reset(new EmptyAnimation(&anim_right)); if (hasParam(parameters,"anim_right")) anim_right=loadAnimation(getParameters(parameters["anim_right"],':')); else anim_right.reset(new EmptyAnimation(&anim_orig)); if (!hasParam(parameters,"maxhealth")) maxhealth=1; if (!hasParam(parameters,"health")) health=min(1,(int)maxhealth); if (!hasParam(parameters,"maxspeedx")) maxspeedx=50; if (!hasParam(parameters,"maxspeedy")) maxspeedy=0; if (hasParam(parameters,"audio_hit")) au_hit=scenario->sndcache->loadWAV(parameters["audio_hit"]); else au_hit=scenario->sndcache->loadWAV("monhit.wav"); animation.reset(new EmptyAnimation((state&STATE_LEFT) ? &anim_left : &anim_right)); }
void Loader::loadAnimation(const aiNode *pNode,int index,CMC_AnimateData * animate) { std::string NodeName(pNode->mName.data); if(!m_pScene->HasAnimations ()) { m_model->m_hasAnimation = false; return ; } const aiAnimation* pAnimation = m_pScene->mAnimations[index]; const aiNodeAnim * pNodeAnim = findNodeAnim(pAnimation, NodeName); if(pNodeAnim)//that node is a animation bone. { auto animateBone = new CMC_AnimateBone(); animateBone->m_boneName = NodeName; //load position key. for(int i =0;i<pNodeAnim->mNumPositionKeys;i++) { auto v = pNodeAnim->mPositionKeys[i]; CMC_TranslateKey key; key.time = v.mTime; key.trans = QVector3D (v.mValue.x,v.mValue.y,v.mValue.z); animateBone->addTranslate (key); } //load scale key for(int i =0;i<pNodeAnim->mNumScalingKeys;i++) { auto v = pNodeAnim->mScalingKeys[i]; CMC_ScaleKey key; key.time = v.mTime; key.scale = QVector3D (v.mValue.x,v.mValue.y,v.mValue.z); animateBone->addScale (key); } //load rotation key for(int i =0;i<pNodeAnim->mNumPositionKeys;i++) { auto v = pNodeAnim->mRotationKeys[i]; CMC_RotateKey key; key.time = v.mTime; key.rotate = QQuaternion(v.mValue.w,v.mValue.x,v.mValue.y,v.mValue.z); animateBone->addRotate (key); } animate->addAnimateBone (animateBone); animate->m_ticksPerSecond = pAnimation->mTicksPerSecond; animate->m_duration = pAnimation->mDuration; } for (uint i = 0 ; i < pNode->mNumChildren ; i++) { loadAnimation( pNode->mChildren[i],index,animate); } }
void states::setStates(int frames[], int maxFrames, int separator, int horizontal, int tileH, int tileW) { tileHeight = tileH; tileWidth = tileW; sep = separator; ht = horizontal; tilePos tmp; for(int i=0;i<maxFrames;i++) { //std::cout <<"SetSates |" << i << ":" << maxFrames << std::endl; //std::cout <<"frames |" << frames[i] << std::endl; loadAnimation(maxFrames,frames[i]); } }
void ComposerEngine::playAnimation(uint16 animId, int16 x, int16 y, int16 eventParam) { // First, we check if this animation is already playing, // and if it is, we sabotage that running one first. for (Common::List<Animation *>::iterator i = _anims.begin(); i != _anims.end(); i++) { Animation *anim = *i; if (anim->_id != animId) continue; stopAnimation(*i); } Animation *anim = NULL; loadAnimation(anim, animId, x, y, eventParam); _anims.push_back(anim); runEvent(kEventAnimStarted, animId, eventParam, 0); }
bool Enemy1::loadMedia(SDL_Renderer* gRenderer) { if (!LoadFromFile(path_.c_str(), gRenderer)) { printf("Failed to load walking animation texture!\n"); return false; } std::string animNames[] = { "WALLKING", "PUNCH", "FALLING" }; loadAnimation(animNames); destY = posY_; destX = posX_; return true; }
// The assignment operator mainly used in internal vector managing, // e.g. in vector::erase() Loot& Loot::operator= (const Loot &other) { if (gfx != "") anim->decreaseCount(gfx); delete animation; loadAnimation(other.gfx); animation->syncTo(other.animation); stack.item = other.stack.item; stack.quantity = other.stack.quantity; pos.x = other.pos.x; pos.y = other.pos.y; currency = other.currency; tip = other.tip; return *this; }
void EffectManager::addEffect(EffectDef &effect, int duration, int magnitude, bool item, int trigger, int passive_id, int source_type) { // if we're already immune, don't add negative effects if (immunity) { if (effect.type == "damage") return; else if (effect.type == "speed" && magnitude < 100) return; else if (effect.type == "stun") return; } for (unsigned i=effect_list.size(); i>0; i--) { if (effect_list[i-1].name == effect.name) { if (trigger > -1 && effect_list[i-1].trigger == trigger) return; // trigger effects can only be cast once per trigger if (!effect.can_stack) removeEffect(i-1); } // if we're adding an immunity effect, remove all negative effects if (effect.type == "immunity") { clearNegativeEffects(); } } Effect e; e.name = effect.name; e.icon = effect.icon; e.type = effect.type; e.render_above = effect.render_above; if (effect.animation != "") { anim->increaseCount(effect.animation); e.animation = loadAnimation(effect.animation); e.animation_name = effect.animation; } e.ticks = e.duration = duration; e.magnitude = e.magnitude_max = magnitude; e.item = item; e.trigger = trigger; e.passive_id = passive_id; e.source_type = source_type; effect_list.push_back(e); }
Stalfos::Stalfos(Point pos, bool canBeCollidedWith){ position = pos; width = Global::TileWidth; height = Global::TileHeight; isCollideable = canBeCollidedWith; loadAnimation(); isInvincible = false; healthPoint = 2; strength = 1; currentInvincibleFrame = 0; pushbackStep = 0; setupMask(&fullMask, width, height, sf::Color::Magenta); setupMask(&mask, width, height, sf::Color::Magenta); dir = Direction::None; getNextDirection(Direction::None); walkAnimIndex = 0; isParalyzed = false; currentParalyzeTime = 0; }
void SpriteDef::loadAction(XmlNodePtr node, int variant_offset) { const std::string actionName = XML::getProperty(node, "name", ""); const std::string imageSetName = XML::getProperty(node, "imageset", ""); const unsigned hp = XML::getProperty(node, "hp", 100); ImageSetIterator si = mImageSets.find(imageSetName); if (si == mImageSets.end()) { logger->log("Warning: imageset \"%s\" not defined in %s", imageSetName.c_str(), getIdPath().c_str()); return; } ImageSet *imageSet = si->second; if (actionName == SpriteAction::INVALID) { logger->log("Warning: Unknown action \"%s\" defined in %s", actionName.c_str(), getIdPath().c_str()); return; } Action *action = new Action; action->setNumber(hp); addAction(hp, actionName, action); // dirty hack to fix bad resources in tmw server if (actionName == "attack_stab") addAction(hp, "attack", action); // When first action set it as default direction Actions::const_iterator i = mActions.find(hp); if ((*i).second->size() == 1) addAction(hp, SpriteAction::DEFAULT, action); // Load animations for_each_xml_child_node(animationNode, node) { if (xmlNameEqual(animationNode, "animation")) loadAnimation(animationNode, action, imageSet, variant_offset); } }