path: root/vfg/src/testApp.cpp

#include "testApp.h"
//bug in codeblocks: it sometimes checks for existence of executable from previous project

//--------------------------------------------------------------
guiWindow::~guiWindow(){
	cout << "gui window destroyed" << endl;
}
void guiWindow::setup(){
}
void guiWindow::setParent(testApp *p){
	parent=p;
}
void guiWindow::draw(){

	ofDisableAlphaBlending();
	parent->gui.draw();
	ofSetColor(255,255,255);
	ofDrawBitmapString(ofToString(parent->game.queued)+" in queue", 10,ofGetHeight()-15);
	char buf[200];
	sprintf(buf,"%.1f",ofGetFrameRate());
	ofDrawBitmapString(buf, ofGetWidth()-43,ofGetHeight()-15);
	ofDrawBitmapString(levelnames[parent->gamestate-1], 10,ofGetHeight()-35);
	switch (parent->gamestate) {
		case GAME_PLAYING:
			ofDrawBitmapString(parent->songs[parent->currentsong]->getScoreString(),10,ofGetHeight()-55);
			break;
		case GAME_INTRO:
			sprintf(buf,"%f %i of %i",parent->intro.getPosition(),parent->intro.getCurrentFrame(),parent->intro.getTotalNumFrames());
			ofDrawBitmapString(buf,10,ofGetHeight()-55);
			break;
		case GAME_ADVERT:
			sprintf(buf,"%f %i of %i",parent->advert.getPosition(),parent->advert.getCurrentFrame(),parent->advert.getTotalNumFrames());
			ofDrawBitmapString(buf,10,ofGetHeight()-55);
			break;
	}

}
void guiWindow::dragEvent(ofDragInfo dragInfo, ofxFenster* win){
    parent->dragEvent(dragInfo);
}
void guiWindow::windowMoved(int x,int y){
    //printf("window moved!\n");
}

