ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1) Added alpha version of profile-mode (which replaces if-statements

Browse Source 
in world).
2) Moved camera management into race gui, so that the number of split screens
   used can be adjusted (and not only indirect via number of player) - this
   allows e.g. debug modes where you can see 4 AI karts at the same time,
   for profile mode, ...
3) Code cleanup.


git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/main/branches/irrlicht@3899 178a84e3-b1eb-0310-8ba1-8eac791a3b58
This commit is contained in:
hikerstk 2009-08-21 00:32:24 +00:00
parent bbfb30d4c5
commit ef175e94d4
23 changed files with 311 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Makefile.am
View File

@ -175,6 +175,8 @@ supertuxkart_SOURCES = \
modes/follow_the_leader.hpp \
modes/linear_world.cpp \
modes/linear_world.hpp \
modes/profile_world.cpp \
modes/profile_world.hpp \
modes/standard_race.cpp \
modes/standard_race.hpp \
modes/three_strikes_battle.cpp \

8
src/ide/vc9/supertuxkart.vcproj
View File

@ -388,6 +388,10 @@
RelativePath="..\..\modes\linear_world.cpp"
>
</File>
<File
RelativePath="..\..\modes\profile_world.cpp"
>
</File>
<File
RelativePath="..\..\modes\standard_race.cpp"
>
@ -1118,6 +1122,10 @@
RelativePath="..\..\modes\linear_world.hpp"
>
</File>
<File
RelativePath="..\..\modes\profile_world.hpp"
>
</File>
<File
RelativePath="..\..\modes\standard_race.hpp"
>

12
src/karts/player_kart.cpp
View File

