void EnemyManager::Update()
{
for (int i = 0; i < m_enemies->size(); i++)
{
Enemy* e = m_enemies->at(i);
if (e->hp < 0)
{
delete e;
m_enemies->erase(m_enemies->begin() + i);
i--;
continue;
}
e->Update();
}
}
//================================================================================
// 生成処理
//================================================================================
Enemy* Enemy::create(const Vec2& pos,ENEMY_KIND nKindEnemy)
{
// インスタンスの生成
Enemy* pEnemy = new Enemy();
// メンバ変数の代入
pEnemy->m_pos = pos;
pEnemy->m_nEnemyKind = nKindEnemy;
// 初期化
pEnemy->init();
return pEnemy;
}
// Tests for Enemy
void testEnemySet(void) {
setUp();
Enemy *enemy = new Enemy();
enemy->set(*tileSet, 0, 0);
Sprite * testSprite = new Sprite();
testSprite->setTexture(*tileSet);
testSprite->setTextureRect(IntRect(0, 0, 1, 1));
TS_ASSERT_DELTA(enemy->dx, ENEMY_SPEED, 0.01);
TS_ASSERT(enemy->life);
delete enemy;
breakDown();
}
vector<Enemy*> CharacterFactory::parseXML(string xmlPath) {
// Read from file
XMLDocument doc;
doc.LoadFile(xmlPath.c_str());
// Text is just another Node to TinyXML-2. The more
// general way to get to the XMLText:
XMLElement *node = doc.FirstChildElement("enemies")->FirstChildElement("enemy")->ToElement();
for (node; node; node = node->NextSiblingElement())
{
Enemy* character = new Enemy();
character->parseXMLElement(node);
characters.push_back(character);
}
return characters;
}
/**
* \brief Returns whether the hero can be hurt by an attacker in this state.
* \param attacker an attacker that is trying to hurt the hero
* (or nullptr if the source of the attack is not an enemy)
* \return true if the hero can be hurt in this state
*/
bool Hero::RunningState::can_be_hurt(Entity* attacker) const {
if (phase == 0) {
// Preparing to run.
return true;
}
if (attacker != nullptr && attacker->get_type() == EntityType::ENEMY) {
// TODO move get_can_hurt_hero_running to Entity.
Enemy* enemy = static_cast<Enemy*>(attacker);
return enemy->get_can_hurt_hero_running();
}
return false;
}
// Public for enemy to call - handle bullet collision and damage applying
void Player::HandleBullets(Enemy& e)
{
if (!e.IsSpawned())
return;
for (int i = 0; i < m_Bullets.size(); i++)
{
if (e.DetectBulletCollision(m_Bullets[i]))
{
e.ApplyDamage(2);
m_Bullets.erase(m_Bullets.begin() + i);
i--;
continue;
}
}
}
Enemy* Enemy::nodeWithTheGame(HelloWorld* game)
{
Enemy *pRet = new Enemy();
if (pRet && pRet->initWithTheGame(game))
{
pRet->autorelease();
return pRet;
}
else
{
delete pRet;
pRet = NULL;
return NULL;
}
}
EnemyManager::EnemyManager(char* filename, Ogre::SceneManager* _inMgr, Blocks* block_ent)
{
vData.clear();
vEnemy.clear();
ReadXmlEnemyData(filename);
for (int i = 0; i < vData.size(); i++) {
Ogre::Vector3 startPos = Ogre::Vector3(vData[i].x, vData[i].y, vData[i].z);
Ogre::Vector3 pos = block_ent->absToRealPos(startPos);
Enemy* enemy = new Enemy(_inMgr, Ogre::Vector3(pos.x, pos.y-25, pos.z), startPos);
vEnemy.push_back(enemy);
enemy->Initialize();
enemy->InitCmdVector(vData[i].vCmd);
}
}
Enemy* Enemy::create ( KDuint uType )
{
Enemy* pRet = new Enemy ( );
if ( pRet && pRet->init ( uType ) )
{
pRet->autorelease ( );
}
else
{
CC_SAFE_DELETE ( pRet );
}
return pRet;
}
//////// Boss moves down into game screen ////////
//////// then begins its attack run ////////
void AI::enemyBossUpdate(Enemy &enemy, const float dt)
{
// Move into game screen
if (enemy.getPosition() < D3DXVECTOR3(0.0f, 20.0f, 0.0f)) // TODO: Modify for constant Y position value
{
D3DXVECTOR3 vel = D3DXVECTOR3(0.0f, -5.0f, 0.0f);
enemy.setVelocity(vel);
// Uncomment if needed
//enemy.setPosition(enemy.getPosition() += vel * dt);
}
else
{
// Begin attack run
// Fire bullets
float bFireRate = enemy.getBulletFireRate();
enemy.setBulletFireRate(bFireRate -= dt);
if (bFireRate <= 0.0f)
{
float x = -20.0f;
for (int i = 0; i < 4; i++)
{
enemy.fireBullet(D3DXVECTOR3(x, -20.0f, 0.0f));
x += 10.0f;
}
enemy.setBulletFireRate(1.0f);
}
// Fire missiles
float missFireRate = enemy.getMissileFireRate();
enemy.setMissileFireRate(missFireRate -= dt);
if (missFireRate <= 0.0f)
{
enemy.fireMissile(D3DXVECTOR3(0.0f, -20.0f, 0.0f));
enemy.setMissileFireRate(10.0f);
}
// Fire mines
// Cannot specify where to drop mine
// Mines are listed as a pickup, are they intended to be picked up by the player?
/*float mineFireRate = enemy.getMineFireRate();
enemy.setMineFireRate(mineFireRate -= dt);
if (mineFireRate <= 0.0f)
{
}*/
}
}
void LevelGenerator::spawnEnemy(core::Siika2D *siika, int xPos, int yPos)
{
Enemy *e;
bool fly = false;
if (lrand48() % 3 == 0)
fly = true;
int frames = 0;
int speed = 200;
if (fly)
{
if (generatorName == "castle")
e = new Enemy("sprite_mikucopter.png");
else if (generatorName == "plains")
e = new Enemy("sprite_noodles.png");
else
{
e = new Enemy("sprite_shibat.png");
yPos += 80;
}
}
else
{
if (generatorName == "castle")
e = new Enemy("sprite_meido.png");
else if (generatorName == "forest")
e = new Enemy("sprite_shimapanda.png");
else
{
e = new Enemy("sprite_gigapuddi.png", true);
speed = 100;
frames = 8;
}
}
e->init(siika, 0, frames, speed);
e->xPos = xPos;
e->yPos = yPos;
e->yLevel = e->yPos;
if (fly)
e->flies = true;
e->go->move(glm::vec2(e->xPos, e->yPos));
enemies.push_back(e);
}
Enemy* Enemy::create(CCPoint position, const char* fileName)
{
//エネミー生成
Enemy* enemy = new Enemy();
if (enemy)
{
enemy->initEnemy(position, fileName);
enemy->autorelease();
GAME::getInstance()->addChild(enemy, kTag_Enemy, kOrder_Enemy);
return enemy;
}
//autoreleaseを使用しているため、deleteの代わりに使用、メモリを開放
//何度も生成しないようにガードをかける
CC_SAFE_DELETE(enemy);
return NULL;
}
// Attempt to fire at enemy; return true if destroyed
bool Tower::Fire(Enemy &enemy, vector <Bullet> &Shots)
{
if (reloadTime <= 0)
{
double dx, dy, towerX, towerY, enemyX, enemyY;
towerX = (gridX + .5)*TILESIZE;
towerY = (gridY + .5)*TILESIZE;
enemyX = enemy.x + .5*TILESIZE;
enemyY = enemy.y + .5*TILESIZE;
dx = enemyX - towerX;
dy = enemyY - towerY;
if (dx*dx + dy*dy <= range*range)
{
double angle = atan2(dy, dx)/M_PI + 1;
direction = (int)((4*(angle))+6.5)%8;
reloadTime+=1./rate;
angle = (direction+2)*M_PI/4;
int bulletX = towerX - TILESIZE*cos(angle)/2;
int bulletY = towerY - TILESIZE*sin(angle)/2;
Shots.push_back(Bullet(bulletX, bulletY,
enemyX, enemyY));
if (enemy.damage(power))
{
return true;
}
}
}
return false;
};
double Player::update(const Enemy& enemy) {
vec3 el = enemy.getLoc();
vel += (el-loc).norm() * 6000 / (pow((el-loc).abs(),1.83)+80);
if((el-loc).abs() < 250) return 0.005;
return 0;
}
/**
* \brief This function is called when an enemy's sprite collides with a sprite of this entity.
* \param enemy the enemy
* \param enemy_sprite the enemy's sprite that overlaps the hero
* \param this_sprite the arrow sprite
*/
void Hookshot::notify_collision_with_enemy(
Enemy& enemy, Sprite& enemy_sprite, Sprite& /* this_sprite */) {
if (!overlaps(get_hero())) {
enemy.try_hurt(EnemyAttack::HOOKSHOT, *this, &enemy_sprite);
}
}
Enemy* Stage::popZako()
{
float zakoY = RandomHelper::random_real<float>(140, 400);
//Enemyクラスのポインタ変数enemyを作る
Enemy *zakoenemy = ZakoEnemy::create();
//enemyをX540,Y240の位置にセットする
zakoenemy->setPosition(Vec2(600, zakoY));
//取得したenemyのテクスチャに対して設定を与えている
zakoenemy->getTexture()->setAliasTexParameters();
//enemyの表示サイズを2倍にする
zakoenemy->setScale(2.0f);
CocosDenshion::SimpleAudioEngine::getInstance()->playEffect("sounds/pop_se.wav");
//戻り値にzakoenemyを返す
return zakoenemy;
}
int main()
{
Enemy enemy;
Boss boss;
cout << "Enemy: " << endl;
enemy.Attack();
cout << endl;
cout << "Boss: " << endl;
boss.Attack();
boss.MegaAttack();
return 0;
}
/**
* \brief This function is called when an enemy's sprite collides with a sprite of this entity.
* \param enemy the enemy
* \param enemy_sprite the enemy's sprite that overlaps the hero
* \param this_sprite the arrow sprite
*/
void Arrow::notify_collision_with_enemy(
Enemy& enemy, Sprite& enemy_sprite, Sprite& this_sprite) {
if (!overlaps(hero) && is_flying()) {
enemy.try_hurt(ATTACK_ARROW, *this, &enemy_sprite);
}
}
Enemy* Enemy::create(const std::string & filename)
{
Enemy* pSprite = new Enemy();
if (pSprite->initWithFile(filename))
{
pSprite->autorelease();
pSprite->initOptions();
return pSprite;
}
CC_SAFE_DELETE(pSprite);
return NULL;
}
int GameScene::addNewEnemyByLevel(int lvl){
float dropTime = 1 + ((lvl-1)/4);
auto wSize = Director::getInstance()->getWinSize();
int quantity = GameScene::hardControlForNumByLvl(lvl);
int start = 0;
int end = 8;
int total = abs(end - start);
if (quantity >total) {
CCLOG("随机数错误");
}
int sequence[total]; //存放随机数的数组
int output[quantity]; //最终生成的不重复一系列随机数
//将sequence 初始化
for (int i = 0; i < total; i++) {
sequence[i] = start+i;
}
//随机数种子
timeval psv;
gettimeofday(&psv, NULL);
unsigned seed = (unsigned)psv.tv_sec*1000 + (unsigned)psv.tv_usec/1000;
srand(seed);
for (int i = 0; i < quantity; i++) {
Enemy * obj = Enemy::create();
int weight = GameScene::hardControlForCountByLvl(lvl);
obj->setEnemyWeight(weight);
log("zhongzi:%d",(end-start+1)+start);
int num = CCRANDOM_0_1()*end;//在指定范围下产生随机数
output[i] = sequence[num];//将产生的随机数存储
sequence[num] = sequence[end-1];//将最后个下标的值填充到随机产生的下标中
end--;//在指定范围 向前移
Sprite *em = obj->createEnemy();
auto width = em->getContentSize().width;
float f = output[i]*width+width*.5f;
em->setPosition(f, wSize.height+80);
// log("--%d--%.2f- %.2f-",output[i],f,width);
this->addChild(em,i+100);
GameScene::startDrop(20/dropTime+5*(weight-1), em, false);
curWave.pushBack(obj);
curEnWave.pushBack(em);
}
return waveCount;
}
size_t EnemyManager::loadEnemyPrototype(const std::string& type_id) {
for (size_t i = 0; i < prototypes.size(); i++) {
if (prototypes[i].type == type_id) {
return i;
}
}
Enemy e = Enemy();
e.eb = new BehaviorStandard(&e);
e.stats.load(type_id);
e.type = type_id;
if (e.stats.animations == "")
Utils::logError("EnemyManager: No animation file specified for entity: %s", type_id.c_str());
loadAnimations(&e);
e.loadSounds();
// set cooldown_hit to duration of hit animation if undefined
if (e.stats.cooldown_hit == -1) {
Animation *hit_anim = e.animationSet->getAnimation("hit");
if (hit_anim) {
e.stats.cooldown_hit = hit_anim->getDuration();
delete hit_anim;
}
else {
e.stats.cooldown_hit = 0;
}
}
prototypes.push_back(e);
size_t prototype = prototypes.size() - 1;
for (size_t i = 0; i < e.stats.powers_ai.size(); i++) {
int power_index = e.stats.powers_ai[i].id;
const std::string& spawn_type = powers->powers[power_index].spawn_type;
if (power_index != 0 && spawn_type != "" && spawn_type != "untransform") {
std::vector<Enemy_Level> spawn_enemies = enemyg->getEnemiesInCategory(spawn_type);
for (size_t j = 0; j < spawn_enemies.size(); j++) {
loadEnemyPrototype(spawn_enemies[j].type);
}
}
}
return prototype;
}
void EnemyGenerator::GenerateEnemy()
{
Enemy* enemy;
// Get all the % values for the colors
vector<float> allColorKeys = KeysInVector(allColorTypeChances);
float colorTypeChance = randomPourcentageGenerator();
//Get a random key from the Vector of keys and use it to get it's paired color enum
Enemy::ColorType color = allColorTypeChances[GetEnumKey(allColorKeys, colorTypeChance)];
// Create proper enemy depending on color
switch (color)
{
case Enemy::green:
enemy = GreenEnemy::Create();
break;
case Enemy::orange:
enemy = OrangeEnemy::Create();
break;
case Enemy::red:
enemy = RedEnemy::Create();
break;
default:
break;
}
enemy->color = color;
// Same concept for color but with the shape
vector<float> allShapeKeys = KeysInVector(allShapeTypeChances);
float shapeTypeChance = randomPourcentageGenerator();
enemy->shape = allShapeTypeChances[GetEnumKey(allShapeKeys, shapeTypeChance)];
enemy->enemySprite = Sprite::create(textBank->enemyTexture);
enemy->enemySprite->setTag(ENEMY_TAG);
// Used for referencing object to delete
enemy->enemySprite->setUserData(enemy);
// Find the proper rect on the enemy spritesheat
enemy->SetupEnemySpriteRect(enemy);
// Apply proper collider geometry
enemy->SetupCollisionShape(enemy);
// Move above the screen with random X pos
enemy->SetStartingPos(enemy->enemySprite);
enemyLayer->addChild(enemy->enemySprite);
enemy->Activate();
}
void Game::init(const WorldMap& _world_map, IntPoint selected_chunk) {
world_map = _world_map;
//Give me a buffer size of 150x300 (tiles, which are 8x16 pixels)
//The buffer is what the screen draws from.
buffer = TilePointerMatrix(CHUNK_HEIGHT * 3, vector<Tile*>(CHUNK_WIDTH * 3));
character_index = std::vector<std::vector<Character*> >(CHUNK_HEIGHT * 3, std::vector<Character*>(CHUNK_WIDTH * 3));
clear_character_index();
//Each chunk holds an overworld and several
//dungeons, which are generated upon chunk creation.
//This is the "starting" chunk (arbitrary).
//TODO put this clutter somewhere else
int main_stat_array[NUM_STATS] = {100, 2, 100, 0, 1, 10, 10, 10};
std::vector<int> main_stats(&main_stat_array[0], &main_stat_array[0] + NUM_STATS);
main_char = Character(main_stats, 50, 25, Tileset::get("MAIN_CHAR"), misc::player_corpse, selected_chunk.col, selected_chunk.row, 0, 0, 70, -1, "You!", weapons::fist);
main_char.add_item(new Consumable(main_char.get_chunk(), consumables::potato));
main_char.add_item(new Weapon(main_char.get_chunk(), weapons::wood_axe));
Enemy* wolf = new Enemy(49, 25, 0, enemies::wolf_companion);
wolf->set_master(&main_char);
wolf->set_chunk(main_char.get_chunk());
character_list.push_back(wolf);
character_queue.push_back(wolf);
character_to_index(wolf);
IntPoint buffer_coords = get_buffer_coords(main_char.get_chunk(), main_char.get_coords());
character_index[buffer_coords.row][buffer_coords.col] = &main_char;
// Out of bounds tiles look like a generic BLOCK_WALL.
buffer_tile_placeholder=Tileset::get("BLOCK_WALL");
//What gets drawn to the screen
canvas = TilePointerMatrix(GAME_HEIGHT, vector<Tile*>(GAME_WIDTH));
//Eventually, this should be based on screen size.
chunk_map = ChunkMatrix(3, selected_chunk, world_map.get_map(), name);
update_buffer(main_char.get_chunk());
recalculate_visibility_lines(15);
refresh();
visibility_on = true;
initialized = true;
}
void Game::Update( void* gameInst, Entity** entities, int startIndex, int numEntities, double deltaTime )
{
Game* game = (Game*)gameInst;
int maxIndex = startIndex + numEntities;
for (int i = startIndex; i < maxIndex; ++i)
{
Enemy* enemy = dynamic_cast<Enemy*>(entities[i]);
Player* player = dynamic_cast<Player*>(entities[i]);
if (enemy)
{
if ( (enemy->behavior.tasks[enemy->currentTaskIndex])->DoTask( enemy, deltaTime ) )
{
enemy->currentTaskIndex = (enemy->currentTaskIndex + 1) % enemy->behavior.tasks.size();
}
enemy->Update( deltaTime );
}
else if (player)
{
float horizontalSpeed = 0;
float verticalSpeed = 0;
if (Input::InputDown(KeyCode::KEY_W))
{
verticalSpeed = -1;
}
else if (Input::InputDown(KeyCode::KEY_S))
{
verticalSpeed = 1;
}
if (Input::InputDown(KeyCode::KEY_D))
{
horizontalSpeed = 1;
}
else if (Input::InputDown(KeyCode::KEY_A))
{
horizontalSpeed = -1;
}
player->MoveVertically(verticalSpeed);
player->MoveHorizontally(horizontalSpeed);
}
}
}
/**
* \brief This function is called when this carried item collides an enemy.
* \param enemy the enemy
*/
void CarriedItem::notify_collision_with_enemy(Enemy &enemy) {
if (is_throwing
&& !can_explode()
&& get_damage_on_enemies() > 0) {
enemy.try_hurt(EnemyAttack::THROWN_ITEM, *this, nullptr);
}
}
bool tick(){
for(unsigned int i=0; i<velocity; i++){ // TODO: Put here new enemies with RoundsManager
auto it1 = enemies.begin();
while(it1 != enemies.end()){
bool lost = life<=0;
Enemy* e = *it1;
if(e->tick()){
life -= e->getDamage();
delete e;
it1 = enemies.erase(it1);
}else it1++;
if(life<=0 && !lost){
money = 0;
clearEntities();
for(Tower* t:towers){
entities.push_back(new ExplosionEntity(getRealPosition(t->getPosition()), pixelsPerSquare, 200));
}
clearTowers();
}
}
auto it2 = entities.begin();
while(it2 != entities.end()){
Entity* e = *it2;
if(e->tick()){
delete e;
it2 = entities.erase(it2);
}else it2++;
}
for(Tower* t : towers){
t->tick();
}
if(life>0){
if(tickCount%400 == 1)
enemies.push_back(new InhibitorEnemy(1.0, 30+tickCount/500, 1));
else if(tickCount%20 == 1)
enemies.push_back(new BasicEnemy(1.0 + (double)(rand()%10)/10.0, 15+tickCount/500, 1));
}
++tickCount;
}
return false;
}
/**
* @brief This function is called when this carried item collides an enemy.
* @param enemy the enemy
*/
void CarriedItem::notify_collision_with_enemy(Enemy &enemy) {
if (is_throwing
&& !can_explode()
&& get_damage_on_enemies() > 0) {
enemy.try_hurt(ATTACK_THROWN_ITEM, *this, NULL);
}
}
void CheckEnemyHits(){
for(int i=0;i < enemies.size(); i++){
hgeRect* enemyBox;
Enemy* enemy = enemies.at(i);
enemyBox = enemy->getBoundingBox();
for(int j=0; j < players.size(); j++){
hgeRect* playerBox;
Player* player = players.at(j);
if (!player->getInvulnerable()) {
playerBox = player->getBoundingBox();
if (enemyBox->Intersect(playerBox)){
gameActive = false;
}
}
}
}
}
/**
* \brief Attacks the specified enemy if possible.
*
* This function is called by this explosion when it detects an enemy, or by an enemy who detects this explosion.
*
* \param enemy the enemy to attack
* \param enemy_sprite the enemy's sprite detected by the explosion
*/
void Explosion::try_attack_enemy(Enemy& enemy, Sprite& enemy_sprite) {
// see if the enemy was already hurt by this explosion
auto it = std::find(victims.begin(), victims.end(), &enemy);
if (it == victims.end()) {
enemy.try_hurt(EnemyAttack::EXPLOSION, *this, &enemy_sprite);
}
}
void Wave::remove_defeated_enemies()
{
std::list<Enemy*>::iterator it = enemies.begin();
for(unsigned int i = 0 ; i < enemies.size() ; i++){
Enemy *en = *it;
if(en->has_died()){
delete en;
it = enemies.erase(it);
}
else{
it++;
}
}
}
