static void statueAttack()
{
Entity *e;
self->thinkTime--;
if (self->thinkTime <= 0)
{
e = addEnemy("enemy/flame_statue", 0, 0);
e->health = 5;
e->layer = BACKGROUND_LAYER;
e->x = player.x + player.w / 2 - e->w / 2;
e->x -= player.w * 2;
e->mental = 0;
e->y = getMapFloor(self->x + self->w / 2, self->y);
e->targetY = e->y - e->h;
e->action = &statueRise;
e->touch = NULL;
e->thinkTime = 240;
e = addEnemy("enemy/flame_statue", 0, 0);
e->health = 5;
e->layer = BACKGROUND_LAYER;
e->x = player.x + player.w / 2 - e->w / 2;
e->x += player.w * 2;
e->mental = 1;
e->y = getMapFloor(self->x + self->w / 2, self->y);
e->targetY = e->y - e->h;
e->action = &statueRise;
e->touch = NULL;
e->thinkTime = 240;
self->thinkTime = 600;
self->action = &statueRiseWait;
}
hover();
}
void Enemies::createEnemy(int model, FLOAT x1, FLOAT y1, FLOAT z1, FLOAT x2, FLOAT y2, FLOAT z2, FLOAT x3, FLOAT y3, FLOAT z3, FLOAT x4, FLOAT y4, FLOAT z4, FLOAT scale, int speed, int collisionstype)
{
Enemy* newEnemy;
newEnemy = new Enemy();
XMMATRIX modelScale = XMMatrixScaling(scale, scale, -scale);
XMMATRIX modelRot = XMMatrixRotationY(0);
XMMATRIX modelOffset = XMMatrixTranslation(x1, y1, z1);
newEnemy->setModelScale(modelScale);
newEnemy->setModelRot(modelRot);
newEnemy->setModelOffset(modelOffset);
newEnemy->SetPositionOne(x1, y1, z1);
newEnemy->SetPositionTwo(x2, y2, z2);
newEnemy->SetPositionThree(x3, y3, z3);
newEnemy->SetPositionFour(x4, y4, z4);
if (model == simpleEnemy)
{
anEnemy = mSimpleEnemy;
}
else if (model == tractor)
{
anEnemy = mTractor;
}
newEnemy->setModel(anEnemy);
newEnemy->setScale(scale);
newEnemy->setSpeed(speed);
newEnemy->setcollisiontype(collisionstype);
BasicModelInstance oneEnemy;
theEnemy.Model = anEnemy;
XMStoreFloat4x4(&theEnemy.World, modelScale*modelRot*modelOffset);
newEnemy->setBasicMInstance(theEnemy);
oneEnemy = newEnemy->getBasicMInstance();
addEnemy(theEnemy);
enemyclass.push_back(newEnemy);
LevelCollisions.push_back(EnemyBox);
newEnemy->setWorld(theEnemy.World);
}
bool Monster::addEnemy(Creature* target, bool print) {
if(isEnemy(target))
return false;
if(print) {
if(aggroString[0])
broadcast(nullptr, getRoomParent(), "%M says, \"%s.\"", this, aggroString);
target->printColor("^r%M attacks you.\n", this);
broadcast(target->getSock(), getRoomParent(), "%M attacks %N.", this, target);
}
if(target->isPlayer()) {
// take pity on these people
if(target->isEffected("petrification") || target->isUnconscious())
return(0);
// pets should not attack master
if(isPet() && getMaster() == target)
return(false);
}
if(target->isPet()) {
addEnemy(target->getMaster());
}
adjustThreat(target, 0);
return(true);
}
bool PlayLayer::init()
{
if (!Layer::init()) {
return false;
}
Size winSize = Director::getInstance()->getWinSize();
SpriteFrameCache::getInstance()->addSpriteFramesWithFile("Sprite.plist");
spriteSheet = SpriteBatchNode::create("Sprite.png");
addChild(spriteSheet);
map = TMXTiledMap::create("map1.tmx");
auto bgLayer = map->getLayer("bg");
bgLayer->setAnchorPoint(Point(0.5f, 0.5f));
bgLayer->setPosition(Point(winSize.width / 2 ,winSize.height / 2));
objects = map->getObjectGroup("obj");
this->addChild(map, -1);
float offX = ( map->getContentSize().width - winSize.width )/ 2;
initPointsVector(offX);
addEnemy();
auto touchListener = EventListenerTouchOneByOne::create();
touchListener->onTouchBegan = CC_CALLBACK_2(PlayLayer::onTouchBegan, this);
_eventDispatcher->addEventListenerWithSceneGraphPriority(touchListener, this);
scheduleUpdate();
return true;
}
void Brave::addRoles()
{
player = Player::create(Player::PlayerType::PLAYER);
player->setPosition(VisibleRect::left().x + player->getContentSize().width / 2, VisibleRect::top().y / 2);
this->addChild(player, 10);
addEnemy();
}
static void creditsMove()
{
Entity *e;
e = addEnemy("boss/awesome_boss_4", self->x + 24, self->y);
e->endX = 24;
e->head = self;
e->face = LEFT;
e->creditsAction = &creditsMoveToMiddle;
e = addEnemy("boss/awesome_boss_3", self->x + 16, self->y);
e->endX = 16;
e->head = self;
e->face = LEFT;
e->creditsAction = &creditsMoveToMiddle;
e = addEnemy("boss/awesome_boss_2", self->x + 8, self->y);
e->endX = 8;
e->head = self;
e->face = LEFT;
e->creditsAction = &creditsMoveToMiddle;
e = addEnemy("boss/awesome_boss_1", self->x + 0, self->y);
e->endX = 0;
e->head = self;
e->face = LEFT;
e->creditsAction = &creditsMoveToMiddle;
self->creditsAction = &bossMoveToMiddle;
}
void ld::PlayState::countTimeForEnemies()
{
if (m_Time <= m_spawnTime)
{
m_spawnTime = 0;
addEnemy();
}
}
void MainScene::addRoles()
{
//add player
_player = Player::create(Player::PlayerType::PLAYER);
_player->setPosition(VisibleRect::left().x + _player->getContentSize().width/2, VisibleRect::top().y/2);
this->addChild(_player,10);
addEnemy();
}
int main(int argc, char* args[])
{
SDL_Window* window = nullptr;
SDL_Surface* windowSurface = nullptr;
SDL_Renderer* renderer = nullptr;
if (!init(&window, &windowSurface, &renderer))
{
printf("Failed to initialize SDL.\n", SDL_GetError());
}
else
{
bool quit = false;
SDL_Event e;
Player player;
SDL_Rect winBox;
addEnemy();
addEntity(player.m_pos, 375, 25, 25, 25);
addEntity(winBox, 0, 750, 50, 800);
//Game loop
while (!quit)
{
while (SDL_PollEvent(&e) != 0)
{
if (e.type == SDL_QUIT) {
quit = true;
}
if (e.type == SDL_KEYDOWN)
{
inputMananger(e, player.m_pos, player.m_movementSpeed);
}
}
if (playerCollisions(enemies, player)) {
resetPlayerPos(player);
}
enemyMovement();
gameBounds(player.m_pos);
render(&renderer, player.m_pos, winBox);
//Check to see whether the game is won
if (checkWinCollision(winBox, player)) {
quit = true;
}
SDL_Delay(16); //Simulate 16 fps
}
}
close(&window, &renderer);
return 0;
}
void Env::_genEnemy( void ) {
static int frame = 0;
frame++;
if (frame == REP_ENEMY) {
Enemy *enemy = new Enemy(_hud.maxX+1, _hud.maxY+1);
enemy->setMaxMinXY(MAP_LIMITS);
addEnemy(*enemy);
frame = 0;
}
}
void GameObj::addContact(GameObj *enemy) {
if(enemy == NULL) {
groundContact = true;
}
else if(enemy->isNPC() != isNPC()) {
// contacts++;
if(enemy->getType() != Settings::OBJ_T_BULLET) {
addEnemy(enemy);
}
}
}
void refreshTileMap(Game* g)
{
memset(g->doors, 0, g->doorArraySize * sizeof(door));
memset(g->enemies, 0, g->enemyArraySize * sizeof(enemy));
memset(g->gameKeys, 0, g->keyArraySize * sizeof(key));
memset(g->shots, 0, g->shotArraySize * sizeof(shot));
memset(&g->player1, 0, sizeof(player));
memset(&g->stairs, 0, sizeof(stair));
Tile* t;
for (int i = 0; i < TILEMAPSIDE; i++)
{
for (int j = 0; j < TILEMAPSIDE; j++)
{
t = &g->tileMaps[0].tiles[i][j];
switch (t->tileID)
{
case Tile::FLOOR:
t->filled = FALSE;
t->texID = g->floorTex;
break;
case Tile::WALL:
t->filled = TRUE;
t->texID = g->wallTex;
break;
case Tile::ENEMY_FLOOR:
t->filled = false;
t->texID = g->floorTex;
//enemy spawn
addEnemy(g, TILESIDE*(j + 0.5), TILESIDE*(i + 0.5), g->enemyTex);
break;
case Tile::PLAYER_FLOOR:
t->filled = false;
t->texID = g->floorTex;
//player spawn
setPlayer(g, TILESIDE*(j + 0.5) , TILESIDE*(i + 0.5), g->playerTex);
break;
case Tile::STAIR:
t->filled = false;
t->texID = g->floorTex;
setStair(g, TILESIDE*(j + 0.5), TILESIDE*(i + 0.5), g->stairTex);
break;
case Tile::DOOR:
t->filled = false;
t->texID = g->floorTex;
addDoor(g, TILESIDE*(j + 0.5), TILESIDE*(i + 0.5), g->doorTex);
break;
}
}
}
printf("");
}
void ListEnemies::handleEnnemy(const uint8_t id, const uint8_t life, const uint8_t type, const uint16_t x, const uint16_t y)
{
Enemy_SharedPtr e;
if ((e = getEnemy(id)) == nullptr) {
e = std::make_shared<Enemy>(id, life, type);
addEnemy(e);
}
e->setX(x);
e->setY(y);
}
void
Game2D::
addEnemyLine (int x, int y, int size, int count, int type, int align){
if (align==1) x=x+width()/2-size*count/2;
if (align==2) x=x+width()-size*count;
for (int i=0; i<count; i++){
addEnemy (x, y, size, type);
x+=size;
}
}
void World::addEnemies()
{
const auto numberOfEnemies = 66u;
const auto enemiesPerRow = 11u;
const auto horizontalSpacing = 40.f;
const auto verticalSpacing = 35.f;
const sf::Vector2f positionOfTopLeft(MovementsPadding, Padding * 2.5);
for (auto i = 0u; i < numberOfEnemies; ++i)
{
sf::Vector2f position(horizontalSpacing * (i % enemiesPerRow), verticalSpacing * (i / enemiesPerRow));
if (i < 22)
addEnemy(Invader::Enemy1, positionOfTopLeft.x + position.x, positionOfTopLeft.y + position.y);
else if (i >= 22 && i < 44)
addEnemy(Invader::Enemy2, positionOfTopLeft.x + position.x, positionOfTopLeft.y + position.y);
else if (i >= 44)
addEnemy(Invader::Enemy3, positionOfTopLeft.x + position.x, positionOfTopLeft.y + position.y);
}
}
void spawnRandomEnemy()
{
debug(("spawnRandomEnemy()\n"));
Properties props;
Vector position;
if (game->nomonsters)
{
return;
}
position = player->position;
props.clear();
position.x += Math::rrand(-80, 80);
position.y += Math::rrand(-80, 80);
position.z += Math::rrand(16, 64);
props.setProperty("classname", extractEnemyFromList(mission->enemySpawnList.getText()));
int type = entityManager->getEntityType(&props);
if ((entityManager->enemyDef[type].flags & EF_WEIGHTLESS))
{
if (bsp->getContentsAtPosition(position) & (CONTENTS_SLIME|CONTENTS_LAVA|CONTENTS_WATER|CONTENTS_MONSTERCLIP|CONTENTS_SOLID))
{
debug(("spawnRandomEnemy() - Can't spawn in content type\n"));
return;
}
}
else if (!unitCanSpawnInLocation(NULL, position))
{
debug(("spawnRandomEnemy() - Can't spawn at position\n"));
return;
}
props.setProperty("position", position);
props.setProperty("spawnedIn", 1);
props.setProperty("thinkTime", Math::rrand(50, 100)); // don't attack instantly!
addEnemy(&props);
addTeleportParticles(position);
audio->playSound(SND_TELEPORT2, CH_SPAWN, camera->getSoundDistance(position));
debug(("spawnRandomEnemy() - Done\n"));
}
void JG_AttackWave_AllLinesTogether::initAttackWave(float attackDifficulty, int attackCount)
{
JG_AttackWave_Base::initAttackWave( attackDifficulty, attackCount);
enemeyAddInterval = 0.3;
pathCounter =0;
int currentTotalPathExist = CALL_MEMBER_FN(listenerObj,getAvailablePathCountFunction)();
float totalDifficulty = 0.0;
float currentEnemyDifficulty;
while( totalDifficulty < attackDifficulty)
{
currentEnemy=addEnemy();
//CCLOG("enemy added");
currentEnemyDifficulty = currentEnemy->GetDifficulty();
//difficulty added because of path health
currentEnemyDifficulty *= (1 + ( (100 - selectPath(pathCounter)->GetHealth() )/100 ));
//defficulty added because of concurrent path attack
currentEnemyDifficulty *= ( ( (pathCounter+1) > currentTotalPathExist ? currentTotalPathExist:(pathCounter+1)) *2 );
totalDifficulty += currentEnemyDifficulty;
enemyCounter ++;
pathCounter ++;
//TODO pathcounter is redundant
}
//schedule(schedule_selector(JG_AttackWave_AllLinesSequential::initiateEnemyAttack),0,1,0.1);
//this->schedule(schedule_selector(JG_AttackWave_AllLinesSequential::initiateEnemyAttack),0.5);
//initiateEnemyAttack(2);
//schedule(schedule_selector(JG_AttackWave_AllLinesSequential::initiateEnemyAttack),enemeyAddInterval,pathCo);
schedule(schedule_selector(JG_AttackWave_AllLinesSequential::initiateEnemyAttack), enemeyAddInterval, pathCounter-1,0);
}
void EnemyColletion::init(MapShowScene* m)
{
mms = m;
vector< vector<int> > mapData = mms->curMap->mapData;
for (int i = 0; i < mapData.size(); i++ )
{
for (int j = 0; j < mapData[i].size(); j++ )
{
if (mapData[i][ j ] == Map::ENEMY )
{
addEnemy(i, j);
}
}
}
}
void World::addEnemies()
{
// Add enemies to the spawn point container
addEnemy(Aircraft::Raptor, 0.f, 500.f);
addEnemy(Aircraft::Raptor, 0.f, 1000.f);
addEnemy(Aircraft::Raptor, +100.f, 1100.f);
addEnemy(Aircraft::Raptor, -100.f, 1100.f);
addEnemy(Aircraft::Avenger, -70.f, 1400.f);
addEnemy(Aircraft::Avenger, -70.f, 1600.f);
addEnemy(Aircraft::Avenger, 70.f, 1400.f);
addEnemy(Aircraft::Avenger, 70.f, 1600.f);
// Sort all enemies according to their y value, such that lower enemies are checked first for spawning
std::sort(mEnemySpawnPoints.begin(), mEnemySpawnPoints.end(), [] (SpawnPoint lhs, SpawnPoint rhs)
{
return lhs.y < rhs.y;
});
}
static void raiseDead()
{
char targetName[MAX_VALUE_LENGTH];
Target *t;
Entity *e;
self->thinkTime--;
if (self->thinkTime <= 0)
{
snprintf(targetName, MAX_VALUE_LENGTH, "GRAVE_%c", self->description[self->mental]);
t = getTargetByName(targetName);
if (t == NULL)
{
showErrorAndExit("Azriel cannot find target");
}
e = addEnemy("enemy/zombie", t->x, t->y);
e->y = getMapFloor(self->x + self->w / 2, self->y);
e->startX = e->x;
e->startY = e->y - e->h;
e->endY = e->y;
e->thinkTime = 15 + prand() % 105;
self->mental--;
if (self->mental <= 0)
{
self->thinkTime = 30;
self->action = &raiseDeadFinish;
}
}
checkToMap(self);
becomeTransparent();
}
static void followPlayer()
{
Entity *e;
if (self->active == TRUE)
{
self->targetX = player.x - self->w / 2 + player.w / 2;
/* Position above the player */
if (abs(self->x - self->targetX) <= abs(self->dirX))
{
self->x = self->targetX;
self->dirX = 0;
}
else
{
self->dirX = self->targetX < self->x ? -player.speed * 3 : player.speed * 3;
}
if (self->health > 0)
{
self->thinkTime--;
if (self->thinkTime <= 0)
{
e = addEnemy("common/large_rock", self->x, self->y);
e->x += (self->w - e->w) / 2;
e->y += (self->h - e->h) / 2;
self->health--;
self->thinkTime = self->maxThinkTime;
}
}
}
checkToMap(self);
}
Entity *addEntityFromResource(char *type, char *name, int startX, int startY)
{
Entity *e = NULL;
if (strcmpignorecase(type, "ITEM") == 0 || strcmpignorecase(type, "SHIELD") == 0 || strcmpignorecase(type, "WEAPON") == 0)
{
e = addPermanentItem(name, startX, startY);
}
else if (strcmpignorecase(type, "TEMP_ITEM") == 0 || strcmpignorecase(type, "HEALTH") == 0)
{
e = addTemporaryItem(name, startX, startY, LEFT, 0, 0);
}
else if (strcmpignorecase(type, "PLAYER") == 0)
{
e = loadPlayer(startX, startY, NULL);
}
else if (strcmpignorecase(type, "PLAYER_WEAPON") == 0)
{
setPlayerWeaponName(name);
}
else if (strcmpignorecase(type, "PLAYER_SHIELD") == 0)
{
setPlayerShieldName(name);
}
else if (strcmpignorecase(type, "KEY_ITEM") == 0)
{
e = addKeyItem(name, startX, startY);
}
else if (strcmpignorecase(type, "ENEMY") == 0)
{
e = addEnemy(name, startX, startY);
}
else if (strcmpignorecase(type, "NPC") == 0)
{
e = addNPC(name, startX, startY);
}
else if (strcmpignorecase(type, "AUTO_LIFT") == 0 || strcmpignorecase(type, "MANUAL_LIFT") == 0)
{
e = addLift(name, startX, startY, getEntityTypeByName(type));
}
else if (strcmpignorecase(type, "SPAWNER") == 0)
{
e = addSpawner(startX, startY, name);
}
else if (strcmpignorecase(type, "TARGET") == 0)
{
addTarget(startX, startY, name);
}
else if (strcmpignorecase(type, "PRESSURE_PLATE") == 0)
{
e = addPressurePlate(name, startX, startY);
}
else if (strcmpignorecase(type, "TELEPORTER") == 0)
{
e = addTeleporter(name, startX, startY);
}
else if (strcmpignorecase(type, "AUTO_DOOR") == 0 || strcmpignorecase(type, "MANUAL_DOOR") == 0)
{
e = addDoor(name, startX, startY, getEntityTypeByName(type));
}
else if (strcmpignorecase(type, "WEAK_WALL") == 0)
{
e = addWeakWall(name, startX, startY);
}
else if (strcmpignorecase(type, "TRAP_DOOR") == 0)
{
e = addTrapDoor(name, startX, startY);
}
else if (strcmpignorecase(type, "CONVEYOR_BELT") == 0)
{
e = addConveyorBelt(name, startX, startY);
}
else if (strcmpignorecase(type, "SWITCH") == 0)
{
e = addSwitch(name, startX, startY);
}
else if (strcmpignorecase(type, "SCRIPT_LINE_DEF") == 0 || strcmpignorecase(type, "LINE_DEF") == 0)
{
e = addLineDef(type, name, startX, startY);
}
else if (strcmpignorecase(type, "LEVEL_EXIT") == 0)
{
e = addLevelExit(name, startX, startY);
}
else if (strcmpignorecase(type, "SAVE_POINT") == 0)
{
/* Save points don't spawn for replays */
if (game.gameType == NORMAL)
{
e = addSavePoint(startX, startY);
}
}
else if (strcmpignorecase(type, "TRIGGER") == 0)
{
addTriggerFromResource(key, value);
}
else if (strcmpignorecase(type, "GLOBAL_TRIGGER") == 0)
{
addGlobalTriggerFromResource(key, value);
}
else if (strcmpignorecase(type, "MAP_TRIGGER") == 0)
{
addMapTriggerFromResource(key, value);
}
else if (strcmpignorecase(type, "OBJECTIVE") == 0)
{
addObjectiveFromResource(key, value);
}
else if (strcmpignorecase(type, "ACTION_POINT") == 0)
{
e = addActionPoint(name, startX, startY);
}
else if (strcmpignorecase(type, "FALLING_PLATFORM") == 0)
{
e = addFallingPlatform(startX, startY, name);
}
else if (strcmpignorecase(type, "VANISHING_PLATFORM") == 0)
{
e = addVanishingPlatform(startX, startY, name);
}
else if (strcmpignorecase(type, "ANTI_GRAVITY") == 0)
{
e = addAntiGravityField(startX, startY, name);
}
else
{
showErrorAndExit("Unknown Entity type %s", type);
}
return e;
}
void EditLayer::onMessage( unsigned int type, unsigned long param1, unsigned long param2 )
{
switch (type)
{
case MSG_DELETESELECTED:
deleteSelected();
break;
case MSG_CHANGEITEMTYPE:
changeEnemyType(param1, param2);
break;
case MSG_CHANGEITEMRINGTYPE:
changeEnemyRingType(param1, param2);
break;
case MSG_CHANGEBOXTYPE:
changeBlockBoxType(param1, param2);
break;
case MSG_CHANGESELECTED:
{
hidePropertyLayer();
hideBlockBoxPropertyLayer();
int old_sel = param1;
int new_sel = param2;
Node* pNode = this->getChildByTag(old_sel);
if (pNode)
pNode->removeChildByTag(TAG_SELECTED_RECT);
Sprite* pSelected = dynamic_cast<Sprite*>(this->getChildByTag(new_sel));
if (pSelected)
drawSelectedRect(pSelected);
}
break;
case MSG_ADDBLOCK:
{
switch (param1)
{
case kBlockBox:
addBlock(Vec2(200, 200));
break;
case kBlockWheel:
addWheel(Vec2(300, 300));
break;
case kBlockVortex:
addVortex(Vec2(400, 400));
break;
case kBlockBomb:
addBomb(Vec2(500, 500));
break;
default:
break;
}
}
break;
case MSG_ADDENEMYITEM:
addEnemy(BallBase::kTypeNormal1, Vec2(100, 100), BallBase::kTypeBulletUnknown);
break;
case MSG_SAVESTAGE:
{
_sectionId = param1;
_stageId = param2;
save();
}
break;
case MSG_SETBULLETCOUNT:
{
_bulletCounter[param1] = param2;
updateBulletCount();
}
break;
default:
break;
}
}
void World::addEnemies(int level) //requires level
{
// Add enemies to the spawn point container
if (level == 1){
addEnemy(Aircraft::Raptor, 0.f, 500.f);
addEnemy(Aircraft::Raptor, 0.f, 1000.f);
addEnemy(Aircraft::Raptor, +100.f, 1150.f);
addEnemy(Aircraft::Raptor, -100.f, 1150.f);
addEnemy(Aircraft::Avenger, 70.f, 1500.f);
addEnemy(Aircraft::Avenger, -70.f, 1500.f);
addEnemy(Aircraft::Avenger, -70.f, 1710.f);
addEnemy(Aircraft::Avenger, 140.f, 1700.f);
addEnemy(Aircraft::Avenger, -140.f, 1850.f);
addEnemy(Aircraft::Raptor, 300.f, 2200.f);
addEnemy(Aircraft::Raptor, -300.f, 2200.f);
addEnemy(Aircraft::Raptor, 0.f, 2200.f);
addEnemy(Aircraft::Raptor, 0.f, 2500.f);
addEnemy(Aircraft::Avenger, -300.f, 2700.f);
addEnemy(Aircraft::Raptor, 0.f, 3000.f);
addEnemy(Aircraft::Raptor, 250.f, 3250.f);
addEnemy(Aircraft::Raptor, -250.f, 3250.f);
addEnemy(Aircraft::Avenger, 0.f, 3500.f);
addEnemy(Aircraft::Avenger, 0.f, 3700.f);
addEnemy(Aircraft::Raptor, 0.f, 3800.f);
addEnemy(Aircraft::Avenger, 0.f, 4000.f);
addEnemy(Aircraft::Avenger, -200.f, 4200.f);
addEnemy(Aircraft::Raptor, 200.f, 4200.f);
addEnemy(Aircraft::Raptor, 0.f, 4400.f);
}
if (level == 2)
{ //enemies added but needs to be optimized and placed correctly
addEnemy(Aircraft::Raptor2, 0.f, 500.f);
addEnemy(Aircraft::Raptor2, 0.f, 1000.f);
addEnemy(Aircraft::Raptor2, 150.f, 1150.f);
addEnemy(Aircraft::Raptor2, -150.f, 1150.f);
addEnemy(Aircraft::Avenger2, 70.f, 1500.f);
addEnemy(Aircraft::Avenger2, -70.f, 1500.f);
addEnemy(Aircraft::Avenger2, -70.f, 1710.f);
addEnemy(Aircraft::Avenger2, 70.f, 1700.f);
addEnemy(Aircraft::Avenger2, 30.f, 1850.f);
addEnemy(Aircraft::Raptor2, 300.f, 2200.f);
addEnemy(Aircraft::Raptor2, -300.f, 2200.f);
addEnemy(Aircraft::Raptor2, 0.f, 2200.f);
addEnemy(Aircraft::Raptor2, 0.f, 2500.f);
addEnemy(Aircraft::Avenger2, -300.f, 2700.f);
addEnemy(Aircraft::Avenger2, 300.f, 2900.f);
addEnemy(Aircraft::Raptor2, 0.f, 3000.f);
addEnemy(Aircraft::Raptor2, 250.f, 3250.f);
addEnemy(Aircraft::Raptor2, -250.f, 3250.f);
addEnemy(Aircraft::Avenger2, 0.f, 3500.f);
addEnemy(Aircraft::Avenger2, 0.f, 3700.f);
addEnemy(Aircraft::Raptor2, 0.f, 3800.f);
addEnemy(Aircraft::Avenger2, 0.f, 4000.f);
addEnemy(Aircraft::Avenger2, -200.f, 4200.f);
addEnemy(Aircraft::Raptor2, 200.f, 4200.f);
addEnemy(Aircraft::Raptor2, 0.f, 4400.f);
}
if (level == 3)
{
addEnemy(Aircraft::Raptor3, 0.f, 500.f);
addEnemy(Aircraft::Raptor3, 400.f, 750.f);
addEnemy(Aircraft::Raptor3, -400.f, 750.f);
addEnemy(Aircraft::Raptor3, 0.f, 1000.f);
addEnemy(Aircraft::Raptor3, +200.f, 1150.f);
addEnemy(Aircraft::Raptor3, -200.f, 1150.f);
addEnemy(Aircraft::Avenger3, 140.f, 1500.f);
addEnemy(Aircraft::Avenger3, 0.f, 1500.f);
addEnemy(Aircraft::Avenger3, -140.f, 1500.f);
addEnemy(Aircraft::Avenger3, -70.f, 1710.f);
addEnemy(Aircraft::Avenger3, 70.f, 1700.f);
addEnemy(Aircraft::Avenger3, 30.f, 1850.f);
addEnemy(Aircraft::Raptor3, 375.f, 2200.f);
addEnemy(Aircraft::Raptor3, -375.f, 2200.f);
addEnemy(Aircraft::Raptor3, 0.f, 2200.f);
addEnemy(Aircraft::Raptor3, 0.f, 2500.f);
addEnemy(Aircraft::Avenger3, -325.f, 2700.f);
addEnemy(Aircraft::Avenger3, 325.f, 2900.f);
addEnemy(Aircraft::Raptor3, 0.f, 3000.f);
addEnemy(Aircraft::Avenger3, 250.f, 3250.f);
addEnemy(Aircraft::Avenger3, -250.f, 3250.f);
addEnemy(Aircraft::Avenger3, 100.f, 3500.f);
addEnemy(Aircraft::Avenger3, -100.f, 3600.f);
addEnemy(Aircraft::Raptor3, 0.f, 3800.f);
addEnemy(Aircraft::Avenger3, 0.f, 4000.f);
addEnemy(Aircraft::Avenger3, -200.f, 4200.f);
addEnemy(Aircraft::Raptor3, 200.f, 4200.f);
addEnemy(Aircraft::Raptor3, 0.f, 4400.f);
}
// Sort all enemies according to their y value, such that lower enemies are checked first for spawning
std::sort(mEnemySpawnPoints.begin(), mEnemySpawnPoints.end(), [] (SpawnPoint lhs, SpawnPoint rhs)
{
return lhs.y < rhs.y;
});
}
bool ld::PlayState::init()
{
std::srand(static_cast<unsigned int>(std::time(0)));
if (m_music.openFromFile("assets/Audio/Music/Abstraction - Ludum Dare 28 - First Track.wav"))
m_music.play();
m_music.setLoop(true);
const float buttonScale = 2.f;
// Pause menu
{
std::array<std::unique_ptr<Button>, 3> buttons;
for (auto& i : buttons)
{
i.reset(new Button(*m_window));
i->setFillColor(sf::Color(255, 255, 255, 255));
i->setSound("assets/Audio/Sound Effects/menuselect.ogg");
}
const float buttonOffset = 50.f;
/****** Resume button ******/
auto tex = ldResource.getTexture("assets/Graphics/Menus/retry.png");
buttons[0]->setTexture(tex);
buttons[0]->setSize(sf::Vector2f(tex->getSize()) * buttonScale);
buttons[0]->setPosition(100.f, 100.f);
buttons[0]->setCallback([this]()
{
m_menuState = Count;
Engine::getInstance().setPaused(false);
});
/****** Restart button ******/
tex = ldResource.getTexture("assets/Graphics/Menus/restart.png");
buttons[1]->setTexture(tex);
buttons[1]->setSize(buttons[0]->getSize());
buttons[1]->setPosition(100.f, buttons[0]->getPosition().y + buttons[0]->getSize().y + buttonOffset);
buttons[1]->setCallback([this]()
{
auto ptr = new PlayState(*m_window);
ptr->setDifficulty(m_difficulty);
Engine::getInstance().changeState(ptr);
Engine::getInstance().setPaused(false);
});
/****** Exit button ******/
tex = ldResource.getTexture("assets/Graphics/Menus/backToMenu.png");
buttons[2]->setTexture(tex);
buttons[2]->setSize(buttons[1]->getSize());
buttons[2]->setPosition(100.f, buttons[1]->getPosition().y + buttons[1]->getSize().y + buttonOffset);
buttons[2]->setCallback([this]()
{
Engine::getInstance().changeState(new MainMenuState(*m_window));
Engine::getInstance().setPaused(false);
});
for (auto& i : buttons)
m_menus[Pause]->addElement(i.release());
}
// Game over menu
{
std::array<std::unique_ptr<Button>, 2> buttons;
for (auto& i : buttons)
{
i.reset(new Button(*m_window));
i->setFillColor(sf::Color(255, 255, 255, 255));
i->setSound("assets/Audio/Sound Effects/menuselect.ogg");
}
const float buttonOffset = 50.f;
/****** Restart button ******/
auto tex = ldResource.getTexture("assets/Graphics/Menus/restart.png");
buttons[0]->setTexture(tex);
buttons[0]->setSize(sf::Vector2f(tex->getSize()) * buttonScale);
buttons[0]->setPosition(100.f, 100.f);
buttons[0]->setCallback([this]()
{
auto ptr = new PlayState(*m_window);
ptr->setDifficulty(m_difficulty);
Engine::getInstance().changeState(ptr);
Engine::getInstance().setPaused(false);
});
/****** Quit button ******/
tex = ldResource.getTexture("assets/Graphics/Menus/backToMenu.png");
buttons[1]->setTexture(tex);
buttons[1]->setSize(buttons[0]->getSize());
buttons[1]->setPosition(100.f, buttons[0]->getPosition().y + buttons[0]->getSize().y + buttonOffset);
buttons[1]->setCallback([this]()
{
Engine::getInstance().changeState(new MainMenuState(*m_window));
Engine::getInstance().setPaused(false);
});
for (auto& i : buttons)
m_menus[GameOver]->addElement(i.release());
}
//Player
auto tex = ldResource.getTexture("assets/Graphics/Player and shield planets/Player_Base.png");
tex->setSmooth(true);
m_player.setTexture(tex);
m_player.setSize(sf::Vector2f(128.f,128.f));
m_player.setOrigin(m_player.getSize().x / 2, m_player.getSize().y / 2);
m_player.setPosition(m_window->getView().getCenter());
tex = ldResource.getTexture("assets/Graphics/Player and shield planets/Shield.png");
tex->setSmooth(true);
m_player.m_shield.setTexture(tex);
m_player.m_shield.setSize(sf::Vector2f(128.f, 128.f));
m_player.m_shield.setOrigin(m_player.m_shield.getSize().x / 2, m_player.m_shield.getSize().y / 2);
m_player.m_shield.setPosition(m_player.getPosition() - m_player.getSize());
tex = ldResource.getTexture("assets/Graphics/Effects/electricity_chain_loop.png");
tex->setSmooth(true);
tex->setRepeated(true);
m_player.m_chain.setTexture(tex);
m_player.m_chain.setSize(sf::Vector2f(200, 200));
m_player.m_chain.setOrigin(m_player.m_chain.getSize().x / 2, 0);
m_player.m_chain.setPosition(m_player.getPosition());
tex = ldResource.getTexture("assets/Graphics/Player and shield planets/Player_Cloud.png");
tex->setSmooth(true);
m_player.m_clouds.setTexture(tex);
m_player.m_clouds.setSize(m_player.getSize());
m_player.m_clouds.setScale(m_player.getScale());
m_player.m_clouds.setOrigin(m_player.getSize() / 2.f);
m_player.m_clouds.setPosition(m_player.getPosition());
tex = ldResource.getTexture("assets/Graphics/Backgrounds/background.png");
tex->setSmooth(true);
m_background.setSize(m_window->getView().getSize());
m_background.setTexture(tex);
tex = ldResource.getTexture("assets/Graphics/Menus/healthcounter.png");
tex->setSmooth(true);
m_lifeIcon.setTexture(tex);
m_lifeIcon.setSize(sf::Vector2f(m_lifeIcon.getTexture()->getSize()));
tex = ldResource.getTexture("assets/Graphics/Menus/killcounter.png");
tex->setSmooth(true);
m_killIcon.setTexture(tex);
m_killIcon.setSize(sf::Vector2f(m_killIcon.getTexture()->getSize()));
auto font = ldResource.getFont("assets/Graphics/Roboto-Black.ttf");
m_scoreText.setFont(*font);
m_scoreText.setCharacterSize(50);
m_scoreText.setColor(sf::Color(255, 255, 255, 255));
m_killsText.setFont(*font);
m_killsText.setCharacterSize(65);
m_killsText.setColor(sf::Color(255, 255, 255, 255));
switch (m_difficulty)
{
case 1:
m_Time = 6.f;
m_minTime = 3.f;
m_player.setLives(5);
m_enemySpeed = 150.f;
m_enemySpeedMin = 100.f;
break;
case 2:
m_Time = 3.5f;
m_minTime = 1.f;
m_player.setLives(4);
m_enemySpeed = 185.f;
m_enemySpeedMin = 100.f;
break;
case 3:
m_Time = 2.5f;
m_minTime = 0.25f;
m_player.setLives(3);
m_enemySpeed = 225.f;
m_enemySpeedMin = 100.f;
break;
default:
assert(false);
break;
}
m_scoreClock.restart();
//Enemy
addEnemy();
return true;
}
static void summonEnemies()
{
char summonList[MAX_VALUE_LENGTH], enemyToSummon[MAX_VALUE_LENGTH];
char *token;
int i, summonIndex = 0, summonCount = 0;
Entity *e;
for (i=0;i<2;i++)
{
summonCount = 0;
summonIndex = 0;
STRNCPY(summonList, self->requires, MAX_VALUE_LENGTH);
token = strtok(summonList, "|");
while (token != NULL)
{
token = strtok(NULL, "|");
summonCount++;
}
if (summonCount == 0)
{
showErrorAndExit("Scanner at %f %f has no summon list", self->x, self->y);
}
summonIndex = prand() % summonCount;
STRNCPY(summonList, self->requires, MAX_VALUE_LENGTH);
summonCount = 0;
token = strtok(summonList, "|");
while (token != NULL)
{
if (summonCount == summonIndex)
{
break;
}
token = strtok(NULL, "|");
summonCount++;
}
snprintf(enemyToSummon, MAX_VALUE_LENGTH, "enemy/%s", token);
e = addEnemy(enemyToSummon, self->x, self->y);
e->x = self->x;
e->y = self->y;
e->targetX = self->x + (i == 0 ? -64 : 64);
e->targetY = self->y;
calculatePath(e->x, e->y, e->targetX, e->targetY, &e->dirX, &e->dirY);
e->flags |= (NO_DRAW|HELPLESS|TELEPORTING);
}
}
void World::addEnemies() {
if (mNetworkedWorld)
return;
// Add enemies to the spawn point container
addEnemy(Aircraft::Raptor, 0.f, 500.f);
addEnemy(Aircraft::Raptor, 0.f, 1000.f);
addEnemy(Aircraft::Raptor, +100.f, 1150.f);
addEnemy(Aircraft::Raptor, -100.f, 1150.f);
addEnemy(Aircraft::Avenger, 70.f, 1500.f);
addEnemy(Aircraft::Avenger, -70.f, 1500.f);
addEnemy(Aircraft::Avenger, -70.f, 1710.f);
addEnemy(Aircraft::Avenger, 70.f, 1700.f);
addEnemy(Aircraft::Avenger, 30.f, 1850.f);
addEnemy(Aircraft::Raptor, 300.f, 2200.f);
addEnemy(Aircraft::Raptor, -300.f, 2200.f);
addEnemy(Aircraft::Raptor, 0.f, 2200.f);
addEnemy(Aircraft::Raptor, 0.f, 2500.f);
addEnemy(Aircraft::Avenger,-300.f, 2700.f);
addEnemy(Aircraft::Avenger,-300.f, 2700.f);
addEnemy(Aircraft::Raptor, 0.f, 3000.f);
addEnemy(Aircraft::Raptor, 250.f, 3250.f);
addEnemy(Aircraft::Raptor, -250.f, 3250.f);
addEnemy(Aircraft::Avenger, 0.f, 3500.f);
addEnemy(Aircraft::Avenger, 0.f, 3700.f);
addEnemy(Aircraft::Raptor, 0.f, 3800.f);
addEnemy(Aircraft::Avenger, 0.f, 4000.f);
addEnemy(Aircraft::Avenger,-200.f, 4200.f);
addEnemy(Aircraft::Raptor, 200.f, 4200.f);
addEnemy(Aircraft::Raptor, 0.f, 4400.f);
sortEnemies();
}
void Model::startWave() {
if (enemiesLeft == -2&&enemies.size()==0) {
enemiesLeft = waves.at(waveNumber).size-2;
addEnemy(waves.at(waveNumber).enemyType, waves.at(waveNumber).enemyLevel);
}
}
void Model::update(sf::Time delta) {
//check for GameOver
if (this->lives < 1) {
std::cout << "YOU LOSE" << std::endl;
this->gameMode = -1;
}
//Checks for winner
if ((this->waveNumber == this->totalWaves) && (this->enemiesLeft=-2) && lives > 0) {
std::cout << "YOU WIN" << std::endl;
this->gameMode = 2;
}
this->player.update(delta);
sf::Transform mapState;
mapState.translate(float(mapX), float(mapY));
state.transform = mapState;
for (unsigned int i = 0; i < this->enemies.size(); i++) {
bool crossedLine = false;
this->enemies.at(i).UpdatePos(this->mapX, this->mapY);
if (checkPoint[int(-this->enemies.at(i).getPosition().x+mapX+640)][int(-this->enemies.at(i).getPosition().y+mapY+448)]) {
if (this->enemies.at(i).checkPointUpdate(1)==0) {
if (enemiesLeft > -1) {
addEnemy(waves.at(waveNumber).enemyType, waves.at(waveNumber).enemyLevel);
enemiesLeft -= 1;
}
}
if (this->enemies.at(i).checkPointUpdate(0) == 15) {
crossedLine = true;
}
}
if (crossedLine) {
//delete enemy here
this->lives -= 1;
enemies.erase(enemies.begin() + i);
}
else {
if (this->enemies.at(i).isDead()) {
this->player.inventory.gold += this->enemies.at(i).inventory.gold;
enemies.erase(enemies.begin() + i);
}
else {
this->enemies.at(i).update(delta);
}
}
}
if (enemiesLeft == -1&&enemies.size()==0) {
enemiesLeft--;
waveNumber++;
}
for (unsigned int i = 0; i < this->towers.size(); i++) {
if (this->towers.at(i).moving == false) {
this->towers.at(i).moveTower(int(this->dispX), int(this->dispY));
if (this->towers.at(i).update(delta, enemies)) {
switch (this->towers.at(i).type) {
//Add other options later
default:
attackSound.play();
break;
}
}
}
}
for (unsigned int i = 0; i < this->shops.size(); i++) {
this->shops.at(i).movePlayer(int(this->dispX), int(this->dispY));
}
for (unsigned int i = 0; i < this->powerUps.size(); i++) {
this->powerUps.at(i).movePower(int(this->dispX), int(this->dispY));
}
this->dispX = 0;
this->dispY = 0;
monsterNeedTex();
}
static void callSummoners()
{
int r;
Entity *e;
Target *t;
self->thinkTime--;
if (self->thinkTime <= 0)
{
setEntityAnimation(self, "ATTACK_1");
self->mental--;
playSoundToMap("sound/common/spell", BOSS_CHANNEL, self->x, self->y, 0);
e = addEnemy("enemy/sorceror_dark_summoner", 0, 0);
e->x = self->x + self->w / 2 - e->w / 2;
e->y = self->y + self->h / 2 - e->h / 2;
r = prand() % 3;
switch (r)
{
case 0:
t = getTargetByName("DARK_SUMMONER_TARGET_0");
break;
case 1:
t = getTargetByName("DARK_SUMMONER_TARGET_1");
break;
default:
t = getTargetByName("DARK_SUMMONER_TARGET_2");
break;
}
if (t == NULL)
{
showErrorAndExit("Sorceror cannot find target");
}
e->targetX = t->x;
e->targetY = t->y;
e->startX = e->targetX;
e->startY = e->targetY;
e->maxThinkTime = self->maxThinkTime;
calculatePath(e->x, e->y, e->targetX, e->targetY, &e->dirX, &e->dirY);
e->flags |= (NO_DRAW|HELPLESS|TELEPORTING);
e->head = self;
if (self->mental <= 0)
{
setEntityAnimation(self, "STAND");
self->maxThinkTime++;
self->action = &callSummonersWait;
}
self->thinkTime = 30;
}
hover();
}