@ -2,7 +2,7 @@
//
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2004-2005 Steve Baker <sjbaker1@airmail.net>
// Copyright (C) 2006 Joerg Henrichs, Steve Baker
// Copyright (C) 2006-2009 Joerg Henrichs, Steve Baker
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
@ -24,21 +24,22 @@
#include "audio/sfx_manager.hpp"
#include "config/player.hpp"
#include "graphics/camera.hpp"
#include "states_screens/race_gui.hpp"
#include "input/input_manager.hpp"
#include "items/item.hpp"
#include "modes/world.hpp"
#include "race/history.hpp"
#include "states_screens/race_gui.hpp"
#include "utils/constants.hpp"
#include "utils/translation.hpp"
PlayerKart::PlayerKart(const std::string& kart_name, int position, ActivePlayer *player,
const btTransform& init_pos, int player_index) :
PlayerKart::PlayerKart(const std::string& kart_name, int position,
ActivePlayer *player, const btTransform& init_pos,
unsigned int player_index) :
Kart(kart_name, position, init_pos)
{
m_player = player;
m_penalty_time = 0.0f;
m_camera = new Camera(player_index, this);
m_camera = RaceManager::getWorld()->getRaceGUI()->addCamera(player_index, this);
m_camera->setMode(Camera::CM_NORMAL);
m_bzzt_sound = sfx_manager->newSFX(SFXManager::SOUND_BZZT );
@ -215,7 +216,6 @@ void PlayerKart::steer(float dt, int steer_val)
//-----------------------------------------------------------------------------
void PlayerKart::update(float dt)
{
m_camera->update(dt);
// Don't do steering if it's replay. In position only replay it doesn't
// matter, but if it's physics replay the gradual steering causes
// incorrect results, since the stored values are already adjusted.

7
src/karts/player_kart.hpp
View File

@ -50,9 +50,10 @@ private:
void steer(float, int);
public:
PlayerKart(const std::string& kart_name,
int position, ActivePlayer *_player,
const btTransform& init_pos, int player_index);
PlayerKart(const std::string& kart_name,
int position, ActivePlayer *_player,
const btTransform& init_pos,
unsigned int player_index);
~PlayerKart ();
int earlyStartPenalty () { return m_penalty_time>0; }
ActivePlayer *getPlayer () { return m_player; }

9
src/modes/follow_the_leader.cpp
View File

@ -128,14 +128,17 @@ void FollowTheLeaderRace::restartRace()
m_leader_intervals.clear();
m_leader_intervals = stk_config->m_leader_intervals;
TimedRace::setClockMode(COUNTDOWN, m_leader_intervals[0]);
}
} // restartRace
//-----------------------------------------------------------------------------
std::string FollowTheLeaderRace::getInternalCode() const
/** Returns the internal identifier for this kind of race.
*/
std::string FollowTheLeaderRace::getIdent() const
{
return "FOLLOW_LEADER";
}
//-----------------------------------------------------------------------------
KartIconDisplayInfo* FollowTheLeaderRace::getKartsDisplayInfo()
RaceGUI::KartIconDisplayInfo* FollowTheLeaderRace::getKartsDisplayInfo()
{
LinearWorld::getKartsDisplayInfo();
m_kart_display_info[0].special_title = _("Leader");

5
src/modes/follow_the_leader.hpp
View File

@ -19,6 +19,7 @@
#define _follow_the_leader_hpp_
#include "modes/linear_world.hpp"
#include "states_screens/race_gui.hpp"
class FollowTheLeaderRace : public LinearWorld
{
@ -35,9 +36,9 @@ public:
// overriding World methods
virtual void update(float delta);
virtual void restartRace();
virtual std::string getInternalCode() const;
virtual std::string getIdent() const;
virtual bool useFastMusicNearEnd() const { return false; }
virtual KartIconDisplayInfo* getKartsDisplayInfo();
virtual RaceGUI::KartIconDisplayInfo* getKartsDisplayInfo();
virtual bool raceHasLaps(){ return false; }

8
src/modes/linear_world.cpp
View File

@ -39,7 +39,7 @@ void LinearWorld::init()
World::init();
const unsigned int kart_amount = m_kart.size();
m_kart_display_info = new KartIconDisplayInfo[kart_amount];
m_kart_display_info = new RaceGUI::KartIconDisplayInfo[kart_amount];
for(unsigned int n=0; n<kart_amount; n++)
{
@ -307,7 +307,7 @@ float LinearWorld::getTimeAtLapForKart(const int kart_id) const
} // getTimeAtLapForKart
//-----------------------------------------------------------------------------
KartIconDisplayInfo* LinearWorld::getKartsDisplayInfo()
RaceGUI::KartIconDisplayInfo* LinearWorld::getKartsDisplayInfo()
{
int laps_of_leader = -1;
float time_of_leader = -1;
@ -317,7 +317,7 @@ KartIconDisplayInfo* LinearWorld::getKartsDisplayInfo()
const unsigned int kart_amount = race_manager->getNumKarts();
for(unsigned int i = 0; i < kart_amount ; i++)
{
KartIconDisplayInfo& rank_info = m_kart_display_info[i];
RaceGUI::KartIconDisplayInfo& rank_info = m_kart_display_info[i];
Kart* kart = m_kart[i];
// reset color
@ -346,7 +346,7 @@ KartIconDisplayInfo* LinearWorld::getKartsDisplayInfo()
// we now know the best time of the lap. fill the remaining bits of info
for(unsigned int i = 0; i < kart_amount ; i++)
{
KartIconDisplayInfo& rank_info = m_kart_display_info[i];
RaceGUI::KartIconDisplayInfo& rank_info = m_kart_display_info[i];
KartInfo& kart_info = m_kart_info[i];
Kart* kart = m_kart[i];

9
src/modes/linear_world.hpp
View File

@ -18,11 +18,10 @@
#ifndef HEADER_LINEAR_WORLD_HPP
#define HEADER_LINEAR_WORLD_HPP
#include "modes/world.hpp"
#include <vector>
struct KartIconDisplayInfo;
#include "modes/world.hpp"
#include "states_screens/race_gui.hpp"
/*
* A 'linear world' is a subcategory of world used in 'standard' races, i.e.
* with a start line and a road that loops. This includes management of drivelines
@ -54,7 +53,7 @@ private:
};
protected:
KartIconDisplayInfo* m_kart_display_info;
RaceGUI::KartIconDisplayInfo* m_kart_display_info;
/** Linear races can trigger rescues for one additional reason : shortcuts.
* It may need to do some specific world before calling the generic Kart::forceRescue
@ -88,7 +87,7 @@ public:
void setTimeAtLapForKart(float t, const int kart_id);
float getTimeAtLapForKart(const int kart_id) const;
virtual KartIconDisplayInfo* getKartsDisplayInfo();
virtual RaceGUI::KartIconDisplayInfo* getKartsDisplayInfo();
virtual void moveKartAfterRescue(Kart* kart, btRigidBody* body);
virtual void terminateRace();

73
src/modes/profile_world.cpp Normal file
View File

@ -0,0 +1,73 @@
// $Id: profile_world.cpp 3882 2009-08-18 11:05:40Z davemk $
//
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2009 Joerg Henrichs
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 3
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "modes/profile_world.hpp"
#include "robots/default_robot.hpp"
//-----------------------------------------------------------------------------
/** Prints the profile statistic and exits!!
*/
ProfileWorld::~ProfileWorld()
{
float min_t=999999.9f, max_t=0.0, av_t=0.0;
for ( Karts::size_type i = 0; i < m_kart.size(); ++i)
{
max_t = std::max(max_t, m_kart[i]->getFinishTime());
min_t = std::min(min_t, m_kart[i]->getFinishTime());
av_t += m_kart[i]->getFinishTime();
printf("%s start %d end %d time %f\n",
m_kart[i]->getName().c_str(),(int)i,
m_kart[i]->getPosition(),
m_kart[i]->getFinishTime());
}
printf("min %f max %f av %f\n",min_t, max_t, av_t/m_kart.size());
std::exit(-2);
} // ~ProfileWorld
//-----------------------------------------------------------------------------
/** Creates a kart, having a certain position, starting location, and local
* and global player id (if applicable).
* \param kart_ident Identifier of the kart to create.
* \param index Index of the kart.
* \param local_player_id If the kart is a player kart this is the index of
* this player on the local machine.
* \param global_player_id If the akrt is a player kart this is the index of
* this player globally (i.e. including network players).
* \param init_pos The start XYZ coordinates.
*/
Kart *ProfileWorld::createKart(const std::string &kart_ident, int index,
int local_player_id, int global_player_id,
const btTransform &init_pos)
{
// Create a camera for the last kart (since this way more of the
// karts can be seen.
Kart *newkart = new DefaultRobot(kart_ident, index+1, init_pos, m_track);
if(index==race_manager->getNumKarts()-1)
{
// The pointer to the camera does not have to be stored, since it
// the camera for robots is not modified.
RaceManager::getWorld()->getRaceGUI()->addCamera(index, newkart);
}
//m_local_player_karts[index] = static_cast<PlayerKart*>(newkart);
//m_player_karts[index] = static_cast<PlayerKart*>(newkart);
m_local_player_karts.clear();
m_player_karts.clear();
return newkart;
} // createKart

39
src/modes/profile_world.hpp Normal file
View File

@ -0,0 +1,39 @@
// $Id: profile_world.hpp 3849 2009-08-13 11:12:26Z hikerstk $
//
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2009 Joerg Henrichs
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 3
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#ifndef HEADER_PROFILE_WORLD_HPP
#define HEADER_PROFILE_WORLD_HPP
#include "modes/standard_race.hpp"
class Kart;
class ProfileWorld : public StandardRace
{
virtual Kart *createKart(const std::string &kart_ident, int index,
int local_player_id, int global_player_id,
const btTransform &init_pos);
public:
virtual ~ProfileWorld();
/** Returns identifier for this world. */
virtual std::string getInternalCode() const {return "PROFILE"; }
};
#endif

32
src/modes/standard_race.cpp
View File

@ -24,13 +24,12 @@
StandardRace::StandardRace() : LinearWorld()
{
TimedRace::setClockMode(CHRONO);
LinearWorld::init();
}
} // StandardRace
//-----------------------------------------------------------------------------
StandardRace::~StandardRace()
{
}
} // ~StandardRace
#if 0
#pragma mark -
@ -47,12 +46,13 @@ void StandardRace::onGo()
{
m_kart[i]->resetBrakes();
}
}
} // onGo
//-----------------------------------------------------------------------------
void StandardRace::terminateRace()
{
LinearWorld::terminateRace();
}
} // terminateRace
#if 0
#pragma mark -
@ -63,7 +63,8 @@ void StandardRace::terminateRace()
void StandardRace::restartRace()
{
LinearWorld::restartRace();
}
} // restartRace
//-----------------------------------------------------------------------------
void StandardRace::update(float delta)
{
@ -74,7 +75,6 @@ void StandardRace::update(float delta)
if(race_manager->getFinishedKarts() >= race_manager->getNumKarts() )
{
TimedRace::enterRaceOverState();
if(UserConfigParams::m_profile<0) printProfileResultAndExit();
unlock_manager->raceFinished();
} // if all karts are finished
@ -86,7 +86,7 @@ void StandardRace::update(float delta)
// to give the AI some time to get non-estimated timings
TimedRace::enterRaceOverState(true /* delay */);
}
}
} // update
//-----------------------------------------------------------------------------
void StandardRace::getDefaultCollectibles(int& collectible_type, int& amount)
@ -98,18 +98,24 @@ void StandardRace::getDefaultCollectibles(int& collectible_type, int& amount)
amount = race_manager->getNumLaps();
}
else World::getDefaultCollectibles(collectible_type, amount);
}
} // getDefaultCollectibles
//-----------------------------------------------------------------------------
bool StandardRace::enableBonusBoxes()
/** Returns if this mode supports bonus boxes or not.
*/
bool StandardRace::haveBonusBoxes()
{
// in time trial mode, don't use bonus boxes
return race_manager->getMinorMode() != RaceManager::MINOR_MODE_TIME_TRIAL;
}
} // haveBonusBoxes
//-----------------------------------------------------------------------------
std::string StandardRace::getInternalCode() const
/** Returns an identifier for this race.
*/
std::string StandardRace::getIdent() const
{
if(race_manager->getMinorMode() == RaceManager::MINOR_MODE_TIME_TRIAL)
return "STD_TIMETRIAL";
else
return "STANDARD";
}
} // getIdent