//----------------------------------------------------------------------
void testApp::setup(){

	game.setup("1122",2000); //Asterisk.cpp thread polls server every 2000ms

//songs.push_back(new song("WeWishYouAMerryChistmas_v.2.1/VODA_MUS_WEWISHU_Backing_v.2.1.mp3","WeWishYouAMerryChistmas_v.2.1/VODA_MUS_WEWISHU_Lead_v.2.1.mp3","VODA_MUS_WEWISHU_Midi_v.2.2.xml","Lyrics_WeWishYou.2.1.xml","Levels_test.xml"));

	songs.push_back(new song("SilentNight/VODA_SilentNight_Backing_v.1.1.1.mp3","SilentNight/VODA_SilentNight_Melody_v.1.1.1.mp3","VODA_SilentNight_Midi_v.1.1.3.xml","Lyrics_SilentNight_v1.1.3.xml","Levels_SilentNight_v1.1.3.xml"));
	songs.push_back(new song("WeWishYouAMerryChistmas_v.2.1/VODA_MUS_WEWISHU_Backing_v.2.1.mp3","WeWishYouAMerryChistmas_v.2.1/VODA_MUS_WEWISHU_Lead_v.2.1.mp3","VODA_MUS_WEWISHU_Midi_v.2.2.xml","Lyrics_WeWishYou.2.1.xml","Levels_WeWishYou.2.1.xml"));
	songs.push_back(new song("DeckTheHalls_v.4.0/VODA_MUS_DeckTheHalls-Backing_v.4.0.mp3","DeckTheHalls_v.4.0/VODA_MUS_DeckTheHalls-Lead_v.4.0.mp3","VODA_MIDI_DeckTheHalls-v.4.0.xml","Lyrics_DeckTheHalls.4.0.xml","Levels_DeckTheHalls.4.0.xml"));
	songs.push_back(new song("DingDong.v.2.2/VODA_MUS_DingDong_Backing_v.2.2.mp3","DingDong.v.2.2/VODA_MUS_DingDong_Melody_v.2.2.mp3","VODA_MIDI_DingDong_v.2.2.xml","Lyrics_DingDong.2.2.xml","Levels_DingDong.2.2.xml"));
	songs.push_back(new song("JingleBells_v.4.0/VODA_MUS_JingleBells_Backing_v.4.0.mp3","JingleBells_v.4.0/VODA_MUS_JingleBells_Melody_v.4.0.mp3","VODA_MUS_JingleBells_MIDI_v.4.0.xml","Lyrics_JingleBells.4.0.xml","Levels_JingleBells.4.0.xml"));

	ofSetBackgroundAuto(false);
	ofBackground(0,0,0);

	//printf("we wish you a merry xmas:\n");
	//songs[0]->notes.printNotes();

	for (int i=0;i<3;i++) penguins.push_back(Puppet());
	penguins[0].load("Penguin-Blue.xml");
	penguins[1].load("Penguin-Purple.xml");
	penguins[2].load("Penguin-Green.xml");


	// temp save time
	for (int i=0;i<3;i++) raccoons.push_back(Puppet());
	raccoons[0].load("Raccoon-Blue.xml");
	raccoons[1].load("Raccoon-Purple.xml");
	raccoons[2].load("Raccoon-Green.xml");


	tags.push_back(new Tag("Tags/TAG_Get-Ready.png",2000,0.5,0));
	tags.push_back(new Tag("Tags/TAG_Level-1.png",3000,0.5,0));
	tags.push_back(new Tag("Tags/TAG_Level-2.png",3000,0.5,0));
	tags.push_back(new Tag("Tags/TAG_Level-3.png",3000,0.5,0));
	tags.push_back(new Tag("Tags/TAG_Level-4.png",3000,0.5,0));
	tags.push_back(new Tag("Tags/PreGame-Practice.png",7000,0.5,0.16667));
	tags.push_back(new Tag("Tags/Game-Over.png",3000,0.5,0));
	tags.push_back(new Tag("Tags/Thanks-NEW.png",4000,0.5,0));
	tags.push_back(new Tag("Tags/TAG_Practice-Run.png",3000,0.5,0));


	logos.push_back(new Billboard("Logo-VF.png",0.5,0.0));
	logos.push_back(new Billboard("Logo-DCC.png",0.36,0.855));

	lyricspanel=new Billboard("Lyrics-panel.png",0.5,0.703);

	banner.load("Ribbon/Dublin/Ribbon_%05i.png",500);
	banner.setAnchorPercent(0.5,0.0);
	banner.setFrameRate(50);
	banner.play();

	wirebirds.load("Birds-with-Wire/Birds-with-Wire_%05i.png",125);
	wirebirds.setAnchorPercent(0.5,0.5);
	wirebirds.setFrameRate(50);
	wirebirds.play();

	//loadanimals("Raccoons");
	playanimal =&penguins;

	//testpenguin.load("Penguin-Blue.xml");
	//debug: commented out: 	436m 257m
	//508fr 1.7s load in use:	837m 444m

	//release: commented out: 	436m 256m
	//508fr 1.4s load   in use:	836m 443m

	//cd /home/tim/workspace/VFxmas/vfg/bin/data
	//mount -t tmpfs -o size=64M tmpfs /RAM
	//cp *.m* RAM

	intro.loadMovie("RAM/Game-Demo_v6_DUBLIN.mp4");
	intro.setLoopState(OF_LOOP_NONE);
	intro.setVolume(0.0);

	advert.loadMovie("RAM/VFxmasAD.mov");
	advert.setLoopState(OF_LOOP_NONE);
	advert.setVolume(1.0);

	background.loadMovie("RAM/Background_v3.mp4");
	background.setLoopState(OF_LOOP_NORMAL);
	background.play();

	backgroundmusic.loadSound("VODA_SFX_PreGameMusic_v.2.0.mp3");
	backgroundmusic.setLoop(true);
	backgroundmusic.play();
	backgroundmusic.setVolume(1.0);

	vignette.loadImage("Vignette.png");

	showFPS=true;
	showVis=false;
	fullscreenoutput=false;
	fadelength=3000;
	segmentStartTime=0;
	currentsong=0;
	nextsong=0;
	gamestate=GAME_READY;


	guiWin=new guiWindow();
	gui.setup("","panel.xml",0,0);

	threshStart=2000;
	gui.add(tS.setup("start threshold",threshStart,0,4000,255));
	threshEnd=500;
	gui.add(tE.setup("end threshold",threshEnd,0,4000,255));
	timescale=5000;
	gui.add(ts.setup("timescale",timescale,0,10000,255));
	keyThresh=1500;
	gui.add(kT.setup("keythresh",keyThresh,0,4000,255));
	birdpoint=0.6;
	gui.add(bP.setup("wire level",birdpoint,0.5,0.7,255));
	gui.add(showWire.setup("wire",true));

	ofxFenster* win=ofxFensterManager::get()->createFenster(0, 0,  200, 400, OF_WINDOW);
	win->setWindowTitle("config");
	win->addListener(guiWin);
	ofAddListener(win->events.keyPressed, this, &testApp::keyPressedEvent);
	guiWin->setup();
	guiWin->setParent(this);

}
/*
void testApp::loadanimals(string which) {
	playanimals.clear();

	for (int i=0;i<3;i++) playanimals.push_back(Puppet());

	if (which=="Penguins") {
		playanimals[0].load("Penguin-Blue.xml");
		playanimals[1].load("Penguin-Purple.xml");
		playanimals[2].load("Penguin-Green.xml");
	}
	else {
		playanimals[0].load("Raccoon-Blue.xml");
		playanimals[1].load("Raccoon-Purple.xml");
		playanimals[2].load("Raccoon-Green.xml");
	}

}
*/

