void Music::Initialize()
{
menu_snd.openFromFile("./Resources/Sounds/menumusic.ogg");
menu_snd.setVolume(60.0f);
menu_snd.setLoop(true);
battle_snd.openFromFile("./Resources/Sounds/battlemusic.ogg");
battle_snd.setVolume(40.0f);
battle_snd.setLoop(true);
menu_snd.play();
}
void SoundEngine::playMusic(sf::Music & Music)
{
if (activeMusic == true)
{
Music.setLoop(true);
Music.setVolume(20);
Music.play();
}
}
/*
PRIVATE function are not supposed to be called from outside VisualNovel namespace
even though it's accessible from global.
it can lead to errors if called
*/
void Init(){
//get the image for the text's background
log_background = get_image( "resource/LogBackground.png" );
//set the volume to the default global volume
SoundFx.setVolume( MUSIC_VOLUME );
static bool loaded = false;
if( !loaded ) //to prevent double calling
{
font_display.loadFromFile( "resource/PTN57F.ttf" );
log_text_display.setFont( font_display );
log_text_display.setCharacterSize( 24 );
log_text_display.setColor( sf::Color( 255, 255, 255 ) );
log_text_display.setPosition( log_x + log_padding_x, log_y + log_padding_y );
log_name_display.setFont( font_display );
log_name_display.setCharacterSize( 40 );
log_name_display.setColor( sf::Color( 255, 255, 255 ) );
log_name_display.setPosition( log_x + log_padding_x, log_y - log_to_name_y - 40 );
}
}
void setVolume(float _volume=1.0f) {
volume = _volume;
int intVol = _volume*100.0f;
sound.setVolume(intVol);
}
void Music::SetVolume(float32 volume)
{ music.setVolume(volume); }
int screen_1::Run(sf::RenderWindow &App)
{
hop.setBuffer(hopFile);
trucked.setBuffer(truckedFile);
dunked.setBuffer(dunkedFile);
// Clock
sf:: Clock clock;
sf::Time time;
sf::Time delay;
// Plays Intro
intro.play();
delay = intro.getDuration();
time = clock.getElapsedTime();
// Music
while ( clock.getElapsedTime() <= delay )
{
//cout << "NO";
}
froggerTheme.setVolume(50);
froggerTheme.play();
clock.restart();
sf::Event Event;
bool Running = true;
int sum = 0;// for log testing purposes
int sum2 = 0;
int sum3 = 0;
int sum4 = 0;
int sum5 = 0;
int sum6 = 0;
int sum7 = 0;
int sum8 = 0;
int sum9 = 0;
int sum10 = 0;
while (Running)
{
// Timer Rect and Clock
double time = clock.getElapsedTime().asSeconds();
if(time >= 1.5)
{
timeRect.width = timeRect.width - 2.383;
timer.setTextureRect(timeRect);
clock.restart();
}
if(timeRect.width <= 0)
{
frogOnLily1 = false;
frogOnLily2 = false;
frogOnLily3 = false;
frogOnLily4 = false;
frogOnLily5 = false;
mainPlayer.setNumLives(3);
rectSource.width = 115;
life.setTextureRect(rectSource);
occupied1.setPosition(-100, -100);
occupied2.setPosition(-100, -100);
occupied3.setPosition(-100, -100);
occupied4.setPosition(-100, -100);
occupied5.setPosition(-100, -100);
froggerTheme.pause();
clock.restart();
timeRect.width = 143;
timer.setTextureRect(timeRect);
frogger.setPosition(320, 605);
return 2;
}
// *********************************************************************
// Creating the objects of Object class for continuous movement
//
// Object(double posX, double posY, double speed)
// *********************************************************************
// Trucks
Object t1(130, 420,0.2 );
Object t2(550, 290, 0.2);
// Cars
Object c1(-50, 420, 0.3);
Object c2(280, 289, 0.2);
Object c3(0, 289, 0.2);
// Short Logs
Object sl1(0, 125, 0.2);
Object sl2(200, 61, 0.3);
Object sl3(300, 8, 0.4);
// Long Logs
Object l1(799, 8.3, 0.4);
Object l2(500, 125, 0.2);
// Sets object's direction
t1.moveRight(truck);
t2.moveLeft(truck2);
c1.moveRight(car);
c2.moveLeft(car2);
c3.moveLeft(car3);
sl1.moveRight(shortLog);
sl2.moveLeft(shortLog2);
sl3.moveRight(shortLog3);
l1.moveRight(longLog);
l2.moveRight(longLog2);
// *********************************************************************
// The following rectangles are for collision detection
// *********************************************************************
// Frog
sf::RectangleShape rect;
// Trucks
sf::RectangleShape rect2;
sf::RectangleShape rect3;
// Cars
sf::RectangleShape rect4;
sf::RectangleShape rect5;
sf::RectangleShape rect6;
// Short Logs
sf::RectangleShape rect7;
sf::RectangleShape rect8;
sf::RectangleShape rect9;
// Long Logs
sf::RectangleShape rect10;
sf::RectangleShape rect11;
// River
sf::RectangleShape rect12;
// Lilypads
sf::RectangleShape rect13;
sf::RectangleShape rect14;
sf::RectangleShape rect15;
sf::RectangleShape rect16;
sf::RectangleShape rect17;
// *********************************************************************
// Setting size of rectangles aka size(width, height)
// *********************************************************************
// Frog
sf::Vector2f size(40, 40);
// Truck
sf::Vector2f size2(120, 70);
sf::Vector2f size3(120, 70);
sf::Vector2f size4(95, 70);
// Cars
sf::Vector2f size5(95, 70);
sf::Vector2f size6(95, 70);
// Short Logs
sf::Vector2f size7(85, 35);
sf::Vector2f size8(85, 35);
sf::Vector2f size9(85, 35);
// Long Log
sf::Vector2f size10(135, 35);
sf::Vector2f size11(135, 35);
// River
sf::Vector2f size12(800, 230);
// Lilypads
sf::Vector2f size13(60, 60);
sf::Vector2f size14(60, 60);
sf::Vector2f size15(60, 60);
sf::Vector2f size16(60, 60);
sf::Vector2f size17(60, 60);
// *********************************************************************
// Get pos of every object
// *********************************************************************
// Trucks
sf::Vector2f objectPos = truck.getPosition();
sf::Vector2f objectPos2 = truck2.getPosition();
// Cars
sf::Vector2f objectPos3 = car.getPosition();
sf::Vector2f objectPos4 = car2.getPosition();
sf::Vector2f objectPos5 = car3.getPosition();
// Short Logs
sf::Vector2f objectPos6 = shortLog.getPosition();
sf::Vector2f objectPos7 = shortLog2.getPosition();
sf::Vector2f objectPos8 = shortLog3.getPosition();
// Long Logs
sf::Vector2f objectPos9 = longLog.getPosition();
sf::Vector2f objectPos10 = longLog2.getPosition();
// Lilypad
sf::Vector2f objectPos11 = lillypad.getPosition();
sf::Vector2f objectPos12 = lillypad2.getPosition();
sf::Vector2f objectPos13 = lillypad3.getPosition();
sf::Vector2f objectPos14 = lillypad4.getPosition();
sf::Vector2f objectPos15 = lillypad5.getPosition();
// *********************************************************************
// Sets boundary settings
// *********************************************************************
sf::Vector2f pos = frogger.getPosition();
// Frog
rect.setPosition(pos.x + 30 , pos.y +10);
rect.setSize(size);
rect.setFillColor(sf::Color::Transparent);
rect.setOutlineColor(sf::Color::Red);
rect.setOutlineThickness(5);
// Trucks
rect2.setPosition(objectPos.x + 40, objectPos.y + 20);
rect2.setSize(size2);
rect2.setFillColor(sf::Color::Transparent);
rect2.setOutlineColor(sf::Color::Red);
rect2.setOutlineThickness(5);
rect3.setPosition(objectPos2.x + 40, objectPos2.y + 60);
rect3.setSize(size3);
rect3.setFillColor(sf::Color::Transparent);
rect3.setOutlineColor(sf::Color::Red);
rect3.setOutlineThickness(5);
// Cars
rect4.setPosition(objectPos3.x + 45, objectPos3.y + 70);
rect4.setSize(size4);
rect4.setFillColor(sf::Color::Transparent);
rect4.setOutlineColor(sf::Color::Red);
rect4.setOutlineThickness(5);
rect5.setPosition(objectPos4.x + 50, objectPos4.y + 70);
rect5.setSize(size5);
rect5.setFillColor(sf::Color::Transparent);
rect5.setOutlineColor(sf::Color::Red);
rect5.setOutlineThickness(5);
rect6.setPosition(objectPos5.x + 50, objectPos5.y + 70);
rect6.setSize(size6);
rect6.setFillColor(sf::Color::Transparent);
rect6.setOutlineColor(sf::Color::Red);
rect6.setOutlineThickness(5);
// Short Logs
rect7.setPosition(objectPos6.x + 30, objectPos6.y + 80);
rect7.setSize(size7);
rect7.setFillColor(sf::Color::Transparent);
rect7.setOutlineColor(sf::Color::Red);
rect7.setOutlineThickness(5);
rect8.setPosition(objectPos7.x + 30, objectPos7.y + 80);
rect8.setSize(size8);
rect8.setFillColor(sf::Color::Transparent);
rect8.setOutlineColor(sf::Color::Red);
rect8.setOutlineThickness(5);
rect9.setPosition(objectPos8.x + 30, objectPos8.y + 80);
rect9.setSize(size9);
rect9.setFillColor(sf::Color::Transparent);
rect9.setOutlineColor(sf::Color::Red);
rect9.setOutlineThickness(5);
// Long Logs
rect10.setPosition(objectPos9.x + 35, objectPos9.y + 70);
rect10.setSize(size10);
rect10.setFillColor(sf::Color::Transparent);
rect10.setOutlineColor(sf::Color::Red);
rect10.setOutlineThickness(5);
rect11.setPosition(objectPos10.x + 35, objectPos10.y + 70);
rect11.setSize(size11);
rect11.setFillColor(sf::Color::Transparent);
rect11.setOutlineColor(sf::Color::Red);
rect11.setOutlineThickness(5);
// River
rect12.setPosition(0, 0);
rect12.setSize(size12);
rect12.setFillColor(sf::Color::Transparent);
rect12.setOutlineColor(sf::Color::Red);
rect12.setOutlineThickness(5);
// Lilypads
rect13.setPosition(objectPos11.x + 30, objectPos11.y+40);
rect13.setSize(size13);
rect13.setFillColor(sf::Color::Transparent);
rect13.setOutlineColor(sf::Color::Red);
rect13.setOutlineThickness(5);
rect14.setPosition(objectPos12.x + 30 , objectPos12.y+40);
rect14.setSize(size14);
rect14.setFillColor(sf::Color::Transparent);
rect14.setOutlineColor(sf::Color::Red);
rect14.setOutlineThickness(5);
rect15.setPosition(objectPos13.x + 30, objectPos13.y+40);
rect15.setSize(size15);
rect15.setFillColor(sf::Color::Transparent);
rect15.setOutlineColor(sf::Color::Red);
rect15.setOutlineThickness(5);
rect16.setPosition(objectPos14.x + 30 , objectPos14.y+40);
rect16.setSize(size16);
rect16.setFillColor(sf::Color::Transparent);
rect16.setOutlineColor(sf::Color::Red);
rect16.setOutlineThickness(5);
rect17.setPosition(objectPos15.x + 30 , objectPos15.y+40);
rect17.setSize(size17);
rect17.setFillColor(sf::Color::Transparent);
rect17.setOutlineColor(sf::Color::Red);
rect17.setOutlineThickness(5);
// *********************************************************************
// Frogger Hit Truck 1
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect2.getGlobalBounds()))
{
froggerTheme.pause();
trucked.play();
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
mainPlayer.setIsHit(true);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
froggerTheme.play();
//death.setPosition(-100,-100);
}
// *********************************************************************
// Frogger Hit Truck 2
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect3.getGlobalBounds()))
{
froggerTheme.pause();
trucked.play();
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
mainPlayer.setIsHit(true);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
sf::Vector2f pos = frogger.getPosition();
death.setPosition(pos);
froggerTheme.play();
death.setPosition(-100,-100);
}
// *********************************************************************
// Frogger Hit Car 1
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect4.getGlobalBounds()))
{
froggerTheme.pause();
trucked.play();
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
mainPlayer.setIsHit(true);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
sf::Vector2f pos = frogger.getPosition();
death.setPosition(pos);
froggerTheme.play();
death.setPosition(-100,-100);
}
// *********************************************************************
// Frogger Hit Car 2
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect5.getGlobalBounds()))
{
froggerTheme.pause();
trucked.play();
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
mainPlayer.setIsHit(true);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
sf::Vector2f pos = frogger.getPosition();
death.setPosition(pos);
froggerTheme.play();
death.setPosition(-100,-100);
}
// *********************************************************************
// Frogger Hit Car 3
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect6.getGlobalBounds()))
{
froggerTheme.pause();
trucked.play();
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
mainPlayer.setIsHit(true);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
sf::Vector2f pos = frogger.getPosition();
death.setPosition(pos);
froggerTheme.play();
death.setPosition(-100,-100);
}
// *********************************************************************
// Below this line will be log collision checking
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect7.getGlobalBounds()))
{
frogger.setPosition(objectPos6.x + 45 + sum2 , objectPos6.y + 80 + sum);
isOnLog = true;
}
else
{
isOnLog = false;
sum = 0;
sum2 = 0;
}
if (rect.getGlobalBounds().intersects(rect8.getGlobalBounds()))
{
frogger.setPosition(objectPos7.x + 45 + sum4, objectPos7.y + 80 + sum3);
isOnLog2 = true;
}
else
{
isOnLog2 = false;
sum3 = 0;
sum4 = 0;
}
if (rect.getGlobalBounds().intersects(rect9.getGlobalBounds()))
{
frogger.setPosition(objectPos8.x + 45+sum6, objectPos8.y + 80+sum5);
isOnLog3 = true;
}
else
{
isOnLog3 = false;
sum5 = 0;
sum6 = 0;
}
if (rect.getGlobalBounds().intersects(rect10.getGlobalBounds()))
{
frogger.setPosition(objectPos9.x + 45 + sum8, objectPos9.y + 70+ sum7);
isOnLog4 = true;
}
else
{
isOnLog4 = false;
sum7 = 0;
sum8 = 0;
}
if (rect.getGlobalBounds().intersects(rect11.getGlobalBounds()))
{
frogger.setPosition(objectPos10.x + 45+ sum10, objectPos10.y + 70+sum9);
isOnLog5 = true;
}
else
{
isOnLog5 = false;
sum9 = 0;
sum10 = 0;
}
// *********************************************************************
// Below this line will be lily collision checking
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect13.getGlobalBounds()))
{
isOnLily = true;
if (frogOnLily1 == false)
{
score += 50;
}
frogOnLily1 = true;
sf::Vector2f lilyPos = rect13.getPosition();
occupied1.setPosition(lilyPos);
}
if (rect.getGlobalBounds().intersects(rect14.getGlobalBounds()))
{
isOnLily = true;
if (frogOnLily2 == false)
{
score += 50;
}
frogOnLily2 = true;
sf::Vector2f lilyPos = rect14.getPosition();
occupied2.setPosition(lilyPos);
}
if (rect.getGlobalBounds().intersects(rect15.getGlobalBounds()))
{
isOnLily = true;
if (frogOnLily3 == false)
{
score += 50;
}
frogOnLily3 = true;
sf::Vector2f lilyPos = rect15.getPosition();
occupied3.setPosition(lilyPos);
}
if (rect.getGlobalBounds().intersects(rect16.getGlobalBounds()))
{
isOnLily = true;
if (frogOnLily4 == false)
{
score += 50;
}
frogOnLily4 = true;
sf::Vector2f lilyPos = rect16.getPosition();
occupied4.setPosition(lilyPos);
}
if (rect.getGlobalBounds().intersects(rect17.getGlobalBounds()))
{
isOnLily = true;
if (frogOnLily5 == false)
{
score += 50;
}
frogOnLily5 = true;
sf::Vector2f lilyPos = rect17.getPosition();
occupied5.setPosition(lilyPos);
}
// *********************************************************************
// Checks if frogger is on log AND goes outside screen boundaries
// if so frogger dies
// *********************************************************************
sf::Vector2f location = frogger.getPosition();
// Checks if frogger went out of bounds
if (rect.getGlobalBounds().intersects(rect12.getGlobalBounds()))
{
if ((isOnLog || isOnLog2 || isOnLog3 || isOnLog4 || isOnLog5) && (location.x >= 740 || location.x < -40))
{
mainPlayer.setIsHit(true);
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
}
}
// Checks if frogger is on the logs not the water
if (rect.getGlobalBounds().intersects(rect12.getGlobalBounds()))
{
if (isOnLog || isOnLog2 || isOnLog3 || isOnLog4 || isOnLog5)
{
//this frogger is on the logs not the water
}
else
{
froggerTheme.pause();
dunked.play();
froggerTheme.play();
mainPlayer.setIsHit(true);
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
}
}
// Checks if the frog has landed on a lilypad
if (isOnLily || isOnLily2 || isOnLily3 || isOnLily4 || isOnLily5)
{
// the frog has landed on the lily pad
froggerLanded = true;
}
// *********************************************************************
// Checks if the frog has landed on all 5 lilypads if so you win
// *********************************************************************
if (frogOnLily1 && frogOnLily2 && frogOnLily3 && frogOnLily4 && frogOnLily5)
{
score += 10000;
frogOnLily1 = false;
frogOnLily2 = false;
frogOnLily3 = false;
frogOnLily4 = false;
frogOnLily5 = false;
mainPlayer.setNumLives(3);
rectSource.width = 115;
life.setTextureRect(rectSource);
occupied1.setPosition(-100, -100);
occupied2.setPosition(-100, -100);
occupied3.setPosition(-100, -100);
occupied4.setPosition(-100, -100);
occupied5.setPosition(-100, -100);
froggerTheme.pause();
clock.restart();
timeRect.width = 143;
timer.setTextureRect(timeRect);
frogger.setPosition(320, 605);
return 2;
}
while (App.pollEvent(Event))
{
// Window closed
if (Event.type == sf::Event::Closed)
{
return (-1);
}
// *********************************************************************
// LEFT
// *********************************************************************
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
{
if (isOnLog)
{
sum2 = (sum2 + (20 * -1));
}
if (isOnLog2)
{
sum4 = (sum4 + (20 * -1));
}
if (isOnLog3)
{
sum6 = (sum6 + (20 * -1));
}
if (isOnLog4)
{
sum8 = (sum8 + (20 * -1));
}
if (isOnLog5)
{
sum10 = (sum10 + (20 * -1));
}
sf::Vector2f pos = frogger.getPosition();
if (pos.x < 0)
{
frogger.move(0, 0);
}
else
{
if (rectSourceSprite.left != 216)
{
rectSourceSprite.left = 216;
rectSourceSprite.width = 55;
frogger.setTextureRect(rectSourceSprite);
}
score += 10;
froggerTheme.setVolume(0);
hop.play();
frogger.move(-40, 0);
froggerTheme.setVolume(50);
}
}
// *********************************************************************
// RIGHT
// *********************************************************************
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
{
if (isOnLog)
{
sum2 = (sum2 + (20));
}
if (isOnLog2)
{
sum4 = (sum4 + (20));
}
if (isOnLog3)
{
sum6 = (sum6 + (20));
}
if (isOnLog4)
{
sum8 = (sum8 + (20));
}
if (isOnLog5)
{
sum10 = (sum10 + (20));
}
sf::Vector2f pos = frogger.getPosition();
if (pos.x >= 640)
{
frogger.move(0, 0);
}
else
{
if (rectSourceSprite.left != 89)
{
rectSourceSprite.left = 89;
rectSourceSprite.width = 60;
frogger.setTextureRect(rectSourceSprite);
}
score += 10;
froggerTheme.setVolume(0);
hop.play();
frogger.move(40, 0);
froggerTheme.setVolume(50);
}
}
// *********************************************************************
// UP
// *********************************************************************
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
{
if (isOnLog)
{
sum = (sum + (20 * -1));
}
if (isOnLog2)
{
sum3 = (sum3 + (20 * -1));
}
if (isOnLog3)
{
sum5 = (sum5 + (20 * -1));
}
if (isOnLog4)
{
sum7 = (sum7 + (20 * -1));
}
if (isOnLog5)
{
sum9 = (sum9 + (20 * -1));
}
if (pos.y <= -35)
{
frogger.move(0, 0);
}
else
{
if (rectSourceSprite.left != 0)
{
rectSourceSprite.left = 0;
rectSourceSprite.width = 89;
frogger.setTextureRect(rectSourceSprite);
}
score += 10;
froggerTheme.setVolume(0);
hop.play();
frogger.move(0, -40);
froggerTheme.setVolume(50);
}
}
// *********************************************************************
// DOWN
// *********************************************************************
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
{
if (isOnLog)
{
sum = (sum + 20);
}
if (isOnLog2)
{
sum3 = (sum3 + 20);
}
if (isOnLog3)
{
sum5 = (sum5 + 20);
}
if (isOnLog4)
{
sum7 = (sum7 + 20);
}
if (isOnLog5)
{
sum9 = (sum9 + 20);
}
sf::Vector2f pos = frogger.getPosition();
if (pos.y >= 650)
{
frogger.move(0, 0);
}
else
{
if (rectSourceSprite.left != 149)
{
rectSourceSprite.left = 149;
rectSourceSprite.width = 67;
frogger.setTextureRect(rectSourceSprite);
}
score += 10;
froggerTheme.setVolume(0);
hop.play();
frogger.move(0, 40);
froggerTheme.setVolume(50);
}
}
}
// *********************************************************************
// Checks if player has been hit
// *********************************************************************
if (mainPlayer.getIsHit() == true)
{
cout << " Number of lives" << mainPlayer.getNumLives() << endl;
mainPlayer.setIsHit(false);
rectSourceSprite.left = 0;
rectSourceSprite.width = 89;
frogger.setTextureRect(rectSourceSprite);
frogger.setPosition(320, 605);
}
// *********************************************************************
// Checks if player landed on lily
// *********************************************************************
if (froggerLanded == true)
{
froggerLanded = false;
rectSourceSprite.left = 0;
rectSourceSprite.width = 89;
frogger.setTextureRect(rectSourceSprite);
frogger.setPosition(320, 605);
isOnLily = false;
isOnLily2 = false;
isOnLily3 = false;
isOnLily4 = false;
isOnLily5 = false;
}
// *********************************************************************
// Checks if player has run out of lives
// *********************************************************************
if (mainPlayer.getNumLives() < 1)
{
frogOnLily1 = false;
frogOnLily2 = false;
frogOnLily3 = false;
frogOnLily4 = false;
frogOnLily5 = false;
mainPlayer.setNumLives(3);
rectSource.width = 115;
life.setTextureRect(rectSource);
occupied1.setPosition(-100, -100);
occupied2.setPosition(-100, -100);
occupied3.setPosition(-100, -100);
occupied4.setPosition(-100, -100);
occupied5.setPosition(-100, -100);
froggerTheme.pause();
clock.restart();
timeRect.width = 143;
timer.setTextureRect(timeRect);
frogger.setPosition(320, 605);
return 2;
}
App.clear(sf::Color(0, 0, 0, 0));
//Drawing
App.draw(background);
App.draw(car2);
App.draw(car3);
App.draw(truck2);
App.draw(truck);
App.draw(car);
App.draw(longLog);
App.draw(longLog2);
App.draw(shortLog);
App.draw(shortLog2);
App.draw(shortLog3);
App.draw(lillypad);
App.draw(lillypad2);
App.draw(lillypad3);
App.draw(lillypad4);
App.draw(lillypad5);
App.draw(life);
App.draw(timer);
App.draw(frogger);
App.draw(occupied1);
App.draw(occupied2);
App.draw(occupied3);
App.draw(occupied4);
App.draw(occupied5);
// *********************************************************************
// The following are for testing purposes only
// Draws the boundary box
// *********************************************************************
App.draw(rect);
App.draw(rect2);
App.draw(rect3);
App.draw(rect4);
App.draw(rect5);
App.draw(rect6);
App.draw(rect7);
App.draw(rect8);
App.draw(rect9);
App.draw(rect10);
App.draw(rect11);
App.draw(rect12);
App.draw(rect13);
App.draw(rect14);
App.draw(rect15);
App.draw(rect16);
App.draw(rect17);
App.display();
}
//Never reaching this point normally, but just in case, exit the application
return -1;
}
int main(void)
{
// Update Überprüfung
stringstream updateVerfuegbarText;
updateVerfuegbarText << "Robber " << ROBBER_VERSION;
if(newVersionAvailable())
{
// Neue Version verfügbar!
cout << endl << "! Es steht eine Aktualisierung des Spiels zum Herunterladen bereit !" << endl << endl;
updateVerfuegbarText << " (Update verfuegbar: " << LATEST_VERSION << " )";
}
else
{
// Keine neue Version verfügbar
cout << endl << "Das Spiel läuft in der aktuellsten Version!" << endl << endl;
}
// Fenster- und Grafikeinstellungen
sf::VideoMode aufloesung = sf::VideoMode::getDesktopMode();
// Musik loopen!
musik.setLoop(true);
// Fenster erstellen
#ifndef LINUX
// Nur Windows
sf::RenderWindow fenster(aufloesung, "Robber", sf::Style::None);
#else
// Nur Linux
sf::RenderWindow fenster(aufloesung, "Robber", sf::Style::Fullscreen);
#endif
// Fensterreferenz erstellen!
globalFenster = &fenster;
// Maximal 50 FPS
fenster.setFramerateLimit(50);
// vsync!
fenster.setVerticalSyncEnabled(true);
// Cursor off!
fenster.setMouseCursorVisible(false);
// SFML View erstellen!
sf::View ansicht(sf::FloatRect(0,0, aufloesung.width, aufloesung.height));
// Anzeigebereich festlegen
ansicht.setViewport(sf::FloatRect(0,0, 1, 1));
fenster.setView(ansicht);
// AnimationList vorbereiten
list<animation *> animationList;
// Renderlist vorbereiten
list<sf::Drawable *> renderList;
// Hintergrundbild
sf::Texture* hintergrundTextur = 0x0;
sf::Sprite* hintergrund = 0x0;
// Globale Schriftart laden!
standardSchriftart.loadFromFile("resources/DejaVuSans.ttf");
// Hauptmenü laden!
aktuellesLevel = levelLaden("hauptmenu");
aktuellesLevel->loadToScreen(hintergrundTextur, hintergrund, renderList, animationList);
// Version im Spiel anzeigen!
benachrichtigung version(updateVerfuegbarText.str(), 25, 25, 20);
renderList.push_back((sf::Drawable *)&version.text);
// DebugMsg anzeigen!
renderList.push_back((sf::Drawable *)&debugMsg.text);
// DebugMsg2 anzeigen!
renderList.push_back((sf::Drawable *)&debugMsg2.text);
// Benachrichtigung für Zeit erstellen
benachrichtigung zeit("Zeit", 25, 150, 20);
// Zeit nur anzeigen, wenn man nicht im Hauptmenü und nicht "Game Over" ist
if(aktuellesLevel->name != "hauptmenu" && aktuellesLevel->name != "gameOver")
{
renderList.push_back((sf::Drawable *)&zeit.text);
}
// Benachrichtigung für Punkte erstellen
benachrichtigung anzahlPunkte("0 Punkte", 25, 125, 20);
if(aktuellesLevel->name != "hauptmenu" && aktuellesLevel->name != "gameOver")
{
renderList.push_back((sf::Drawable *)&anzahlPunkte.text);
}
// Entwicklernachricht anzeigen
debugMsg.updateText("Game running in Debug Mode!");
// Benachrichtigung für Lärm erstellen
benachrichtigung schall("Lärm", 25, 175, 20);
if(aktuellesLevel->name != "hauptmenu" && aktuellesLevel->name != "gameOver")
{
renderList.push_back((sf::Drawable *)&schall.text);
}
// Konsole erstellen!
console::eingabeFeld.setFont(standardSchriftart);
console::eingabeFeld.setColor(sf::Color::Red);
console::eingabeFeld.setCharacterSize(20);
// Konsole anzeigen lassen!
renderList.push_back((sf::Drawable *)&console::eingabeFeld);
// Spielertextur laden!
sf::Texture spielerTexture;
sf::Sprite spieler;
spielerTexture.loadFromFile("resources/spieler.png");
// Spielertextur zuordnen
spieler.setTexture(spielerTexture);
// Textur auf 1/4 Fläche verkleinern
spieler.setScale(0.5, 0.5);
// Mitt des Spielers für sämtliche Rotationen (Rotation, Translation)
spieler.setOrigin(sf::Vector2f(50, 50));
// Spieler auf Startposition setzen
spieler.setPosition(aktuellesLevel->spielerPosition);
// Spieler immer anzeigen!
renderList.push_back(&spieler);
// Dunkles Fenster um den Spieler (für dunkle Levels)
sf::Texture dunkelTextur;
sf::Sprite dunkel;
dunkelTextur.loadFromFile("resources/Dunkel.png");
// Dunkeltextur zuordnen
dunkel.setTexture(dunkelTextur);
// Zentrum der Dunkelheit ist auf dem Spieler
dunkel.setOrigin(960*2, 540*2);
// Dunkelheit mitverschieben
dunkel.setPosition(spieler.getPosition());
// Schallpegel: Am Anfang = 0
float schallPegel = 0;
// Standardposition (ist nicht wichtig)
sf::Vector2i schallPosition(25, 25);
int sX = fenster.mapPixelToCoords(schallPosition).x;
int sY = fenster.mapPixelToCoords(schallPosition).y;
// Animation für Schallmesser erstellen
animation schallAnimation("resources/schall", 11, false, false, true, 1, sX, sY);
// Mitte des Bildes ist Zentrum
schallAnimation.sprite.setOrigin(75,75);
// Animation wird hizugefügt: Muss nicht wiederholt werden.
animationList.push_back(&schallAnimation);
// Zoombegrenzung
int zoomLevel = 0;
// Input delay
sf::Clock verzoegerung;
// Musik
string vorherigesLevel = "hauptmenu";
hintergrundMusik("hauptmenu");
// rand initialisieren (Zufallsseed aus der Zeit lesen)
srand(time(0x0));
sf::Sound schritt;
sf::SoundBuffer schrittbuffer;
schrittbuffer.loadFromFile("resources/sound/Schritte.wav");
schritt.setBuffer(schrittbuffer);
schritt.play();
schritt.setLoop(true);
// Solange das Fenster geöffnet ist:
while(fenster.isOpen())
{
// Hat sich das Level geändert?
if(aktuellesLevel->name != vorherigesLevel)
{
// Je nach Level entsprechende Musik abspielen
if(aktuellesLevel->name == "hauptmenu")
{
hintergrundMusik("hauptmenu");
musik.setVolume(50);
}
else if(aktuellesLevel->name == "gameOver")
{
hintergrundMusik("gameover");
musik.setVolume(50);
}
else
{
// Wenn weder Menü noch Gameover -> main Musik
hintergrundMusik("main");
musik.setVolume(100);
}
// Zum Überprüfen nächstes Mal
vorherigesLevel = aktuellesLevel->name;
}
// Eingabeüberprüfung!
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
{
// Bei Escape Hauptmenü laden
// Gespeicherte Levels zurücksetzen
for(auto l: levelListe)
{
cout << "Level '" << l.first << "' aus Speicher entfernt\n";
delete l.second;
}
cout << "Alle " << levelListe.size() << " Level entfernt\n";
levelListe.clear();
// Punkte zurücksetzen
spiel.punkte = 0;
aktuellesLevel = levelLaden("hauptmenu");
aktuellesLevel->loadToScreen(hintergrundTextur, hintergrund, renderList, animationList);
// Spieler in die hauptmenu Level positionieren
spieler.setPosition(520, 375);
// Den Spieler wieder anzeigen
renderList.push_back(&spieler);
renderList.push_back((sf::Drawable *)&version.text);
renderList.push_back((sf::Drawable *)&debugMsg.text);
renderList.push_back((sf::Drawable *)&debugMsg2.text);
renderList.push_back((sf::Drawable *)&console::eingabeFeld);
}
// Kollisionsdetektion
sf::FloatRect spielerEcken = spieler.getGlobalBounds();
// Zoom erneut auf 1 setzen
float zoom = 1.0f;
// Input loop
// Nur wenn Konsole nicht aktiviert!
if(!console::activated)
{
if(aktuellesLevel->name != "gameOver")
{
//rennen: doppelt so schnell, dafür aber laut
int s;
if(sf::Keyboard::isKeyPressed(sf::Keyboard::LShift))
{
s = 10;
}
else
{
s = 5;
}
// Nur in eine Richtung auf einmal!
// Nach vorne
if(sf::Keyboard::isKeyPressed(sf::Keyboard::W))
{
// Zuerst Kollision überprüfen!
spielerEcken.top -= s;
if(s == 10 && aktuellesLevel->dunkel)
schallPegel += 0.05;// schallpegel wird höher beim rennen
if(aktuellesLevel->checkCollision(spielerEcken))
{
// Nicht bewegen!
spielerEcken.top += s;
}
else
{
// Bewegen!
spieler.setRotation(0);
spieler.move(0, -s);
}
}
else
// Nach links
if(sf::Keyboard::isKeyPressed(sf::Keyboard::A))
{
spielerEcken.left-=s;
if(s == 10 && aktuellesLevel->dunkel)
schallPegel += 0.05;// schallpegel wird höher beim rennen
if(aktuellesLevel->checkCollision(spielerEcken))
{
spielerEcken.left +=s;
}
else
{
spieler.setRotation(270);
spieler.move(-s, 0);
}
}
// Nach hinten
else if(sf::Keyboard::isKeyPressed(sf::Keyboard::S))
{
// Zuerst Kollision überprüfen!
spielerEcken.top += s;
if(s == 10 && aktuellesLevel->dunkel)
schallPegel += 0.05;// schallpegel wird höher beim rennen
if(aktuellesLevel->checkCollision(spielerEcken))
{
// Nicht bewegen!
spielerEcken.top -= s;
}
else
{
// Bewegen!
spieler.setRotation(180);
spieler.move(0, s);
}
}
else
// Nach rechts
if(sf::Keyboard::isKeyPressed(sf::Keyboard::D))
{
spielerEcken.width +=s;
if(s == 10 && aktuellesLevel->dunkel)
schallPegel += 0.05;// schallpegel wird höher beim rennen
if(aktuellesLevel->checkCollision(spielerEcken))
{
spielerEcken.width -=s;
}
else
{
spieler.setRotation(90);
spieler.move(s, 0);
}
}
// Kollision überprüfen
if(aktuellesLevel->checkCollision(spielerEcken))
{
spieler.move(5, 5);
}
// Reinzoomen (Begrenzung beachten)
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Num0))
{
if(zoomLevel > -10)
{
zoom -= 0.05;
zoomLevel--;
ansicht.zoom(zoom);
}
}
// Rauszoomen (Begrenzung beachten)
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Num9))
{
if(zoomLevel < 10)
{
zoom += 0.05;
zoomLevel++;
ansicht.zoom(zoom);
}
}
// Dunk8les Overlay wandert mit dem Spieler mit
dunkel.setPosition(spieler.getPosition());
}
float minAbstand=10000;
for(int i=0; i < aktuellesLevel->gegenspielers.size(); i++)
{
float abstand = aktuellesLevel->gegenspielers[i]->schrittAbstand(spielerEcken);
if(abstand < minAbstand)
{
minAbstand = abstand;
}
}
if(minAbstand < 400)
{
float vol = 100 - minAbstand/4;
if(vol < 0)
vol = 0;
else if(vol > 100)
vol = 100;
schritt.setVolume(100 - minAbstand/4);
}
// "Spiel beenden"-Feld möglich machen
if(aktuellesLevel->name == "hauptmenu")
{
sf::FloatRect spielEnde;
spielEnde = sf::FloatRect(50, 400, 370, 60);
// Beim Überschneiden -> Fenster schliessen, Schleife wird verlassen, Spiel beendet
if(spielEnde.intersects(spielerEcken))
{
fenster.close();
}
}
// Auf Pfeile achten: -> Wenn ja, wohin Teleportieren?
int pfeilNummer = aktuellesLevel->checkCollisionPfeile(spielerEcken);
// Wenn mit Pfeil geschnitten
if(pfeilNummer != -1)
{
if(aktuellesLevel->pfeile[pfeilNummer]->farbe != 0 || (aktuellesLevel->pfeile[pfeilNummer]->farbe == 0 && spiel.gewonnen == true))
{
// Lese x/y Koordinaten heraus, bevor sie verworfen werden!
float spielerX = aktuellesLevel->pfeile[pfeilNummer]->nX;
float spielerY = aktuellesLevel->pfeile[pfeilNummer]->nY;
// Neues Level laden
aktuellesLevel = levelLaden(aktuellesLevel->pfeile[pfeilNummer]->nLevel); // neuer Level wird durch den jeweiligen Pfeil bestummen
// Neues Level anzeigen
aktuellesLevel->loadToScreen(hintergrundTextur, hintergrund, renderList, animationList);
// Spieler an die dem i-ten Pfeil zugehörigen Position im neuen Level positionieren
spieler.setPosition(spielerX, spielerY);
// Wenn das Level dunkel ist
if(aktuellesLevel->dunkel)
{
if(aktuellesLevel->Wert == 1)
dunkelTextur.loadFromFile("resources/DunkelDecke.png");
else
dunkelTextur.loadFromFile("resources/Dunkel.png");
renderList.push_back(&dunkel);
renderList.push_back(&schallAnimation.sprite);
schallPegel = 0; // zurücksetzen
}
// Spieler und Benachrichtigungen wieder anzeigen
renderList.push_back(&spieler);
renderList.push_back((sf::Drawable *)&zeit.text);
renderList.push_back((sf::Drawable *)&anzahlPunkte.text);
renderList.push_back((sf::Drawable *)&version.text);
renderList.push_back((sf::Drawable *)&debugMsg.text);
renderList.push_back((sf::Drawable *)&debugMsg2.text);
renderList.push_back((sf::Drawable *)&console::eingabeFeld);
// Zeit für das Level zurücksetzen
Uhr.restart();
}
}
// Schätze einsammeln
if(sf::Keyboard::isKeyPressed(sf::Keyboard::E) && verzoegerung.getElapsedTime().asSeconds() > 0.2)
{
int schaetzeNummer = aktuellesLevel->checkCollisionSchaetze(spielerEcken);
if(schaetzeNummer != -1 && aktuellesLevel->schaetze[schaetzeNummer]->s->istBeendet() && !aktuellesLevel->schaetze[schaetzeNummer]->eingesammelt)
{
renderList.remove(&aktuellesLevel->schaetze[schaetzeNummer]->s->sprite);
aktuellesLevel->schaetze[schaetzeNummer]->eingesammelt = true;
spiel.punkteHinzufuegen(10);
}
// Türe in der Nähe finden!
int tuereNummer = aktuellesLevel->checkCollisionTuere(spielerEcken);
// Türe nur öffnen wenn die, die in der Nähe ist, nicht gerade am Öffnen ist
if(tuereNummer != -1 && aktuellesLevel->tueren[tuereNummer]->t->istBeendet())
{
// Wenn tuere aufgeht ist es laut
schallPegel += 1;
float Ux = aktuellesLevel->tueren[tuereNummer]->posX;
float Uy = aktuellesLevel->tueren[tuereNummer]->posY;
// Neue Mauernkoordinaten berechnen!
// Fall 1: Rotation der Türe: 0°
if(aktuellesLevel->tueren[tuereNummer]->t->sprite.getRotation() == 0)
{
if(aktuellesLevel->tueren[tuereNummer]->offen)//tuere geschlossen -> tuere offen
{
aktuellesLevel->mauern.remove(sf::FloatRect(Ux-7, Uy-7, 193, 14));
aktuellesLevel->mauern.push_back(sf::FloatRect(Ux-7, Uy-186, 14, 193));
}
else //tuere offen -> türe geschlossen
{
aktuellesLevel->mauern.remove(sf::FloatRect(Ux-7, Uy-186, 14, 193));
aktuellesLevel->mauern.push_back(sf::FloatRect(Ux-7, Uy-7, 193, 14));
}
}
else if((aktuellesLevel->tueren[tuereNummer]->t->sprite.getRotation())-360 == -90)
{
if(aktuellesLevel->tueren[tuereNummer]->offen)//tuere geschlossen -> tuere offen
{
aktuellesLevel->mauern.remove(sf::FloatRect(Ux-7, Uy-186, 14, 193));
aktuellesLevel->mauern.push_back(sf::FloatRect(Ux-186, Uy-7, 193, 14));
}
else //tuere offen -> türe geschlossen
{
aktuellesLevel->mauern.remove(sf::FloatRect(Ux-186, Uy-7, 193, 14));
aktuellesLevel->mauern.push_back(sf::FloatRect(Ux-7, Uy-186, 14, 193));
}
}
else if(aktuellesLevel->tueren[tuereNummer]->t->sprite.getRotation()-360 == -180)
{
if(aktuellesLevel->tueren[tuereNummer]->offen)//tuere geschlossen -> tuere offen
{
aktuellesLevel->mauern.remove(sf::FloatRect(Ux-186, Uy-7, 193, 14));
aktuellesLevel->mauern.push_back(sf::FloatRect(Ux-7, Uy-7, 14, 193));
}
else //tuere offen -> türe geschlossen
{
aktuellesLevel->mauern.remove(sf::FloatRect(Ux-7, Uy-7, 14, 193));
aktuellesLevel->mauern.push_back(sf::FloatRect(Ux-186, Uy-7, 193, 14));
}
}
else if(aktuellesLevel->tueren[tuereNummer]->t->sprite.getRotation()-360 == -270)
{
if(aktuellesLevel->tueren[tuereNummer]->offen)//tuere geschlossen -> tuere offen
{
aktuellesLevel->mauern.remove(sf::FloatRect(Ux-7, Uy-7, 14, 193));
aktuellesLevel->mauern.push_back(sf::FloatRect(Ux-7, Uy-7, 193, 14));
}
else //tuere offen -> türe geschlossen
{
aktuellesLevel->mauern.remove(sf::FloatRect(Ux-7, Uy-7, 193, 14));
aktuellesLevel->mauern.push_back(sf::FloatRect(Ux-7, Uy-7, 14, 193));
}
}
// Animation abspielen
aktuellesLevel->tueren[tuereNummer]->t->setRichtung(aktuellesLevel->tueren[tuereNummer]->offen);
aktuellesLevel->tueren[tuereNummer]->t->start();
aktuellesLevel->tueren[tuereNummer]->offen = !aktuellesLevel->tueren[tuereNummer]->offen;
}
// Zeit für Eingabeverzögerung zurücksetzen
verzoegerung.restart();
}
}
// Wenn die Konsole nocht nicht aktiviert ist -> Aktivieren wenn RShift gedrückt
if(!console::activated && sf::Keyboard::isKeyPressed(sf::Keyboard::RShift))
{
if(!console::activated)
{
showConsole();
}
}
// Wenn die Konsole aber aktiviert ist
if(console::activated && sf::Keyboard::isKeyPressed(sf::Keyboard::Return))
{
string befehl = console::eingabeText.str();
// Debug: Befehl in der Kommandozeile ausgeben
cout << "Ausfuehren: '" << befehl << "'" << endl;
// Befehle auslesen
if(befehl == "9990")
{
// 9990 cheat
debugMsg2.updateText("----- LOL -----");
}
else if(befehl == "toggleWalls")
{
// Wände umschalten
aktuellesLevel->collisionsActivated = (!aktuellesLevel->collisionsActivated);
}
else if(befehl.find("loadLevel ") == 0)
{
// Levelname auslesen
aktuellesLevel->name = befehl.substr(befehl.find("loadLevel ") + 10);
// Neues Level laden
aktuellesLevel = levelLaden(aktuellesLevel->name);
// Debugnachricht anzeigen
cerr << "Lade: '" << aktuellesLevel->name << "'" << endl;
// Level anzeigen
aktuellesLevel->loadToScreen(hintergrundTextur, hintergrund, renderList, animationList);
// Neue Spielerposition setzen!
spieler.setPosition(aktuellesLevel->spielerPosition);
// Wenn es dunkel ist -> Overlay anzeigen
if(aktuellesLevel->dunkel)
{
renderList.push_back(&dunkel);
renderList.push_back(&schallAnimation.sprite);
}
// Spieler und Labels wieder anzeigen!
renderList.push_back(&spieler);
renderList.push_back((sf::Drawable *)&zeit.text);
renderList.push_back((sf::Drawable *)&anzahlPunkte.text);
renderList.push_back((sf::Drawable *)&version.text);
renderList.push_back((sf::Drawable *)&debugMsg.text);
renderList.push_back((sf::Drawable *)&debugMsg2.text);
renderList.push_back((sf::Drawable *)&console::eingabeFeld);
// Uhr für Levelzeit neustarten
Uhr.restart();
schallPegel = 0;
}
else if(befehl == "dunkel")
{
if(dunkelBefehl == true)
renderList.remove(&dunkel);
else
{
if(aktuellesLevel->dunkel)
{
renderList.remove(&dunkel);
renderList.remove(&schallAnimation.sprite);
}
// Spieler und Labels wieder anzeigen!
renderList.remove(&spieler);
renderList.remove((sf::Drawable *)&zeit.text);
renderList.remove((sf::Drawable *)&anzahlPunkte.text);
renderList.remove((sf::Drawable *)&version.text);
renderList.remove((sf::Drawable *)&debugMsg.text);
renderList.remove((sf::Drawable *)&debugMsg2.text);
renderList.remove((sf::Drawable *)&console::eingabeFeld);
if(aktuellesLevel->dunkel)
{
renderList.push_back(&dunkel);
renderList.push_back(&schallAnimation.sprite);
}
// Spieler und Labels wieder anzeigen!
renderList.push_back(&spieler);
renderList.push_back((sf::Drawable *)&zeit.text);
renderList.push_back((sf::Drawable *)&anzahlPunkte.text);
renderList.push_back((sf::Drawable *)&version.text);
renderList.push_back((sf::Drawable *)&debugMsg.text);
renderList.push_back((sf::Drawable *)&debugMsg2.text);
renderList.push_back((sf::Drawable *)&console::eingabeFeld);
}
dunkelBefehl = !dunkelBefehl;
}
else if(befehl == "exit")
{
fenster.close();
}
// Wenn "Enter" gedrückt und Befehl eingelesen -> Konsole zurücksetzen und verstecken
hideConsole();
}
// Event Poll! (Fenster schliessen, etc.)
sf::Event event;
while(fenster.pollEvent(event))
{
// Schliessen per "Kreuzchen" (x)
if(event.type == sf::Event::Closed)
{
fenster.close();
}
else
if(console::activated && event.type == sf::Event::TextEntered)
{
// Wenn Konsole aktiviert, Eingabe lesen!
updateConsole(static_cast<char>(event.text.unicode));
}
}
// Weil es keinen animationsschritt über 10 gibt -> Zurücksetzen
if(schallPegel > 10)
schallPegel = 10;
// Mit static_cast<int>: float -> int
schallAnimation.zeigeSchritt(static_cast<int>(schallPegel));
// Ansicht anpassen! (Neu zentrieren)
ansicht.setCenter(spieler.getPosition());
fenster.setView(ansicht);
// "Fixe" Benachrichtigungen neu setzen
sf::Vector2i versionPosition(25, 25);
sf::Vector2i debugPosition(25, 50);
sf::Vector2i debug2Position(25, 75);
sf::Vector2i consolePosition(25, 100);
sf::Vector2i zeitPosition(25, 125);
sf::Vector2i anzahlPunktePosition(25, 150);
// Koordinatentransformation: Bildschirm -> Fenster
version.text.setPosition(fenster.mapPixelToCoords(versionPosition));
debugMsg.text.setPosition(fenster.mapPixelToCoords(debugPosition));
debugMsg2.text.setPosition(fenster.mapPixelToCoords(debug2Position));
console::eingabeFeld.setPosition(fenster.mapPixelToCoords(consolePosition));
zeit.text.setPosition(fenster.mapPixelToCoords(zeitPosition));
anzahlPunkte.text.setPosition(fenster.mapPixelToCoords(anzahlPunktePosition));
// Position des Schallmessers auf dem Bildschirm
sf::Vector2i schallPosition(100, 600);
// Koordinatentransformation: Bildschirm -> Fenster
float sX = fenster.mapPixelToCoords(schallPosition).x;
float sY = fenster.mapPixelToCoords(schallPosition).y;
// Schallmesser setzen
schallAnimation.sprite.setPosition(sX, sY);
// Animation Loop
// = Alle Animationen ausführen, sodass das nächste Bild geladen wird
for(animation* a : animationList)
{
a->animationAusfuehren();
}
// SFML: Fenster leeren!
fenster.clear();
for(auto object : renderList)
{
// Jedes Objekt anzeigen
fenster.draw(*object);
}
// Fensterinhalt anzeigen
fenster.display();
// Debugstring aktualisieren
stringstream debugMsgText;
debugMsgText << "Spielerposition: " << spieler.getPosition().x << ", " << spieler.getPosition().y;
debugMsg.updateText(debugMsgText.str());
// Gegenspieler bewegen
for(gegenspieler* g : aktuellesLevel->gegenspielers)
{
g->bewegen();
}
// Punkte aktualisieren
stringstream anzahlPunkteAnzeige;
anzahlPunkteAnzeige << "Punkte: " << spiel.punkte;
anzahlPunkte.updateText(anzahlPunkteAnzeige.str());
// Gegenspielerkontakt -> GameOver
for(gegenspieler* g : aktuellesLevel->gegenspielers)
{
float dX = abs(g->sprite.getPosition().x - spieler.getPosition().x);
float dY = abs(g->sprite.getPosition().y - spieler.getPosition().y);
if(sqrt(dX*dX + dY*dY) < 120)
{
// Punkte zurücksetzen
spiel.punkte = 0;
cerr << "GAME OVER: GRUND 3" << endl;
// Neues Level laden und anzeigen
aktuellesLevel = levelLaden("gameOver"); // Wegen dem geht man GameOver ohne dass etwas passiert ist
aktuellesLevel->loadToScreen(hintergrundTextur, hintergrund, renderList, animationList);
// Hintergrund neu positionieren
hintergrund->setOrigin(0, 0);
// Spieler in Mitte setzen
spieler.setPosition(960, 540);
// Schall zurücksetzen
schallPegel = 0;
// Konsole wieder anzeigen, nachdem renderListe geleert wurde
renderList.push_back((sf::Drawable *)&console::eingabeFeld);
}
}
//Wenn der Pegel im roten Bereich ist, ist nicht sofort gameOver sondern erst nach einer Zufallszeit
int Zufall = rand() % 200;
if(schallPegel >= 7 && Zufall == 199)
{
// Punkte zurücksetzen
spiel.punkte = 0;
cerr << "GAME OVER: GRUND 2" << endl;
// Neues Level laden und anzeigen
aktuellesLevel = levelLaden("gameOver"); // Wegen dem geht man GameOver ohne dass etwas passiert ist
aktuellesLevel->loadToScreen(hintergrundTextur, hintergrund, renderList, animationList);
// Hintergrund neu positionieren
hintergrund->setOrigin(0, 0);
// Spieler in Mitte setzen
spieler.setPosition(960, 540);
// Schall zurücksetzen
schallPegel = 0;
// Konsole wieder anzeigen, nachdem renderListe geleert wurde
renderList.push_back((sf::Drawable *)&console::eingabeFeld);
}
if(schallPegel > 0)
{
//Pegel nimmt mit der Zeit wieder ab
schallPegel -= 0.005;
}
// Zeit aktualisieren
int verbleibendeZeit;
if(aktuellesLevel->Zeit.asSeconds() >= 0.5) // t
{
verbleibendeZeit = aktuellesLevel->Zeit.asSeconds() - Uhr.getElapsedTime().asSeconds();
if(aktuellesLevel->checkCollisionLaser(spielerEcken) == true ??!??! verbleibendeZeit < 0)
{
spiel.punkte = 0;
schallPegel = 0;
cerr << "GAME OVER: GRUND 1" << endl;
aktuellesLevel = levelLaden("gameOver");
aktuellesLevel->loadToScreen(hintergrundTextur, hintergrund, renderList, animationList);
hintergrund->setOrigin(0, 0);
spieler.setPosition(960, 540);
//ansicht.setCenter(fenster.mapPixelToCoords(sf::Vector2i(960, 540)));
renderList.push_back((sf::Drawable *)&console::eingabeFeld);
}
stringstream zeitAnzeige;
zeitAnzeige << "Zeit: " << verbleibendeZeit << " s";
zeit.updateText(zeitAnzeige.str());
}
else
{
void ambiance::tick(int madness)
{
ambMadness = 101-madness;
ambMaxVolume = 100;
// SO THE ENGINE BEGINS //
// IF NOT PLAYING AA ///////////////////////////////////////////////////
if (ALLambAA[ambAARandom].getStatus() == 0)
{
// FILE SELECTOR //
ambAARandom = rand()% ARRAY_SIZE(ambAAFile);
//ALLambAA[ambAARandom].openFromFile(ambAAFile[ambAARandom]);
// VOLUME RESET //
ALLambAA[ambAARandom].setVolume(0);
ambAAVolume = 0;
ambAADynamics = 100000;
// LENGTH //
ambAALength = rand() % 60 + 40;
ambAASecCounter = 0;
// FADE //
ambAAFadeSpeed = rand()% 2 + 3;
ambAAFadeOut = false;
// PITCH //
ambAAPitch = rand() % 100;
ambAAPitch = ambAAPitch/200+0.75;
ALLambAA[ambAARandom].setPitch(ambAAPitch);
// PLAY //
ALLambAA[ambAARandom].play();
}
// IF NOT PLAYING AB /////////////////////////////////////////////////////////
if (ALLambAB[ambABRandom].getStatus() == 0)
{
// FILE SELECTOR //
ambABRandom = rand()% ARRAY_SIZE(ambABFile);
//ALLambAB[ambABRandom].openFromFile(ambABFile[ambABRandom]);
// VOLUME RESET //
ALLambAB[ambABRandom].setVolume(0);
ambABVolume = 0;
ambABDynamics = 100000;
// LENGTH //
ambABLength = rand() % 30 + 30;
ambABSecCounter = 0;
// FADE //
ambABFadeSpeed = rand()% 2 + 3;
ambABFadeOut = false;
// PITCH //
ambABPitch = rand() % 100;
ambABPitch = ambABPitch/200+0.75;
ALLambAB[ambABRandom].setPitch(ambABPitch);
// PLAY //
ALLambAB[ambABRandom].play();
}
// FADE AA ////////////////////////////////////////////////////////////////
// COUNTERS //
ambAAFrameCounter++;
if (ambAAFrameCounter>60)
{
ambAAFrameCounter = 0;
ambAASecCounter++;
}
// FADE //
if (ALLambAB[ambABRandom].getStatus() == 2)
{
ambAADynamics = 10000*(ambMadness*0.25/100) + 2500;
// FADE VOLUME UP //
if (ambAAVolume + ambAAFadeSpeed < ambAADynamics && ambAAFadeOut == false)
{
ambAAVolume = ambAAVolume + ambAAFadeSpeed;
ambAAIntToFloat = ambAAVolume;
ALLambAA[ambAARandom].setVolume(ambAAIntToFloat/100*(ambMaxVolume/100));
}
// FADE VOLUME DOWN //
else if (ambAAVolume > ambAADynamics && ambAAFadeOut == false)
{
ambAAVolume = ambAAVolume - ambAAFadeSpeed*2;
ambAAIntToFloat = ambAAVolume;
ALLambAA[ambAARandom].setVolume(ambAAIntToFloat/100*(ambMaxVolume/100));
}
// FADE OUT //
if (ambAASecCounter > ambAALength && ambABFadeOut == false)
{
ambAAFadeOut = true;
if (ambAAVolume > ambAAFadeSpeed)
{
ambAAVolume = ambAAVolume - ambAAFadeSpeed;
ambAAIntToFloat = ambAAVolume;
ALLambAA[ambAARandom].setVolume(ambAAIntToFloat/100*(ambMaxVolume/100));
}
// STOP //
if (ambAAVolume <= ambAAFadeSpeed*2)
{
ambAAVolume = 0;
ambAAFadeOut = false;
ALLambAA[ambAARandom].setVolume(0);
ALLambAA[ambAARandom].stop();
}
}
}
// FADE AB ////////////////////////////////////////////////////////////////
// COUNTERS //
ambABFrameCounter++;
if (ambABFrameCounter>60)
{
ambABFrameCounter = 0;
ambABSecCounter++;
}
// FADE //
if (ALLambAB[ambABRandom].getStatus() == 2)
{
ambABDynamics = 10000*(ambMadness*0.4/100) + 1000;
// FADE VOLUME UP //
if (ambABVolume + ambABFadeSpeed < ambABDynamics && ambABFadeOut == false)
{
ambABVolume = ambABVolume + ambABFadeSpeed;
ambABIntToFloat = ambABVolume;
ALLambAB[ambABRandom].setVolume(ambABIntToFloat/100*(ambMaxVolume/100));
}
// FADE VOLUME DOWN //
else if (ambABVolume > ambABDynamics && ambABFadeOut == false)
{
ambABVolume = ambABVolume - ambABFadeSpeed*2;
ambABIntToFloat = ambABVolume;
ALLambAB[ambABRandom].setVolume(ambABIntToFloat/100*(ambMaxVolume/100));
}
// FADE OUT //
if (ambABSecCounter > ambABLength && ambAAFadeOut == false)
{
ambABFadeOut = true;
if (ambABVolume > ambABFadeSpeed)
{
ambABVolume = ambABVolume - ambABFadeSpeed;
ambABIntToFloat = ambABVolume;
ALLambAB[ambABRandom].setVolume(ambABIntToFloat/100*(ambMaxVolume/100));
}
// STOP //
if (ambABVolume <= ambABFadeSpeed*2)
{
ambABVolume = 0;
ambABFadeOut = false;
ALLambAB[ambABRandom].setVolume(0);
ALLambAB[ambABRandom].stop();
}
}
}
// IF NOT PLAYING BA /////////////////////////////////////////////////////////
if (ALLambBA[ambBARandom].getStatus() == 0 && ambMadness > ambBATriggerLevel)
{
// FILE SELECTOR //
ambBARandom = rand()% ARRAY_SIZE(ambBAFile);
//ALLambBA[ambBARandom].openFromFile(ambBAFile[ambBARandom]);
// RESETS //
ALLambBA[ambBARandom].setVolume(0);
ambBAUpDown = 0;
ambBAOffOn = 0;
// PLAY //
ALLambBA[ambBARandom].play();
}
// IF NOT PLAYING BB /////////////////////////////////////////////////////////
if (ALLambBB[ambBBRandom].getStatus() == 0 && ambMadness > ambBBTriggerLevel)
{
// FILE SELECTOR //
ambBBRandom = rand()% ARRAY_SIZE(ambBBFile);
//ALLambBB[ambBBRandom].openFromFile(ambBBFile[ambBBRandom]);
// RESETS //
ALLambBB[ambBBRandom].setVolume(0);
ambBBUpDown = 0;
ambBBOffOn = 0;
// PLAY //
ALLambBB[ambBBRandom].play();
}
// IF NOT PLAYING BC /////////////////////////////////////////////////////////
if (ALLambBC[ambBCRandom].getStatus() == 0 && ambMadness > ambBCTriggerLevel)
{
// FILE SELECTOR //
ambBCRandom = rand()% ARRAY_SIZE(ambBCFile);
//ALLambBC[ambBCRandom].openFromFile(ambBCFile[ambBCRandom]);
// RESETS //
ALLambBC[ambBCRandom].setVolume(0);
ambBCUpDown = 0;
ambBCOffOn = 0;
// PLAY //
ALLambBC[ambBCRandom].play();
}
// FADE BA ////////////////////////////////////////////////////////////////
if (ALLambBA[ambBARandom].getStatus() == 2)
{
// TRIGGER //
ambBAFrameCounter++;
if (ambBAOffOn == 0 && ambBAFrameCounter-300 + (ambMadness-ambBATriggerLevel)*7 + rand()% 200 > 500)
{
ambBAOffOn = 1;
ambBAFadeInSpeed = 300 + (ambMadness-ambBATriggerLevel)*5 + rand()% 200;
ambBAFadeOutSpeed = 20 + (ambMadness-ambBATriggerLevel)/2 + rand()% 30;
ambBAPitch = rand() % 100;
ambBAPitch = ambBAPitch/200+0.75;
ALLambBA[ambBARandom].setPitch(ambBAPitch*(ambMadness/200)+0.5);
}
// FADE IN //
if (ambBAOffOn == 1 && ambBAUpDown == 0)
{
ambBAVolume = ambBAVolume + ambBAFadeInSpeed;
ambBAIntToFloat = ambBAVolume;
ambBAIntToFloat = ambBAIntToFloat/100;
ALLambBA[ambBARandom].setVolume(100*(ambBAIntToFloat*ambBAIntToFloat/100*((ambMadness-40)/100)/100)*(ambMaxVolume/100));
if (ambBAVolume > 10000)
{
ambBAUpDown = 1;
}
}
// FADE OUT //
else if (ambBAUpDown == 1)
{
ambBAVolume = ambBAVolume - ambBAFadeOutSpeed;
ambBAIntToFloat = ambBAVolume;
ambBAIntToFloat = ambBAIntToFloat/100;
ALLambBA[ambBARandom].setVolume(100*(ambBAIntToFloat*ambBAIntToFloat/100*((ambMadness-40)/100)/100)*(ambMaxVolume/100));
if (ambBAVolume <= ambBAFadeOutSpeed*2)
{
ambBAUpDown = 0;
ambBAOffOn = 0;
ambBAFrameCounter = 0;
ambBAVolume = 0;
ambBAIntToFloat = 0;
ALLambBA[ambBARandom].setVolume(0);
}
}
// STOP //
if (ambMadness < ambBATriggerLevel && ALLambBA[ambBARandom].getVolume() == 0)
{
ambBAUpDown = 0;
ambBAOffOn = 0;
ambBAFrameCounter = 0;
ambBAVolume = 0;
ambBAIntToFloat = 0;
ALLambBA[ambBARandom].setVolume(0);
ALLambBA[ambBARandom].stop();
}
}
// FADE BB ////////////////////////////////////////////////////////////////
if (ALLambBB[ambBBRandom].getStatus() == 2)
{
// TRIGGER //
ambBBFrameCounter++;
if (ambBBOffOn == 0 && ambBBFrameCounter-200 + (ambMadness-ambBBTriggerLevel)*7 + rand()% 200 > 400)
{
ambBBOffOn = 1;
ambBBFadeInSpeed = 300 + (ambMadness-ambBBTriggerLevel)*5 + rand()% 200;
ambBBFadeOutSpeed = 20 + (ambMadness-ambBBTriggerLevel)/2 + rand()% 30;
ambBBPitch = rand() % 100;
ambBBPitch = ambBBPitch/200+0.75;
ALLambBB[ambBBRandom].setPitch(ambBBPitch*(ambMadness/200)+0.5);
}
// FADE IN //
if (ambBBOffOn == 1 && ambBBUpDown == 0)
{
ambBBVolume = ambBBVolume + ambBBFadeInSpeed;
ambBBIntToFloat = ambBBVolume;
ambBBIntToFloat = ambBBIntToFloat/100;
ALLambBB[ambBBRandom].setVolume(100*(ambBBIntToFloat*ambBBIntToFloat/100*((ambMadness-40)/100)/100)*(ambMaxVolume/100));
if (ambBBVolume > 10000)
{
ambBBUpDown = 1;
}
}
// FADE OUT //
else if (ambBBUpDown == 1)
{
ambBBVolume = ambBBVolume - ambBBFadeOutSpeed;
ambBBIntToFloat = ambBBVolume;
ambBBIntToFloat = ambBBIntToFloat/100;
ALLambBB[ambBBRandom].setVolume(100*(ambBBIntToFloat*ambBBIntToFloat/100*((ambMadness-40)/100)/100)*(ambMaxVolume/100));
if (ambBBVolume <= ambBBFadeOutSpeed*2)
{
ambBBUpDown = 0;
ambBBOffOn = 0;
ambBBFrameCounter = 0;
ambBBVolume = 0;
ambBBIntToFloat = 0;
ALLambBB[ambBBRandom].setVolume(0);
}
}
// STOP //
if (ambMadness < ambBBTriggerLevel && ALLambBB[ambBBRandom].getVolume() == 0)
{
ambBBUpDown = 0;
ambBBOffOn = 0;
ambBBFrameCounter = 0;
ambBBVolume = 0;
ambBBIntToFloat = 0;
ALLambBB[ambBBRandom].setVolume(0);
ALLambBB[ambBBRandom].stop();
}
}
// FADE BC ////////////////////////////////////////////////////////////////
if (ALLambBC[ambBCRandom].getStatus() == 2)
{
// TRIGGER //
ambBCFrameCounter++;
if (ambBCOffOn == 0 && ambBCFrameCounter-100 + (ambMadness-ambBCTriggerLevel)*7 + rand()% 200 > 300)
{
ambBCOffOn = 1;
ambBCFadeInSpeed = 300 + (ambMadness-ambBCTriggerLevel)*5 + rand()% 200;
ambBCFadeOutSpeed = 20 + (ambMadness-ambBCTriggerLevel)/2 + rand()% 30;
ambBCPitch = rand() % 100;
ambBCPitch = ambBCPitch/200+0.75;
ALLambBC[ambBCRandom].setPitch(ambBCPitch*(ambMadness/200)+0.5);
}
// FADE IN //
if (ambBCOffOn == 1 && ambBCUpDown == 0)
{
ambBCVolume = ambBCVolume + ambBCFadeInSpeed;
ambBCIntToFloat = ambBCVolume;
ambBCIntToFloat = ambBCIntToFloat/100;
ALLambBC[ambBCRandom].setVolume(100*(ambBCIntToFloat*ambBCIntToFloat/100*((ambMadness-40)/100)/100)*(ambMaxVolume/100));
if (ambBCVolume > 10000)
{
ambBCUpDown = 1;
}
}
// FADE OUT //
else if (ambBCUpDown == 1)
{
ambBCVolume = ambBCVolume - ambBCFadeOutSpeed;
ambBCIntToFloat = ambBCVolume;
ambBCIntToFloat = ambBCIntToFloat/100;
ALLambBC[ambBCRandom].setVolume(100*(ambBCIntToFloat*ambBCIntToFloat/100*((ambMadness-40)/100)/100)*(ambMaxVolume/100));
if (ambBCVolume <= ambBCFadeOutSpeed*2)
{
ambBCUpDown = 0;
ambBCOffOn = 0;
ambBCFrameCounter = 0;
ambBCVolume = 0;
ambBCIntToFloat = 0;
ALLambBC[ambBCRandom].setVolume(0);
}
}
// STOP //
if (ambMadness < ambBCTriggerLevel && ALLambBC[ambBCRandom].getVolume() == 0)
{
ambBCUpDown = 0;
ambBCOffOn = 0;
ambBCFrameCounter = 0;
ambBCVolume = 0;
ambBCIntToFloat = 0;
ALLambBC[ambBCRandom].setVolume(0);
ALLambBC[ambBCRandom].stop();
}
}
// IF NOT PLAYING CA /////////////////////////////////////////////////////////
if (ambMadness > ambCATriggerLevel && ALLambCA[ambCARandom].getStatus() == 0)
{
// FILE SELECTOR //
ambCARandom = rand()% ARRAY_SIZE(ambCAFile);
//ALLambCA[ambCARandom].openFromFile(ambCAFile[ambCARandom]);
// VOLUME RESET //
ALLambCA[ambCARandom].setVolume(0);
// PITCH //
ambCAPitch = rand() % 100;
ambCAPitch = ambCAPitch/400+0.87;
ALLambCA[ambCARandom].setPitch(ambCAPitch);
// PLAY //
ALLambCA[ambCARandom].play();
}
// IF NOT PLAYING CB /////////////////////////////////////////////////////////
if ( ambMadness > ambCBTriggerLevel && ALLambCB[ambCBRandom].getStatus() == 0)
{
// FILE SELECTOR //
ambCBRandom = rand()% ARRAY_SIZE(ambCBFile);
//ALLambCB[ambCBRandom].openFromFile(ambCBFile[ambCBRandom]);
// VOLUME RESET //
ALLambCB[ambCBRandom].setVolume(0);
// PITCH //
ambCBPitch = rand() % 100;
ambCBPitch = ambCBPitch/400+0.87;
ALLambCB[ambCBRandom].setPitch(ambCBPitch);
// PLAY //
ALLambCB[ambCBRandom].play();
}
// IF NOT PLAYING CC /////////////////////////////////////////////////////////
if (ambMadness > ambCCTriggerLevel && ALLambCC[ambCCRandom].getStatus() == 0)
{
// FILE SELECTOR //
ambCCRandom = rand()% ARRAY_SIZE(ambCCFile);
//ALLambCC[ambCCRandom].openFromFile(ambCCFile[ambCCRandom]);
// VOLUME RESET //
ALLambCC[ambCCRandom].setVolume(0);
// PITCH //
ambCCPitch = rand() % 100;
ambCCPitch = ambCCPitch/400+0.87;
ALLambCC[ambCCRandom].setPitch(ambCCPitch);
// PLAY //
ALLambCC[ambCCRandom].play();
}
// VOLUME CA ////////////////////////////////////////////////////////////////
if (ALLambCA[ambCARandom].getStatus() == 2)
{
/*if((ambMadness - ambCATriggerLevel)*(ambMadness/100+1)*0.50*(ambMaxVolume/100)*0.75 >= 50)
ALLambCA[ambCARandom].setVolume(50);
else*/
ALLambCA[ambCARandom].setVolume((ambMadness - ambCATriggerLevel)*(ambMadness/100+1)*0.50*(ambMaxVolume/100)*0.20);
// STOP //
if (ambMadness <= ambCATriggerLevel)
{
ALLambCA[ambCARandom].stop();
ALLambCA[ambCARandom].setVolume(0);
}
}
// VOLUME CB ////////////////////////////////////////////////////////////////
if (ALLambCB[ambCBRandom].getStatus() == 2)
{
/*if((ambMadness - ambCATriggerLevel)*(ambMadness/100+1)*0.50*(ambMaxVolume/100)*0.75 >= 50)
ALLambCB[ambCBRandom].setVolume(50);
else*/
ALLambCB[ambCBRandom].setVolume((ambMadness - ambCATriggerLevel)*(ambMadness/100+1)*0.50*(ambMaxVolume/100)*0.20);
// STOP //
if (ambMadness <= ambCBTriggerLevel)
{
ALLambCB[ambCBRandom].stop();
ALLambCB[ambCBRandom].setVolume(0);
}
}
// VOLUME CC ////////////////////////////////////////////////////////////////
if (ALLambCC[ambCCRandom].getStatus() == 2)
{
/*if((ambMadness - ambCATriggerLevel)*(ambMadness/100+1)*0.50*(ambMaxVolume/100)*0.75 >= 50)
ALLambCC[ambCCRandom].setVolume(50);
else*/
ALLambCC[ambCCRandom].setVolume((ambMadness - ambCATriggerLevel)*(ambMadness/100+1)*0.50*(ambMaxVolume/100)*0.20);
// STOP //
if (ambMadness <= ambCCTriggerLevel)
{
ALLambCC[ambCCRandom].stop();
ALLambCC[ambCCRandom].setVolume(0);
}
}
// PLAY D //////////////////////////////////////////////////////////////////////////////
if (ambMadness > ambDTriggerLevel || ambDBeforeAfter == 1)
{
ambDCounter++;
// LONG BEEP TRIGGER //
if (ambMadness >= 100 && ambDB.getStatus() == 0)
{
ambDA.stop();
ambDB.setVolume(ambMaxVolume*0.60);
ambDB.play();
ambDBeforeAfter = 1;
ambDTimer = 0;
}
// BEFORE BEEP PLAY //
else if (ambDCounter > 160-((ambMadness*ambMadness)/75) && ambDBeforeAfter == 0 && ambDB.getStatus() == 0)
{
ambDCounter = 0;
ambDA.setVolume((ambMadness-ambDTriggerLevel)*(ambMadness-ambDTriggerLevel)*(ambMaxVolume/100)*0.60);
ambDA.play();
}
// AFTER BEEP PLAY //
else if (ambDB.getStatus() == 0 && ambDCounter > 90 && ambDBeforeAfter == 1)
{
ambDCounter = 0;
ambDTimer++;
ambDC.setVolume(ambDCVolumeTable[ambDTimer]*(ambMaxVolume/100)*0.4);
ambDD.setVolume(ambDDVolumeTable[ambDTimer]*(ambMaxVolume/100)*0.4);
if (ambDBeforeAfter == 1)
{
ambDC.play();
ambDD.play();
}
// STOP //
if (ambDTimer == 11)
{
ambDBeforeAfter = 0;
ambDTimer = 0;
}
}
}
}
ambiance::ambiance()
{
// INSTANCES D //
ambDA.setVolume(0);
ambDA.setLoop(false);
ambDB.setVolume(70);
ambDB.setLoop(false);
ambDC.setVolume(100);
ambDC.setLoop(false);
ambDD.setVolume(100);
ambDD.setLoop(false);
ambDA.openFromFile(path+"ambDA01.ogg");
ambDB.openFromFile(path+"ambDB01.ogg");
ambDC.openFromFile(path+"ambDC01.ogg");
ambDD.openFromFile(path+"ambDD01.ogg");
// LOAD ALL FILES (AKA RONNYHAX) ////////////////////////////////////////////
for(int i = 0; i < ARRAY_SIZE(ambAAFile); i++)
{
ALLambAA[i].openFromFile(path+ambAAFile[i]);
ALLambAA[i].setVolume(0);
ALLambAA[i].setLoop(true);
}
for(int i = 0; i < ARRAY_SIZE(ambABFile); i++)
{
ALLambAB[i].openFromFile(path+ambABFile[i]);
ALLambAB[i].setVolume(0);
ALLambAB[i].setLoop(true);
}
for(int i = 0; i < ARRAY_SIZE(ambBAFile); i++)
{
ALLambBA[i].openFromFile(path+ambBAFile[i]);
ALLambBA[i].setVolume(0);
ALLambBA[i].setLoop(true);
}
for(int i = 0; i < ARRAY_SIZE(ambBBFile); i++)
{
ALLambBB[i].openFromFile(path+ambBBFile[i]);
ALLambBB[i].setVolume(0);
ALLambBB[i].setLoop(true);
}
for(int i = 0; i < ARRAY_SIZE(ambBCFile); i++)
{
ALLambBC[i].openFromFile(path+ambBCFile[i]);
ALLambBC[i].setVolume(0);
ALLambBC[i].setLoop(true);
}
for(int i = 0; i < ARRAY_SIZE(ambCAFile); i++)
{
ALLambCA[i].openFromFile(path+ambCAFile[i]);
ALLambCA[i].setVolume(0);
ALLambCA[i].setLoop(true);
}
for(int i = 0; i < ARRAY_SIZE(ambCBFile); i++)
{
ALLambCB[i].openFromFile(path+ambCBFile[i]);
ALLambCB[i].setVolume(0);
ALLambCB[i].setLoop(true);
}
for(int i = 0; i < ARRAY_SIZE(ambCCFile); i++)
{
ALLambCC[i].openFromFile(path+ambCCFile[i]);
ALLambCC[i].setVolume(0);
ALLambCC[i].setLoop(true);
}
// RAND TIME & ARRAYLENGTH DEFINITION //
srand (time(0));
}
void main_resource_init(){
SoundMusic.setVolume( MUSIC_VOLUME );
}