4
src/modes/standard_race.hpp
View File

@ -38,8 +38,8 @@ public:
virtual void update(float delta);
virtual void restartRace();
virtual void getDefaultCollectibles(int& collectible_type, int& amount);
virtual bool enableBonusBoxes();
virtual std::string getInternalCode() const;
virtual bool haveBonusBoxes();
virtual std::string getIdent() const;
};
#endif

49
src/modes/three_strikes_battle.cpp
View File

@ -39,7 +39,7 @@ ThreeStrikesBattle::ThreeStrikesBattle() : World()
}
const unsigned int kart_amount = m_kart.size();
m_kart_display_info = new KartIconDisplayInfo[kart_amount];
m_kart_display_info = new RaceGUI::KartIconDisplayInfo[kart_amount];
for(unsigned int n=0; n<kart_amount; n++)
{
@ -51,12 +51,14 @@ ThreeStrikesBattle::ThreeStrikesBattle() : World()
// no positions in this mode
m_kart[n]->setPosition(-1);
}// next kart
}
} // ThreeStrikesBattle
//-----------------------------------------------------------------------------
ThreeStrikesBattle::~ThreeStrikesBattle()
{
delete[] m_kart_display_info;
}
} // ~ThreeStrikesBattle
//-----------------------------------------------------------------------------
void ThreeStrikesBattle::onGo()
{
@ -67,8 +69,9 @@ void ThreeStrikesBattle::onGo()
{
m_kart[i]->resetBrakes();
}
}
} // onGo
//-----------------------------------------------------------------------------
void ThreeStrikesBattle::terminateRace()
{
updateKartRanks();
@ -84,7 +87,8 @@ void ThreeStrikesBattle::terminateRace()
} // for i
World::terminateRace();
}
} // terminateRace
//-----------------------------------------------------------------------------
void ThreeStrikesBattle::kartHit(const int kart_id)
{
@ -109,12 +113,16 @@ void ThreeStrikesBattle::kartHit(const int kart_id)
sound_manager->switchToFastMusic();
m_faster_music_active = true;
}
}
} // kartHit
//-----------------------------------------------------------------------------
std::string ThreeStrikesBattle::getInternalCode() const
/** Returns the internal identifier for this race.
*/
std::string ThreeStrikesBattle::getIdent() const
{
return "BATTLE_3_STRIKES";
}
} // getIdent
//-----------------------------------------------------------------------------
void ThreeStrikesBattle::updateKartRanks()
{
@ -160,7 +168,8 @@ void ThreeStrikesBattle::updateKartRanks()
m_kart[ karts_list[n] ]->setPosition( n+1 );
}
delete [] karts_list;
}
} // updateKartRank
//-----------------------------------------------------------------------------
void ThreeStrikesBattle::update(float delta)
{
@ -178,7 +187,8 @@ void ThreeStrikesBattle::update(float delta)
TimedRace::enterRaceOverState();
return;
}
}
} // update
//-----------------------------------------------------------------------------
void ThreeStrikesBattle::restartRace()
{
@ -193,15 +203,15 @@ void ThreeStrikesBattle::restartRace()
// no positions in this mode
m_kart[n]->setPosition(-1);
}// next kart
}
//void ThreeStrikesBattle::getDefaultCollectibles(int& collectible_type, int& amount)
} // restartRace
//-----------------------------------------------------------------------------
KartIconDisplayInfo* ThreeStrikesBattle::getKartsDisplayInfo()
RaceGUI::KartIconDisplayInfo* ThreeStrikesBattle::getKartsDisplayInfo()
{
const unsigned int kart_amount = race_manager->getNumKarts();
for(unsigned int i = 0; i < kart_amount ; i++)
{
KartIconDisplayInfo& rank_info = m_kart_display_info[i];
RaceGUI::KartIconDisplayInfo& rank_info = m_kart_display_info[i];
// reset color
rank_info.lap = -1;
@ -237,7 +247,8 @@ KartIconDisplayInfo* ThreeStrikesBattle::getKartsDisplayInfo()
}
return m_kart_display_info;
}
} // getKartDisplayInfo
//-----------------------------------------------------------------------------
void ThreeStrikesBattle::moveKartAfterRescue(Kart* kart, btRigidBody* body)
{
@ -281,7 +292,8 @@ void ThreeStrikesBattle::moveKartAfterRescue(Kart* kart, btRigidBody* body)
body->setCenterOfMassTransform(pos);
}
} // moveKartAfterRescue
//-----------------------------------------------------------------------------
void ThreeStrikesBattle::raceResultOrder( int* order )
{
@ -295,7 +307,8 @@ void ThreeStrikesBattle::raceResultOrder( int* order )
assert(pos < (int)num_karts);
order[pos] = kart_id;
}
}
} // raceResultOrder
//-----------------------------------------------------------------------------
bool ThreeStrikesBattle::acceptPowerup(const int type) const
{
@ -303,5 +316,5 @@ bool ThreeStrikesBattle::acceptPowerup(const int type) const
if(type == POWERUP_PARACHUTE || type == POWERUP_ANVIL || type == POWERUP_ZIPPER) return false;
return true;
}
} // acceptPowerup