void testApp::exit(){
	delete lyricspanel;
	backgroundmusic.unloadSound();
}

//--------------------------------------------------------------
void testApp::update(){
	int ret=game.update();
	if (ret==ASTERISK_GAMESTARTED) {
		activatePractice();
	}
	else if (ret==ASTERISK_GAMEOVER) {
		if (gamestate==GAME_PLAYING||gamestate==GAME_PRACTICE||gamestate==GAME_PRACTICE2) {
			printf("player hung up!\n");
			endGame();
		}
	}
	else if (ret>48&&ret<52) {
		songs[currentsong]->playerControl(ret-49);
		practiceSong.playerControl(ret-49);
		(*playanimal)[ret-49].playNow("Clap");
	}
	else if (ret>51&&ret<55) {
		songs[currentsong]->playerControl(ret-52);
		practiceSong.playerControl(ret-52);
		(*playanimal)[ret-52].playNow("Clap");
	}
	else if (ret>54&&ret<58) {
		songs[currentsong]->playerControl(ret-55);
		practiceSong.playerControl(ret-55);
		(*playanimal)[ret-55].playNow("Clap");
	}
	if (songs[currentsong]->isPlaying&&songs[currentsong]->getLevel(ofGetElapsedTimeMillis()+4000)>currentlevel) {
		int anim=ofRandom(1.9999); //this gives a binary random number
		for (int i=0;i<3;i++) {
			if (anim) (*playanimal)[i].playNow("Happy");
			else (*playanimal)[i].playNow("Jump");
			anim=(anim+1)%2;
		}
		tags[currentlevel+1]->play();
		currentlevel++;
		printf("finished level %i!\n",currentlevel);
	}
	switch(gamestate) {
		case GAME_READY:
		case GAME_STARTPLAYING:
		case GAME_PLAYING:
		case GAME_ENDPLAYING:
		case GAME_ENDINGINTRO:
		case GAME_PRACTICE:
		case GAME_PRACTICE2:
		case GAME_WALKON:
			background.update();
			banner.update();
			wirebirds.update();
            break;
        case GAME_STARTINGINTRO:
        case GAME_INTRO:
		intro.update();
		break;
        case GAME_STARTINGADVERT:
	case GAME_ENDINGADVERT:
		background.update();
		banner.update();
        case GAME_ADVERT:
		advert.update();
		break;
	case GAME_ENDTITLE:
		background.update();
		break;
	}
}

