423 lines
12 KiB
C++
423 lines
12 KiB
C++
#include <iostream>
|
|
#include <fstream>
|
|
#include <algorithm>
|
|
#include <boost/filesystem.hpp>
|
|
|
|
#include "Model.h"
|
|
#include "Physics.h"
|
|
#include "PhysicsBase.h"
|
|
|
|
#include "EntityFactory.h"
|
|
#include "AsteroidsEvents.h"
|
|
#include "AsteroidEntity.h"
|
|
|
|
#include <assert.h>
|
|
|
|
namespace asteroids {
|
|
|
|
static Model* ModelInstance = NULL;
|
|
|
|
/*
|
|
* Inherited Module functions
|
|
*/
|
|
int Model::OnInit (int argc, char* argv[]) {
|
|
int result = Engine::ModelBase::OnInit (argc, argv);
|
|
|
|
Engine::LogMessage ("Model Initialization!");
|
|
|
|
ModelInstance = this;
|
|
|
|
mGameState = GameStateMainMenu;
|
|
mLastGameState = GameStateMainMenu;
|
|
|
|
/// \TODO use <optional> or similar for initialization of mCurrentLevelIndex
|
|
mCurrentLevelIndex = 99999;
|
|
mNewestHighscoreEntryIndex = 99999;
|
|
|
|
if (InitLevelList() == 0)
|
|
Engine::LogError ("No levels found!");
|
|
|
|
// First we reset the highscore list
|
|
mHighscoreList.clear();
|
|
// then we try to load values from the file
|
|
LoadHighscoreList();
|
|
|
|
// if we have less than the usual number of entries we add default values
|
|
if (mHighscoreList.size() < 10) {
|
|
AddHighscoreEntry ("Imperator", 1000000);
|
|
AddHighscoreEntry ("Darth Vader", 800000);
|
|
AddHighscoreEntry ("Luke Skywalker", 600000);
|
|
AddHighscoreEntry ("Han Solo", 400000);
|
|
AddHighscoreEntry ("Princess Leia", 200000);
|
|
AddHighscoreEntry ("C3PO", 100000);
|
|
AddHighscoreEntry ("R2-D2", 50000);
|
|
AddHighscoreEntry ("Chewy", 10000);
|
|
AddHighscoreEntry ("Mr. Ewok", 5000);
|
|
AddHighscoreEntry ("Jabba the Hutt", 1000);
|
|
}
|
|
|
|
// initialize event handlers and register them
|
|
mLevelCompleteEventHandler = new LevelCompleteEventHandler (this);
|
|
Engine::RegisterListener (mLevelCompleteEventHandler, EventLevelComplete);
|
|
|
|
mGameOverEventHandler = new GameOverEventHandler (this);
|
|
Engine::RegisterListener (mGameOverEventHandler, EventGameOver);
|
|
|
|
mPlayerName = "Player";
|
|
|
|
return result;
|
|
}
|
|
|
|
void Model::Process () {
|
|
if (mLastGameState == mGameState) {
|
|
if (mGameState == GameStateRunning) {
|
|
Engine::ModelBase::Process();
|
|
}
|
|
return;
|
|
}
|
|
|
|
// when we are here we know that something has changed so we need to take
|
|
// some action.
|
|
Engine::LogDebug ("Switching from %s->%s", GetStringGameState(mLastGameState), GetStringGameState(mGameState));
|
|
|
|
if ( (mLastGameState == GameStateMainMenu && mGameState == GameStateRunning)
|
|
|| (mLastGameState == GameStateEnterPlayername && mGameState == GameStateRunning)){
|
|
OnNewGame();
|
|
}
|
|
else if (mLastGameState == GameStateRunning && mGameState == GameStatePlayerDied) {
|
|
mPlayerLives --;
|
|
|
|
ClearEntities();
|
|
|
|
if (mPlayerLives == 0) {
|
|
Engine::EventBasePtr gameover_event (new Engine::EventBase());
|
|
gameover_event->mEventType = EventGameOver;
|
|
QueueEvent (gameover_event);
|
|
}
|
|
}
|
|
else if (mLastGameState == GameStateLevelComplete && mGameState == GameStateRunning) {
|
|
mCurrentLevelIndex++;
|
|
if (mCurrentLevelIndex == mLevelList.size()) {
|
|
Engine::EventBasePtr gameover_event (new Engine::EventBase());
|
|
gameover_event->mEventType = EventGameOver;
|
|
QueueEvent (gameover_event);
|
|
} else {
|
|
DoLoadLevel(mLevelList[mCurrentLevelIndex].c_str());
|
|
}
|
|
}
|
|
else if (mLastGameState == GameStatePlayerDied && mGameState == GameStateRunning)
|
|
DoLoadLevel(mLevelList[mCurrentLevelIndex].c_str());
|
|
else if (mLastGameState == GameStateRunning && mGameState == GameStateGameOver)
|
|
ClearEntities();
|
|
|
|
// ... and we have to set the last game state to the current gamestate
|
|
// otherwise we end up in an infinite loop of performing the switching
|
|
// action.
|
|
mLastGameState = mGameState;
|
|
}
|
|
|
|
unsigned int Model::InitLevelList () {
|
|
const char* level_dir_name = "./data/levels/";
|
|
Engine::LogDebug ("Searching for levels in %s", level_dir_name);
|
|
|
|
mLevelList.clear();
|
|
|
|
boost::filesystem::path level_dir(level_dir_name);
|
|
|
|
if (!boost::filesystem::exists(level_dir)) {
|
|
Engine::LogError ("Could not init level list: %s does not exist!");
|
|
}
|
|
|
|
if (!boost::filesystem::is_directory(level_dir)) {
|
|
Engine::LogError ("Could not init level list: %s is not a directory!");
|
|
}
|
|
|
|
boost::filesystem::directory_iterator end_iter;
|
|
for (boost::filesystem::directory_iterator dir_iter(level_dir);
|
|
dir_iter != end_iter;
|
|
++dir_iter) {
|
|
if (boost::filesystem::is_regular_file (dir_iter->status())) {
|
|
std::string level_relative_path (level_dir_name);
|
|
level_relative_path += dir_iter->path().filename();
|
|
mLevelList.push_back (level_relative_path);
|
|
Engine::LogDebug ("Found level %s", mLevelList[mLevelList.size()-1].c_str());
|
|
}
|
|
}
|
|
|
|
std::sort(mLevelList.begin(), mLevelList.end());
|
|
|
|
return mLevelList.size();
|
|
}
|
|
|
|
void Model::LoadHighscoreList () {
|
|
Engine::LogDebug ("Loading highscore file");
|
|
boost::filesystem::path highscore_file("./highscore.dat");
|
|
|
|
// if the file does not exist, we create it and write standard values into
|
|
// it.
|
|
if (!boost::filesystem::exists(highscore_file))
|
|
return;
|
|
|
|
if (!boost::filesystem::is_regular_file(highscore_file)) {
|
|
Engine::LogError ("Could not load highscore file: %s is not a regular file!", highscore_file.filename().c_str());
|
|
}
|
|
|
|
std::ifstream score_stream (highscore_file.filename().c_str());
|
|
while (!score_stream.eof()) {
|
|
std::string name;
|
|
unsigned int points;
|
|
|
|
std::string line;
|
|
getline (score_stream, line);
|
|
|
|
std::string::size_type delimiter = line.find ('\t');
|
|
if (delimiter == std::string::npos)
|
|
break;
|
|
|
|
name = line.substr(0, delimiter);
|
|
|
|
std::istringstream points_stream(line.substr(delimiter + 1, line.size()));
|
|
points_stream >> points;
|
|
|
|
Engine::LogDebug ("Read Highscore Entry Name: %s Points: %d", name.c_str(), points);
|
|
AddHighscoreEntry (name, points);
|
|
}
|
|
}
|
|
|
|
void Model::SaveHighscoreList () {
|
|
std::ofstream highscore_file ("./highscore.dat");
|
|
|
|
std::list<HighscoreEntry>::iterator iter = mHighscoreList.begin();
|
|
|
|
while (iter != mHighscoreList.end()) {
|
|
highscore_file << iter->name << "\t" << iter->points << std::endl;
|
|
iter++;
|
|
}
|
|
|
|
highscore_file.close();
|
|
}
|
|
|
|
bool highscore_cmp (Model::HighscoreEntry a, Model::HighscoreEntry b) {
|
|
return a.points > b.points;
|
|
}
|
|
|
|
/** \brief Addes an entry to the highscore list and takes care that the list stays valid
|
|
*
|
|
* \TODO Re-think usage of mNewestHighscoreEntryIndex variable in this function
|
|
*/
|
|
unsigned int Model::AddHighscoreEntry(const std::string &name, const unsigned int points) {
|
|
HighscoreEntry entry;
|
|
entry.name = name;
|
|
entry.points = points;
|
|
|
|
unsigned int counter = 0;
|
|
std::list<HighscoreEntry>::iterator iter = mHighscoreList.begin();
|
|
while (iter != mHighscoreList.end()) {
|
|
if (points >= iter->points) {
|
|
mHighscoreList.insert (iter, entry);
|
|
mNewestHighscoreEntryIndex = counter;
|
|
break;
|
|
}
|
|
iter++;
|
|
counter ++;
|
|
}
|
|
|
|
if (mHighscoreList.size() < 10) {
|
|
mHighscoreList.push_back(entry);
|
|
mNewestHighscoreEntryIndex = mHighscoreList.size();
|
|
return mHighscoreList.size();
|
|
}
|
|
|
|
while (mHighscoreList.size() > 10) {
|
|
mHighscoreList.pop_back();
|
|
}
|
|
|
|
if (counter < 10)
|
|
return counter;
|
|
|
|
mNewestHighscoreEntryIndex = 99999;
|
|
|
|
return 99999;
|
|
}
|
|
|
|
int Model::DoLoadLevel (const char* filename) {
|
|
Engine::LogMessage ("Loading level from %s", filename);
|
|
std::fstream level_file (filename, std::ios::in);
|
|
|
|
if (!level_file) {
|
|
Engine::LogError ("Unable to open file %s for writing!", filename);
|
|
exit (-1);
|
|
}
|
|
|
|
ClearEntities();
|
|
mAsteroids.clear();
|
|
|
|
std::string entity_type_str;
|
|
|
|
int entity_count = 0;
|
|
|
|
while (level_file >> entity_type_str) {
|
|
if (entity_type_str[0] == '#') {
|
|
getline (level_file, entity_type_str);
|
|
Engine::LogDebug ("Read Comment: %s", entity_type_str.c_str());
|
|
continue;
|
|
}
|
|
|
|
GameEntityType entity_type = GameEntityTypeUnknown;
|
|
|
|
if (entity_type_str == "GameEntityTypeShip")
|
|
entity_type = GameEntityTypeShip;
|
|
else if (entity_type_str == "GameEntityTypeAsteroid")
|
|
entity_type = GameEntityTypeAsteroid;
|
|
else {
|
|
Engine::LogError ("Unknown Entity type: %s", entity_type_str.c_str());
|
|
exit (-1);
|
|
}
|
|
|
|
Engine::EntityBase* entity = CreateEntity (entity_type);
|
|
|
|
bool is_player;
|
|
level_file >> is_player;
|
|
|
|
if (is_player)
|
|
mPlayerEntityId = entity->mId;
|
|
|
|
level_file >> entity->mPhysicState->mPosition[0];
|
|
level_file >> entity->mPhysicState->mPosition[1];
|
|
level_file >> entity->mPhysicState->mPosition[2];
|
|
|
|
level_file >> entity->mPhysicState->mOrientation[0];
|
|
level_file >> entity->mPhysicState->mOrientation[1];
|
|
level_file >> entity->mPhysicState->mOrientation[2];
|
|
|
|
level_file >> entity->mPhysicState->mVelocity[0];
|
|
level_file >> entity->mPhysicState->mVelocity[1];
|
|
level_file >> entity->mPhysicState->mVelocity[2];
|
|
|
|
level_file >> entity->mPhysicState->mAngleVelocity;
|
|
|
|
entity_count ++;
|
|
}
|
|
|
|
level_file.close();
|
|
|
|
Engine::LogDebug ("%d Entities loaded!", mEntities.size());
|
|
|
|
return 0;
|
|
}
|
|
|
|
int Model::DoSaveLevel (const char* filename) {
|
|
Engine::LogMessage ("Saving level to %s", filename);
|
|
std::fstream level_file (filename, std::ios::out);
|
|
|
|
if (!level_file) {
|
|
Engine::LogError ("Unable to open file %s for writing!", filename);
|
|
exit (-1);
|
|
}
|
|
|
|
level_file << "# Format" << std::endl;
|
|
level_file << "# <Type> <player?> <xpos> <ypos> <zpos> <zrot> <yrot> <xrot> <xvel> <yvel> <zvel> <rotvel>" << std::endl;
|
|
|
|
std::map<unsigned int, Engine::EntityBase*>::iterator iter = mEntities.begin();
|
|
unsigned int player_id = GetPlayerEntityId();
|
|
|
|
for (iter = mEntities.begin(); iter != mEntities.end(); iter++) {
|
|
Engine::EntityBase* game_entity = iter->second;
|
|
|
|
level_file << GetStringGameEntityType((GameEntityType)game_entity->mType) << "\t"
|
|
// this stores the player id
|
|
<< (game_entity->mId == player_id) << "\t"
|
|
<< game_entity->mPhysicState->mPosition[0] << "\t"
|
|
<< game_entity->mPhysicState->mPosition[1] << "\t"
|
|
<< game_entity->mPhysicState->mPosition[2] << "\t"
|
|
<< game_entity->mPhysicState->mOrientation[0] << "\t"
|
|
<< game_entity->mPhysicState->mOrientation[1] << "\t"
|
|
<< game_entity->mPhysicState->mOrientation[2] << "\t"
|
|
<< game_entity->mPhysicState->mVelocity[0] << "\t"
|
|
<< game_entity->mPhysicState->mVelocity[1] << "\t"
|
|
<< game_entity->mPhysicState->mVelocity[2] << "\t"
|
|
<< game_entity->mPhysicState->mAngleVelocity << "\t"
|
|
<< std::endl;
|
|
}
|
|
|
|
level_file.close();
|
|
return 0;
|
|
}
|
|
|
|
bool Model::OnLevelComplete() {
|
|
Engine::LogMessage ("Level complete!");
|
|
|
|
if (mCurrentLevelIndex + 1 == mLevelList.size()) {
|
|
Engine::EventBasePtr gameover_event (new Engine::EventBase());
|
|
gameover_event->mEventType = EventGameOver;
|
|
QueueEvent (gameover_event);
|
|
} else {
|
|
SetGameState (GameStateLevelComplete);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Model::OnGameOver() {
|
|
Engine::LogMessage ("Points = %d lowest = %d", mPoints, mHighscoreList.back().points );
|
|
if (mPoints > mHighscoreList.back().points) {
|
|
Engine::LogMessage ("New Highscore!");
|
|
AddHighscoreEntry (mPlayerName, mPoints);
|
|
}
|
|
SetGameState(GameStateGameOver);
|
|
|
|
return false;
|
|
};
|
|
|
|
void Model::OnNewGame() {
|
|
mNewestHighscoreEntryIndex = 99999;
|
|
mPlayerLives = 1;
|
|
mCurrentLevelIndex = 0;
|
|
mPoints = 0;
|
|
DoLoadLevel (mLevelList[mCurrentLevelIndex].c_str());
|
|
}
|
|
|
|
void Model::OnCreateEntity (const int type, const unsigned int id) {
|
|
GameEntityType entity_type = (GameEntityType) type;
|
|
|
|
if (entity_type == GameEntityTypeAsteroid) {
|
|
mAsteroids.push_back (id);
|
|
}
|
|
}
|
|
|
|
void Model::OnKillEntity (const Engine::EntityBase *entity) {
|
|
GameEntityType entity_type = (GameEntityType) entity->mType;
|
|
|
|
if (entity_type == GameEntityTypeAsteroid) {
|
|
unsigned int i;
|
|
const AsteroidEntity *asteroid = static_cast<const AsteroidEntity*>(entity);
|
|
mPoints += 150 + asteroid->mSubAsteroidsCount * 75;
|
|
|
|
for (i = 0; i < mAsteroids.size(); i++) {
|
|
if (mAsteroids.at(i) == entity->mId) {
|
|
std::vector<unsigned int>::iterator entity_iter = mAsteroids.begin() + i;
|
|
mAsteroids.erase (entity_iter);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (mAsteroids.size() == 0) {
|
|
Engine::EventBasePtr level_complete_event (new Engine::EventBase());
|
|
level_complete_event->mEventType = EventLevelComplete;
|
|
TriggerEvent (level_complete_event);
|
|
}
|
|
}
|
|
}
|
|
|
|
float Model::GetWorldWidth () {
|
|
return static_cast<Physics*>(mPhysics)->GetWorldWidth();
|
|
}
|
|
|
|
float Model::GetWorldHeight () {
|
|
return static_cast<Physics*>(mPhysics)->GetWorldHeight();
|
|
}
|
|
|
|
}
|
|
|
|
|