10
src/modes/three_strikes_battle.hpp
View File

@ -20,10 +20,10 @@
#ifndef THREE_STRIKES_HPP
#define THREE_STRIKES_HPP
#include "modes/world.hpp"
#include <string>
struct KartIconDisplayInfo;
#include "modes/world.hpp"
#include "states_screens/race_gui.hpp"
struct BattleInfo
{
@ -32,7 +32,7 @@ struct BattleInfo
class ThreeStrikesBattle : public World
{
KartIconDisplayInfo* m_kart_display_info;
RaceGUI::KartIconDisplayInfo* m_kart_display_info;
/** This vector contains an 'BattleInfo' struct for every kart in the race.
*/
@ -52,12 +52,12 @@ public:
//virtual void getDefaultCollectibles(int& collectible_type, int& amount);
//virtual bool enableBonusBoxes();
virtual bool useFastMusicNearEnd() const { return false; }
virtual KartIconDisplayInfo* getKartsDisplayInfo();
virtual RaceGUI::KartIconDisplayInfo* getKartsDisplayInfo();
virtual bool raceHasLaps(){ return false; }
virtual void moveKartAfterRescue(Kart* kart, btRigidBody* body);
virtual bool acceptPowerup(const int type) const;
virtual std::string getInternalCode() const;
virtual std::string getIdent() const;
virtual void kartHit(const int kart_id);

50
src/modes/world.cpp
View File

@ -52,6 +52,11 @@
#include "utils/string_utils.hpp"
//-----------------------------------------------------------------------------
/** Constructor. Note that in the constructor it is not possible to call any
* functions that use RaceManager::getWorld(), since this is only defined
* after the constructor. Those functions can be called in the init()
* function, which is called immediately after the constructor.
*/
World::World() : TimedRace()
{
m_physics = NULL;
@ -59,9 +64,12 @@ World::World() : TimedRace()
} // World
// ----------------------------------------------------------------------------
/** This function is called after the World constructor. In init() functions
* can be called that use RaceManager::getWorld(). The init function is
* called immediately after the constructor.
*/
void World::init()
{
RaceManager::setWorld(this);
race_state = new RaceState();
m_track = NULL;
m_faster_music_active = false;
@ -106,24 +114,11 @@ void World::init()
for(unsigned int i=0; i<race_manager->getNumKarts(); i++)
{
btTransform init_pos=m_track->getStartTransform(i);
Kart* newkart;
const std::string& kart_ident = race_manager->getKartIdent(i);
int local_player_id = race_manager->getKartLocalPlayerId(i);
int global_player_id = race_manager->getKartGlobalPlayerId(i);
if(UserConfigParams::m_profile)
{
// Create a camera for the last kart (since this way more of the
// karts can be seen.
newkart = new DefaultRobot(kart_ident, i+1, init_pos, m_track,
(i==race_manager->getNumKarts()-1) ? 0 : -1);
// FIXME: does this actually work???
m_local_player_karts[0] = static_cast<PlayerKart*>(newkart);
}
else
{
newkart = createKart(kart_ident, i, local_player_id,
global_player_id, init_pos);
} // if !UserConfigParams::m_profile
Kart* newkart = this->createKart(kart_ident, i, local_player_id,
global_player_id, init_pos);
m_kart.push_back(newkart);
newkart->setWorldKartId(m_kart.size()-1);
} // for i
@ -137,7 +132,7 @@ void World::init()
if(!history->replayHistory()) history->initRecording();
network_manager->worldLoaded();
} // World
} // init
//-----------------------------------------------------------------------------
/** Creates a kart, having a certain position, starting location, and local
@ -208,7 +203,7 @@ Kart* World::loadRobot(const std::string& kart_name, int position,
} // loadRobot
//-----------------------------------------------------------------------------
World::~World()
World::~World()
{
delete m_race_gui;
delete race_state;
@ -355,7 +350,7 @@ HighscoreEntry* World::getHighscores() const
{
if(!m_use_highscores) return NULL;
const HighscoreEntry::HighscoreType type = "HST_" + getInternalCode();
const HighscoreEntry::HighscoreType type = "HST_" + getIdent();
HighscoreEntry* highscores =
highscore_manager->getHighscoreEntry(type,
@ -432,23 +427,6 @@ void World::updateHighscores()
delete []index;
} // updateHighscores
//-----------------------------------------------------------------------------
void World::printProfileResultAndExit()
{
float min_t=999999.9f, max_t=0.0, av_t=0.0;
for ( Karts::size_type i = 0; i < m_kart.size(); ++i)
{
max_t = std::max(max_t, m_kart[i]->getFinishTime());
min_t = std::min(min_t, m_kart[i]->getFinishTime());
av_t += m_kart[i]->getFinishTime();
printf("%s start %d end %d time %f\n",
m_kart[i]->getName().c_str(),(int)i,
m_kart[i]->getPosition(),
m_kart[i]->getFinishTime());
}
printf("min %f max %f av %f\n",min_t, max_t, av_t/m_kart.size());
std::exit(-2);
} // printProfileResultAndExit
//-----------------------------------------------------------------------------
/** Called in follow-leader-mode to remove the last kart

15
src/modes/world.hpp
View File

@ -28,10 +28,10 @@
#include "network/network_kart.hpp"
#include "physics/physics.hpp"
#include "race/highscores.hpp"
#include "states_screens/race_gui.hpp"
#include "utils/random_generator.hpp"
class SFXBase;
struct KartIconDisplayInfo;
class btRigidBody;
class Track;
class RaceGUI;
@ -107,13 +107,12 @@ protected:
void removeKart (int kart_number);
Kart* loadRobot (const std::string& kart_name, int position,
const btTransform& init_pos);
void printProfileResultAndExit();
void estimateFinishTimes();
public:
virtual Kart *createKart(const std::string &kart_ident, int index,
int local_player_id, int global_player_id,
const btTransform &init_pos);
protected:
/** Pointer to the track. The track is managed by world. */
Track* m_track;
@ -128,7 +127,7 @@ public:
/** call just after instanciating. can't be moved to the contructor as child
classes must be instanciated, otherwise polymorphism will fail and the
results will be incorrect */
void init();
virtual void init();
virtual ~World();
virtual void update(float delta);
@ -169,10 +168,10 @@ public:
*/
virtual bool enableBonusBoxes(){ return true; }
/** Each game mode should have a unique internal code. Override
/** Each game mode should have a unique identifier. Override
* this method in child classes to provide it.
*/
virtual std::string getInternalCode() const = 0;
virtual std::string getIdent() const = 0;
virtual bool useFastMusicNearEnd() const { return true; }
@ -194,7 +193,7 @@ public:
/** Called by the code that draws the list of karts on the race GUI
* to know what needs to be drawn in the current mode
*/
virtual KartIconDisplayInfo* getKartsDisplayInfo() = 0;
virtual RaceGUI::KartIconDisplayInfo* getKartsDisplayInfo() = 0;
/** Since each mode will have a different way of deciding where a rescued
* kart is dropped, this method will be called and each mode can implement it.

46
src/race/race_manager.cpp
View File

@ -30,6 +30,7 @@
#include "input/input_manager.hpp"
#include "karts/kart_properties_manager.hpp"
#include "modes/follow_the_leader.hpp"
#include "modes/profile_world.hpp"
#include "modes/standard_race.hpp"
#include "modes/world.hpp"
#include "modes/three_strikes_battle.hpp"
@ -38,30 +39,26 @@
RaceManager* race_manager= NULL;
World *RaceManager::m_world=NULL;
//-----------------------------------------------------------------------------
World* world = NULL;
World* RaceManager::getWorld()
{
return world;
}
/** Call to set the world, or call setWorld(NULL) to delete the current world.
*/
void RaceManager::setWorld(World* world_arg)
void RaceManager::setWorld(World* world)
{
if(world != NULL) delete world;
world = world_arg;
assert(!m_world);
m_world = world;
}
Track* RaceManager::getTrack()
{
return world->getTrack();
return m_world->getTrack();
}
Kart* RaceManager::getPlayerKart(const unsigned int n)
{
return world->getPlayerKart(n);
return m_world->getPlayerKart(n);
}
Kart* RaceManager::getKart(const unsigned int n)
{
return world->getKart(n);
return m_world->getKart(n);
}
//-----------------------------------------------------------------------------
@ -77,6 +74,7 @@ RaceManager::RaceManager()
m_active_race = false;
m_score_for_position = stk_config->m_scores;
m_coin_target = 0;
m_world = NULL;
setTrack("jungle");
setNumLocalPlayers(0);
//setLocalKartInfo(0, "tux");
@ -255,11 +253,21 @@ void RaceManager::startNextRace()
// variable world. Admittedly a bit ugly, but simplifies
// handling of objects which get created in the constructor
// and need world to be defined.
if(m_minor_mode==MINOR_MODE_FOLLOW_LEADER) new FollowTheLeaderRace();
else if(m_minor_mode==MINOR_MODE_QUICK_RACE || m_minor_mode==MINOR_MODE_TIME_TRIAL) new StandardRace();
else if(m_minor_mode==MINOR_MODE_3_STRIKES) new ThreeStrikesBattle();
else{ fprintf(stderr,"Could not create given race mode\n"); assert(0); }
if (UserConfigParams::m_profile)
m_world = new ProfileWorld();
else if(m_minor_mode==MINOR_MODE_FOLLOW_LEADER)
m_world = new FollowTheLeaderRace();
else if(m_minor_mode==MINOR_MODE_QUICK_RACE ||
m_minor_mode==MINOR_MODE_TIME_TRIAL)
m_world = new StandardRace();
else if(m_minor_mode==MINOR_MODE_3_STRIKES)
m_world = new ThreeStrikesBattle();
else
{
fprintf(stderr,"Could not create given race mode\n");
assert(0);
}
m_world->init();
// Save the current score and set last time to zero. This is necessary
// if someone presses esc after finishing a gp, and selects restart:
// The race is rerun, and the points and scores get reset ... but if
@ -385,8 +393,8 @@ void RaceManager::exitRace()
// FIXME - back to main menu
// menu_manager->switchToMainMenu();
}
delete world;
world = 0;
delete m_world;
m_world = NULL;
m_track_number = 0;
m_active_race = false;
} // exitRace
@ -426,7 +434,7 @@ void RaceManager::rerunRace()
m_kart_status[i].m_score = m_kart_status[i].m_last_score;
m_kart_status[i].m_overall_time -= m_kart_status[i].m_last_time;
}
world->restartRace();
m_world->restartRace();
} // rerunRace
/* EOF */