/*
#define GAME_STARTINGINTRO 1
#define GAME_INTRO 2
#define GAME_ENDINGINTRO 3
#define GAME_READY 4
#define GAME_STARTINGADVERT 5
#define GAME_ADVERT 6
#define GAME_ENDINGADVERT 7
#define GAME_STARTPLAYING 8
#define GAME_PRACTICE 9
#define GAME_PLAYING 10
#define GAME_ENDPLAYING 11
*/
//--------------------------------------------------------------
void testApp::drawBackgroundLayers(){
	float hOffs=(ofGetWidth()-ofGetHeight())/2;
	background.draw(hOffs,0,ofGetHeight(),ofGetHeight());
	ofEnableAlphaBlending();
	vignette.draw(hOffs,0,ofGetHeight(),ofGetHeight());
	ofDisableAlphaBlending();
}
//--------------------------------------------------------------
void testApp::draw(){
	ofDisableAlphaBlending();
	ofSetColor(255,255,255);
	float hOffs=(ofGetWidth()-ofGetHeight())/2;
	float scale=ofGetHeight()/1080.0f;
	float bannerscale,aspect,wOffs,seg; //this old chestnut
	float segamt=min(1.0f,((float)(ofGetElapsedTimeMillis()-segmentStartTime)*2.0f)/fadelength); //same variable used in all segments
	int hit,missed;
	switch(gamestate) {
		case GAME_STARTINGINTRO:
		case GAME_INTRO:
		case GAME_ENDINGINTRO:
		case GAME_READY:
		case GAME_STARTINGADVERT:
		case GAME_ADVERT:
		case GAME_ENDINGADVERT:
		case GAME_STARTPLAYING:
		case GAME_PRACTICE:
		case GAME_PLAYING:
		case GAME_ENDPLAYING:
		case GAME_WALKON:
			break;
	}
	//draw backgrounds
	switch(gamestate) {
		case GAME_STARTINGINTRO:
		case GAME_INTRO:
			ofDisableAlphaBlending();
			intro.draw(hOffs,0,ofGetHeight(),ofGetHeight());
			break;
		case GAME_ENDINGINTRO:
		case GAME_READY:
		case GAME_STARTPLAYING:
		case GAME_PRACTICE:
		case GAME_PRACTICE2:
		case GAME_PLAYING:
		case GAME_ENDPLAYING:
		case GAME_WALKON:
		case GAME_ENDTITLE:
			ofDisableAlphaBlending();
			drawBackgroundLayers();
			break;
		case GAME_STARTINGADVERT:
			if (segamt<0.5) {
				ofEnableAlphaBlending();
				ofSetColor(255,255,255,255-(segamt*510));
				drawBackgroundLayers();
				break;
			}
			else {
				//if (!advert.isPlaying()) advert.play();
				ofEnableAlphaBlending();
				ofSetColor(255,255,255,((segamt-0.5)*510));
			}
		case GAME_ADVERT:
		case GAME_ENDINGADVERT:
			if (gamestate==GAME_ENDINGADVERT) {
				if (segamt<0.5) {
					ofEnableAlphaBlending();
					segamt=((float)(ofGetElapsedTimeMillis()-segmentStartTime))/fadelength;
					ofSetColor(255,255,255,255-(segamt*510));
				}
				else if (segamt>1.0) {
					gamestate=GAME_READY;
					ofSetColor(255,255,255);
					ofDisableAlphaBlending();
					drawBackgroundLayers();
					break;
				}
				else {
					ofDisableAlphaBlending();
					ofSetColor(((segamt-0.5)*510),((segamt-0.5)*510),((segamt-0.5)*510));
					drawBackgroundLayers();
					break;
				}
			}
			aspect=advert.getHeight()/advert.getWidth();
			float maxwidth=min((float)ofGetWidth(),ofGetHeight()*1.2f);
			float wstart=(ofGetWidth()-maxwidth)*0.5;
			wOffs=(ofGetHeight()-(maxwidth*aspect))*0.5;
			advert.draw(wstart,wOffs,maxwidth,maxwidth*aspect);
			ofDisableAlphaBlending(); //may have been turned on during intro

			break;

	}

	//draw game action
	switch(gamestate) {
		case GAME_STARTINGADVERT:
			if (segamt<0.5) {
				ofEnableAlphaBlending();
				ofSetColor(255,255,255,255-(segamt*510));
			}
			else break;
		case GAME_ENDINGADVERT:
			if (segamt>0.5) {
				ofEnableAlphaBlending();
				ofSetColor(255,255,255,((segamt-0.5)*510));
			}
			else break;
		case GAME_READY:
			ofEnableAlphaBlending();
			for (int i=0;i<3;i++) {
				//break up standing around movement
				if (ofRandom(1.0)<.002)  (*playanimal)[i].play("Shuffle");
				(*playanimal)[i].draw(hOffs+(gridX[i+1]*ofGetHeight()),gridY[0]*ofGetHeight(),scale);
			}
			break;
		case GAME_INTRO:
		case GAME_ENDTITLE:
			ofEnableAlphaBlending();
			seg=(((float)(ofGetElapsedTimeMillis()-segmentStartTime))*.001)/6;
			if (seg<1.0f) {
				wOffs=hOffs+(0.75*ofGetWidth()*seg);
				for (int i=0;i<3;i++) (*playanimal)[i].draw(wOffs+(gridX[i+1]*ofGetHeight()),gridY[0]*ofGetHeight(),scale);
			}
			break;
		case GAME_PRACTICE:
		case GAME_PRACTICE2:
			ofEnableAlphaBlending();
			missed=practiceSong.missedNote();
			if (missed>-1) (*playanimal)[missed].playNow("Shudder");
			hit=practiceSong.hitNote();
			if (hit>-1) (*playanimal)[hit].play("Catch");
			for (int i=0;i<3;i++) (*playanimal)[i].draw(hOffs+(gridX[i+1]*ofGetHeight()),gridY[0]*ofGetHeight(),scale);
			practiceSong.draw(hOffs,scale);
			break;
		case GAME_PLAYING:
			ofEnableAlphaBlending();
			if (showVis) songs[currentsong]->drawNotes(hOffs);
			missed=songs[currentsong]->missedNote();
			if (missed>-1) (*playanimal)[missed].playNow("Shudder");
			hit=songs[currentsong]->hitNote();
			if (hit>-1) (*playanimal)[hit].play("Catch");
			for (int i=0;i<3;i++) (*playanimal)[i].draw(hOffs+(gridX[i+1]*ofGetHeight()),gridY[0]*ofGetHeight(),scale);
			lyricspanel->draw(ofGetWidth()*0.5,ofGetHeight()*gridY[1],scale);
			songs[currentsong]->draw(hOffs,scale);
			break;
		case GAME_ENDPLAYING:
			//6 seconds to walk in / out -> 12 seconds turnaround
			//frames to start/cycle/stop walking
			//penguin: 11,35,11
			//raccoon: 20,39,43r
			ofEnableAlphaBlending();
			seg=(((float)(ofGetElapsedTimeMillis()-segmentStartTime))*.001)/6;
			wOffs=hOffs+(0.75*ofGetWidth()*seg);
			for (int i=0;i<3;i++) (*playanimal)[i].draw(wOffs+(gridX[i+1]*ofGetHeight()),gridY[0]*ofGetHeight(),scale);
			songs[currentsong]->draw(hOffs,scale);//allows the song to fade its volume out and stop playing, last notes to play out
			break;
		case GAME_WALKON:
		case GAME_ENDINGINTRO:
			    ofEnableAlphaBlending();
			    seg=(((float)(ofGetElapsedTimeMillis()-segmentStartTime))*.001)/6;
			    wOffs=hOffs-(0.75*ofGetWidth()*(1.0f-seg));
			    for (int i=0;i<3;i++) (*playanimal)[i].draw(wOffs+(gridX[i+1]*ofGetHeight()),gridY[0]*ofGetHeight(),scale);
			    break;
		}


	//draw tags and logos
	switch(gamestate) {
			case GAME_STARTINGADVERT:
				if (segamt<0.5) {
					ofEnableAlphaBlending();
					ofSetColor(255,255,255,255-(segamt*510));
				}
				else break;
			case GAME_ENDINGADVERT:
				if (segamt>0.5) {
					ofEnableAlphaBlending();
					ofSetColor(255,255,255,((segamt-0.5)*510));
				}
				else break;
			case GAME_ENDTITLE:
				//DCC LOGO FOR DUBLIN
				//logos[1]->draw((gridX[0]*ofGetHeight())+hOffs,gridY[1]*ofGetHeight(),scale);
			case GAME_ENDINGINTRO:
			case GAME_READY:
			case GAME_STARTPLAYING:
			case GAME_PRACTICE:
			case GAME_PRACTICE2:
			case GAME_PLAYING:
			case GAME_ENDPLAYING:
			case GAME_WALKON:
				ofEnableAlphaBlending();
				if (gamestate!=GAME_STARTINGADVERT&&gamestate!=GAME_ENDINGADVERT) ofSetColor(255,255,255);
				for (int i=0;i<tags.size();i++) {
					if (tags[i]->isPlaying)  tags[i]->draw(0.5f*ofGetWidth(),0,scale);
				}
				logos[0]->draw((gridX[0]*ofGetHeight())+hOffs,0,scale);
				break;
			
		}
	//draw banner and wirebirds
	bannerscale=scale;
	ofSetColor(255,255,255);
	float birdoffset;
	switch(gamestate) {
		case GAME_PRACTICE:
			ofEnableAlphaBlending();
			bannerscale=scale*(1.0f-(max(0.0,min(((float)(ofGetElapsedTimeMillis()-segmentStartTime))*.002,1.0))*0.325));
			birdoffset=-((1.0f-(max(0.0,min(((float)(ofGetElapsedTimeMillis()-segmentStartTime))*.0003,1.0))))*ofGetWidth());
			wirebirds.draw(birdoffset+(ofGetWidth()/2),ofGetHeight()*birdpoint,scale);
			segamt=1.0;
			ofEnableAlphaBlending();
			banner.draw(ofGetWidth()*0.5,0,bannerscale);
			break;
		case GAME_STARTINGADVERT:
			if (segamt<0.5) {
				ofEnableAlphaBlending();
				ofSetColor(255,255,255,255-(segamt*510));
			}
			else break;
		case GAME_ENDINGADVERT:
			if (segamt>0.5) {
				ofEnableAlphaBlending();
				ofSetColor(255,255,255,((segamt-0.5)*510));
			}
			else break;
		case GAME_READY:
		case GAME_ENDINGINTRO:
			ofEnableAlphaBlending();
			banner.draw(ofGetWidth()*0.5,0,bannerscale);
			break;
		case GAME_PRACTICE2:
		case GAME_STARTPLAYING:
		case GAME_PLAYING:
		case GAME_ENDPLAYING:
			ofEnableAlphaBlending();
			if (showWire) wirebirds.draw(ofGetWidth()/2,ofGetHeight()*birdpoint,scale);
			bannerscale=scale*0.675;
			banner.draw(ofGetWidth()*0.5,0,bannerscale);
			break;
		case GAME_WALKON:
			ofEnableAlphaBlending();
			bannerscale=scale*(0.675+(max(0.0,min(((float)(ofGetElapsedTimeMillis()-segmentStartTime))*.001,1.0))*0.325));
			birdoffset=(((max(0.0,min(((float)(ofGetElapsedTimeMillis()-segmentStartTime))*.0003,1.0))))*ofGetWidth());
			if (showWire) wirebirds.draw(birdoffset+(ofGetWidth()/2),ofGetHeight()*birdpoint,scale);
			banner.draw(ofGetWidth()*0.5,0,bannerscale);
			break;
	}
	//draw blanking edges
	switch(gamestate) {
		case GAME_ENDPLAYING:
		case GAME_WALKON:
		case GAME_ENDINGINTRO:
		case GAME_INTRO:
		case GAME_ENDTITLE:	
			if (ofGetWidth()>ofGetHeight()) {
				float slice=(ofGetWidth()-ofGetHeight())/2;
				ofSetColor(0,0,0);
				ofRect(0,0,slice,ofGetHeight());
				ofRect(ofGetWidth()-slice,0,slice,ofGetHeight());
				ofSetColor(255,255,255);
			}
	}
	//switch states:
	switch(gamestate) {
		case GAME_STARTINGINTRO:
		case GAME_INTRO:
			if (intro.getCurrentFrame()==intro.getTotalNumFrames()-1) {
				gamestate=GAME_ENDINGINTRO;
				segmentStartTime=ofGetElapsedTimeMillis();
				queueWalkOn();
			}
			break;
		case GAME_ENDINGINTRO:
			if (((float)(ofGetElapsedTimeMillis()-segmentStartTime))*.001>6.0) {
				gamestate=GAME_READY;
				segmentStartTime=ofGetElapsedTimeMillis();
			}
			break;
		case GAME_READY:
			break;
		case GAME_STARTINGADVERT:
			backgroundmusic.setVolume(max(0.0,1.0-(segamt*2.0)));
			if (segamt==1.0) {
				gamestate=GAME_ADVERT;
			}
		case GAME_ADVERT:
			if (advert.getCurrentFrame()==advert.getTotalNumFrames()-1) {
				gamestate=GAME_ENDINGADVERT;
				segmentStartTime=ofGetElapsedTimeMillis();
			}
			break;
		case GAME_ENDINGADVERT:
			backgroundmusic.setVolume(max(0.0,(segamt-0.5)*2.0));
			if (segamt==1.0) gamestate=GAME_READY;
			break;
		case GAME_STARTPLAYING:
		case GAME_PRACTICE:
		case GAME_PRACTICE2:
			break;
		case GAME_PLAYING:
			backgroundmusic.setVolume(max(0.0,1.0-(segamt*2.0)));
			if (songs[currentsong]->isGameover()) {
				hangUp();
				endGame();
			}
			break;
		case GAME_ENDPLAYING:
			if ((((float)(ofGetElapsedTimeMillis()-segmentStartTime))*.001)>6.0) {
				gamestate=GAME_WALKON;
				segmentStartTime=ofGetElapsedTimeMillis();
				switchAnimals();
				queueWalkOn();
			}
			break;
		case GAME_WALKON:
			backgroundmusic.setVolume(max(0.0,(segamt-0.5)*2.0));
			if (((float)(ofGetElapsedTimeMillis()-segmentStartTime))*.001>6.0) {
				gamestate=GAME_READY;
				segmentStartTime=ofGetElapsedTimeMillis();
			}
			break;
	}
}