5
src/race/race_manager.hpp
View File

@ -143,6 +143,9 @@ private:
unsigned int m_num_finished_players;
int m_coin_target;
/** The race manager manages the world, i.e. maintains
* this world pointer. */
static World *m_world;
void startNextRace(); // start a next race
friend bool operator< (const KartStatus& left, const KartStatus& right)
@ -153,7 +156,7 @@ private:
public:
bool m_active_race; //True if there is a race
static World* getWorld();
static World* getWorld() {return m_world;}
static void setWorld(World* world);
static Track* getTrack();
static Kart* getPlayerKart(const unsigned int n);

4
src/robots/default_robot.cpp
View File

@ -37,7 +37,6 @@
#ifdef AI_DEBUG
#include "graphics/irr_driver.hpp"
#endif
#include "graphics/camera.hpp"
#include "modes/linear_world.hpp"
#include "network/network_manager.hpp"
#include "race/race_manager.hpp"
@ -47,10 +46,9 @@
DefaultRobot::DefaultRobot(const std::string& kart_name,
int position, const btTransform& init_pos,
const Track *track, int camera_number ) :
const Track *track) :
AutoKart( kart_name, position, init_pos )
{
m_camera = camera_number >=0 ? new Camera(camera_number, this) : NULL;
m_kart_length = m_kart_properties->getKartModel()->getLength();
m_kart_width = m_kart_properties->getKartModel()->getWidth();
m_track = RaceManager::getTrack();

8
src/robots/default_robot.hpp
View File

@ -28,7 +28,6 @@ class Track;
class LinearWorld;
class QuadGraph;
class irr::scene::ISceneNode;
class Camera;
class DefaultRobot : public AutoKart
{
@ -154,10 +153,6 @@ private:
* is targeting at. */
irr::scene::ISceneNode *m_debug_sphere;
/** A camera that can be attached to a robot. This is mainly a debugging
* tool, used in working on the AI and in doing profile runs. Otherwise
* this variable is not used. */
Camera *m_camera;
/** The minimum steering angle at which the AI adds skidding. Lower values
* tend to improve the line the AI is driving. This is used to adjust for
* different AI levels.
@ -192,8 +187,7 @@ private:
public:
DefaultRobot(const std::string& kart_name, int position,
const btTransform& init_pos, const Track *track,
int camera_number=-1);
const btTransform& init_pos, const Track *track);
~DefaultRobot();
void update (float delta) ;
void reset ();

22
src/states_screens/race_gui.cpp
View File

@ -25,12 +25,14 @@ using namespace irr;
#include "audio/sound_manager.hpp"
#include "config/user_config.hpp"
#include "graphics/camera.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/material_manager.hpp"
#include "io/file_manager.hpp"
#include "input/input.hpp"
#include "input/input_manager.hpp"
#include "karts/kart_properties_manager.hpp"
#include "modes/world.hpp"
#include "race/race_manager.hpp"
#include "tracks/track.hpp"
#include "utils/constants.hpp"
@ -148,6 +150,17 @@ void RaceGUI::createRegularPolygon(unsigned int n, float radius,
} // createRegularPolygon
//-----------------------------------------------------------------------------
/** Adds a camera. The number of cameras determines e.g. if split screen is
* used.
*/
Camera *RaceGUI::addCamera(unsigned int index, Kart *kart)
{
Camera *camera = new Camera(index, kart);
m_cameras.push_back(camera);
return camera;
} // addCamera
//-----------------------------------------------------------------------------
/** Called before rendering, so no direct output to the screen can be done
* here.
@ -155,6 +168,9 @@ void RaceGUI::createRegularPolygon(unsigned int n, float radius,
*/
void RaceGUI::update(float dt)
{
std::vector<Camera*>::iterator i;
for(i=m_cameras.begin(); i!=m_cameras.end(); i++)
(*i)->update(dt);
cleanupMessages(dt);
} // update
@ -709,7 +725,7 @@ void RaceGUI::drawStatusText()
if(!RaceManager::getWorld()->isRacePhase()) return;
KartIconDisplayInfo* info = RaceManager::getWorld()->getKartsDisplayInfo();
RaceGUI::KartIconDisplayInfo* info = RaceManager::getWorld()->getKartsDisplayInfo();
for(unsigned int pla = 0; pla < num_players; pla++)
{
@ -769,7 +785,9 @@ void RaceGUI::drawStatusText()
plunger_x+plunger_size, offset_y+plunger_size);
const core::rect<s32> source(core::position2d<s32>(0,0), t->getOriginalSize());
irr_driver->getVideoDriver()->draw2DImage(t, dest, source);
irr_driver->getVideoDriver()->draw2DImage(t, dest, source, 0,
&video::SColor(255,255,255,255),
true);
}
} // next player

54
src/states_screens/race_gui.hpp
View File

@ -29,31 +29,30 @@ using namespace irr;
#include "config/player.hpp"
#include "graphics/material.hpp"
#include "karts/kart.hpp"
#include "karts/player_kart.hpp"
#include "modes/world.hpp"
#include "race/race_manager.hpp"
class Camera;
class InputMap;
class Kart;
class Material;
class RaceSetup;
/**
* Used to display the list of karts and their times or
* whatever other info is relevant to the current mode.
*/
struct KartIconDisplayInfo
{
std::string time;
float r, g, b;
std::string special_title;
/** Current lap of this kart, or -1 if irrelevant
*/
int lap;
};
class RaceGUI
{
public:
/**
* Used to display the list of karts and their times or
* whatever other info is relevant to the current mode.
*/
struct KartIconDisplayInfo
{
std::string time;
float r, g, b;
std::string special_title;
/** Current lap of this kart, or -1 if irrelevant
*/
int lap;
}; // KartIconDisplayInfo
private:
class TimedMessage
{
@ -63,6 +62,7 @@ private:
video::SColor m_color; // color of message
int m_font_size; // size
const Kart *m_kart;
// -----------------------------------------------------
// std::vector needs standard copy-ctor and std-assignment op.
// let compiler create defaults .. they'll do the job, no
// deep copies here ..
@ -75,14 +75,16 @@ private:
m_kart = kart;
m_remaining_time = ( time < 0.0f ) ? -1.0f : time;
m_color = color;
}
} // TimedMessage
// -----------------------------------------------------
// in follow leader the clock counts backwards
bool done(const float dt)
{
m_remaining_time -= dt;
return m_remaining_time < 0;
}
};
} // done
}; // TimedMessage
// ---------------------------------------------------------
Material *m_speed_meter_icon;
Material *m_speed_bar_icon;
@ -95,9 +97,11 @@ private:
/** Musical notes icon (for music description and credits) */
Material *m_music_icon;
// Minimap related variables
// -------------------------
/** The mini map of the track. */
video::ITexture *m_mini_map;
/** The size of a single marker in pixels, must be a power of 2. */
/** The size of a single marker in pixels, must be a power of 2. */
int m_marker_rendered_size;
/** The size of a single marker on the screen for AI karts,
@ -126,7 +130,8 @@ private:
/** Distance of map from bottom of screen. */
int m_map_bottom;
/** The list of all cameras. */
std::vector<Camera*> m_cameras;
void createMarkerTexture();
void createRegularPolygon(unsigned int n, float radius,
@ -160,6 +165,7 @@ public:
~RaceGUI();
void render();
void update(float dt);
Camera *addCamera(unsigned int index, Kart *kart);
void addMessage(const std::string &m, const Kart *kart, float time,
int fonst_size,
const video::SColor &color=video::SColor(255, 255, 0, 255));

2
src/tracks/track.cpp
View File

@ -744,7 +744,7 @@ void Track::loadTrackModel()
video::ITexture* t=irrMaterial.getTexture(j);
if(!t) continue;
core::matrix4 *m = &irrMaterial.getTextureMatrix(j);
m_animated_textures.push_back(new MovingTexture(m, 0.5f, 0.5f));
m_animated_textures.push_back(new MovingTexture(m, 0.05f, 0.05f));
} // for j<MATERIAL_MAX_TEXTURES
} // for i<getMaterialCount