//--------------------------------------------------------------
void testApp::keyPressedEvent(ofKeyEventArgs &args) {
	//printf("window key pressed: %i (%c)\n",args.key,args.key);
	keyPressed(args.key);
}
void testApp::keyPressed(int key, ofxFenster* win){
	//xprintf("window sent %i\n",key);
	if(key == '='){
			fullscreenoutput=!fullscreenoutput;
			win->setFullscreen(fullscreenoutput);
			printf("resolution: %ix%i %s\n",win->getWidth(),win->getHeight(),fullscreenoutput?"fullscreen":"windowed");
	}
	else keyPressed(key);
}
//--------------------------------------------------------------
void testApp::activateGame(){
	segmentStartTime=ofGetElapsedTimeMillis();
	currentlevel=0;
	currentsong=nextsong;
	songs[currentsong]->setTimeframe(timescale);
	songs[currentsong]->setFlakeThresh(threshStart,threshEnd);
	songs[currentsong]->setKeyThresh(keyThresh);
	songs[currentsong]->preRoll(2000);
	tags[0]->play();
	nextsong=(nextsong+1)%songs.size();
	gamestate=GAME_PLAYING;
}
void testApp::activatePractice(){
	segmentStartTime=ofGetElapsedTimeMillis();
	currentlevel=0;
	practiceSong.setTimeframe(timescale);
	practiceSong.setFlakeThresh(threshStart,threshEnd);
	practiceSong.setKeyThresh(keyThresh);
	if (gamestate==GAME_READY) {
		gamestate=GAME_PRACTICE;
		practiceSong.preRoll(4000);
		tags[8]->play();
	} else {
		gamestate=GAME_PRACTICE2;
		practiceSong.preRoll(5000);
		tags[5]->play();
	}
}
void testApp::switchAnimals(){
	if (playanimal==&raccoons) playanimal=&penguins;
	else playanimal =&raccoons;
}
void testApp::queueWalkOff(){
		//6 seconds to walk in / out -> 12 seconds turnaround
	//frames to start/cycle/stop walking
	//penguin: 11,35,11
	//raccoon: 20,39,43
	//penguins: start + 289 = 8.25
	//raccoons: start + 280 = 7.17
	for (int i=0;i<3;i++) {
		(*playanimal)[i].clear();
		(*playanimal)[i].playNow("Walk_start");
		for (int j=0;j<9;j++) (*playanimal)[i].play("Walking");
	}
}
void testApp::queueWalkOn(){
		//work out offet and schedule transition to finish at the end of 6 seconds
                //6 seconds to walk in / out -> 12 seconds turnaround
                //frames to start/cycle/stop walking
                //penguin: 11,35,11
                //raccoon: 20,39,43

                //penguins: 8 cycles + end = 291, diff 180ms (+ 1 frame per cycle? 0ms)
                //raccoons: 6 cycles + end = diff 230ms (+1 fr/cyc? 90ms)
	for (int i=0;i<3;i++) {
	    (*playanimal)[i].clear();
	    int numcycles,start;
	    if (playanimal==&penguins) {
		start=600; //(of 700 cycle) was 400
		numcycles=7;
	    }
	    else {
		start=200; //of 780 was 400
		numcycles=5;
	    }
	    (*playanimal)[i].play("Walking",ofGetElapsedTimeMillis()+start);
	    for (int j=0;j<numcycles;j++) (*playanimal)[i].play("Walking");
	    (*playanimal)[i].play("Walk_end");
	}
}
void testApp::hangUp(){
	string score=songs[currentsong]->getName()+":"+ofToString(((float)songs[currentsong]->getCurrentTime())*.001)+(songs[currentsong]->isFinished()?":finished":":level "+ofToString(currentlevel));
	//printf("current time:%i length:%i \n",songs[currentsong]->getCurrentTime(),songs[currentsong]->getLength())
	printf("score: %s\n",score.c_str());
	game.endGame(score);
}
void testApp::endGame(){
	switch (gamestate) {
		case GAME_PRACTICE:
		case GAME_PRACTICE2:
			practiceSong.gameOver();
			break;
		case GAME_PLAYING:
			songs[currentsong]->gameOver();
			break;
	}
	gamestate=GAME_ENDPLAYING;
	tags[6]->play(1000);
	segmentStartTime=ofGetElapsedTimeMillis();
	queueWalkOff();
}
//--------------------------------------------------------------
void testApp::keyPressed(int key){
	switch (key) {
		case 'x':
			if (gamestate==GAME_READY||gamestate==GAME_PRACTICE) {
				activatePractice();
			}
			break;
		case ' ':
			if (gamestate==GAME_PRACTICE||gamestate==GAME_PRACTICE2) {
				activateGame();
			}
			break;
		case '1':
		case '2':
		case '3':
			songs[currentsong]->playerControl(key-'1');
			practiceSong.playerControl(key-'1');
			(*playanimal)[key-'1'].playNow("Clap");
			break;
		case 's':
			if (gamestate==GAME_READY) {
				game.startGame();
			}
			break;
		case 'e':
			if (gamestate==GAME_PLAYING||gamestate==GAME_PRACTICE||gamestate==GAME_PRACTICE2) {
				hangUp();
				endGame();
			}
			break;
		case 'q':
			if (gamestate==GAME_READY) {
				segmentStartTime=ofGetElapsedTimeMillis();
				queueWalkOff();
				intro.firstFrame();
				intro.play();
				gamestate=GAME_INTRO;
			}
			break;
		case 'p':
			if (gamestate==GAME_READY) {
				segmentStartTime=ofGetElapsedTimeMillis();
				queueWalkOff();
				tags[7]->playEnd();
				gamestate=GAME_ENDTITLE;
			}
			break;
		case 'w':
			if (gamestate==GAME_READY) {
				segmentStartTime=ofGetElapsedTimeMillis();
				gamestate=GAME_STARTINGADVERT;
				advert.firstFrame();
				advert.play();
			}
			break;
		case 'f':
			showFPS=!showFPS;
			break;
		case 'v':
			showVis=!showVis;
			break;
		case 'r':
				//loadanimals("Raccoons");
				playanimal =&raccoons;
				break;
		case 't':
				//loadanimals("Penguins");
				playanimal =&penguins;
				break;
	}

}

//--------------------------------------------------------------
void testApp::keyReleased(int key){
	switch (key) {
		case '1':
		case '2':
		case '3':
			break;
	}
}

//--------------------------------------------------------------
void testApp::mouseMoved(int x, int y ){

}

//--------------------------------------------------------------
void testApp::mouseDragged(int x, int y, int button){

}

//--------------------------------------------------------------
void testApp::mousePressed(int x, int y, int button){

}

//--------------------------------------------------------------
void testApp::mouseReleased(int x, int y, int button){

}

//--------------------------------------------------------------
void testApp::windowResized(int w, int h){

}

//--------------------------------------------------------------
void testApp::gotMessage(ofMessage msg){

}

//--------------------------------------------------------------
void testApp::dragEvent(ofDragInfo dragInfo){

}