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

Started to remove the various kart lists in various objects.

Browse Source 
1) Removed getKart from RaceManager.
2) Renamged RaceManager::getNumKarts() to getNumberOfKarts.
   This function should only be called when the world
   does not exist (or is not yet initialised). 	In all
   other cases world::getNumKarts() should be called.
3) Improved several 'const' functions.


git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/main/trunk@4676 178a84e3-b1eb-0310-8ba1-8eac791a3b58
This commit is contained in:
hikerstk 2010-02-10 11:40:33 +00:00
parent f78001c7b2
commit c6bf95a64c
41 changed files with 295 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/challenges/challenge_data.cpp
View File

@ -265,10 +265,11 @@ bool ChallengeData::raceFinished()
// Single races
// ------------
std::string track_name = RaceManager::getTrack()->getIdent();
if(track_name!=m_track_name ) return false; // wrong track
if((int)race_manager->getNumKarts()<m_num_karts) return false; // not enough AI karts
if(track_name!=m_track_name ) return false; // wrong track
World *world = RaceManager::getWorld();
if((int)world->getNumKarts()<m_num_karts ) return false; // not enough AI karts
Kart* kart = RaceManager::getPlayerKart(0);
PlayerKart* kart = RaceManager::getPlayerKart(0);
if(m_energy>0 && kart->getEnergy() <m_energy ) return false; // not enough energy
if(m_position>0 && kart->getPosition()>m_position) return false; // too far behind
@ -295,12 +296,13 @@ bool ChallengeData::raceFinished()
// ----------------------------------------------------------------------------
bool ChallengeData::grandPrixFinished()
{
// printf("----- checking if GP challenge is solved\n");
// Note that we have to call race_manager->getNumKarts, since there
// is no world objects to query at this stage.
if (race_manager->getMajorMode() != RaceManager::MAJOR_MODE_GRAND_PRIX ||
race_manager->getMinorMode() != m_minor ||
race_manager->getGrandPrix()->getId() != m_gp_id ||
race_manager->getDifficulty()!= m_difficulty ||
race_manager->getNumKarts() < (unsigned int)m_num_karts ||
race_manager->getNumberOfKarts() < (unsigned int)m_num_karts ||
race_manager->getNumPlayers() > 1) return false;
// check if the player came first.

8
src/graphics/camera.cpp
View File

@ -308,11 +308,13 @@ void Camera::update(float dt)
}
case CM_LEADER_MODE:
{
wanted_target = RaceManager::getKart(0)->getXYZ().toIrrVector();
World *world = RaceManager::getWorld();
Kart *kart = world->getKart(0);
wanted_target = kart->getXYZ().toIrrVector();
// Follows the leader kart, higher off of the ground, further from the kart,
// and turns in the opposite direction from the kart for a nice effect. :)
float angle_around = RaceManager::getKart(0)->getHPR().getX();
float angle_up = RaceManager::getKart(0)->getHPR().getY() + 40.0f*DEGREE_TO_RAD;
float angle_around = kart->getHPR().getX();
float angle_up = kart->getHPR().getY() + 40.0f*DEGREE_TO_RAD;
wanted_position.setX(sin(angle_around));
wanted_position.setY(cos(angle_around));
wanted_position.setZ(sin(angle_up) );

18
src/graphics/irr_driver.cpp
View File

@ -746,7 +746,8 @@ void IrrDriver::renderBulletDebugView()
float f=2.0f;
glFrustum(-f, f, -f, f, 1.0, 1000.0);
const Kart *kart = RaceManager::getKart(race_manager->getNumKarts()-1);
World *world = RaceManager::getWorld();
const Kart *kart = world->getKart(world->getNumKarts()-1);
Vec3 xyz = kart->getXYZ();
// Compute the camera position 5 units behind and 4 units higher than the kart
Vec3 cam_pos= kart->getTrans()(Vec3(0, -5, 4));
@ -757,12 +758,12 @@ void IrrDriver::renderBulletDebugView()
xyz.getX(), xyz.getY(), xyz.getZ(),
0.0f, 0.0f, 1.0f );
for (unsigned int i = 0 ; i < race_manager->getNumKarts(); ++i)
for (unsigned int i = 0 ; i < world->getNumKarts(); ++i)
{
Kart *kart=RaceManager::getKart((int)i);
Kart *kart=world->getKart((int)i);
if(!kart->isEliminated()) kart->draw();
}
RaceManager::getWorld()->getPhysics()->draw();
world->getPhysics()->draw();
#endif
} // renderBulletDebugView
@ -865,10 +866,13 @@ void IrrDriver::update(float dt)
m_video_driver->setViewPort(core::recti(0, 0,
UserConfigParams::m_width,
UserConfigParams::m_height));
for(unsigned int i=0; i<race_manager->getNumLocalPlayers(); i++)
World *world = RaceManager::getWorld();
for(unsigned int i=0; i<world->getNumKarts(); i++)
{
rg->renderPlayerView(i);
} // for i<getNumLocalPlayers
Kart *kart = world->getKart(i);
if(kart->getCamera())
rg->renderPlayerView(kart);
} // for i<getNumKarts
} // !bullet_debug
}
else

10
src/items/flyable.cpp
View File

@ -150,9 +150,10 @@ void Flyable::getClosestKart(const Kart **minKart, float *minDistSquared,
*minDistSquared = -1.0f;
*minKart = NULL;
for(unsigned int i=0 ; i<race_manager->getNumKarts(); i++ )
World *world = RaceManager::getWorld();
for(unsigned int i=0 ; i<world->getNumKarts(); i++ )
{
Kart *kart = RaceManager::getKart(i);
Kart *kart = world->getKart(i);
if(kart->isEliminated() || kart == m_owner || kart->isRescue() ) continue;
btTransform t=kart->getTrans();
@ -324,9 +325,10 @@ void Flyable::hit(Kart *kart_hit, PhysicalObject* object)
// Apply explosion effect
// ----------------------
for ( unsigned int i = 0 ; i < race_manager->getNumKarts() ; i++ )
World *world = RaceManager::getWorld();
for ( unsigned int i = 0 ; i < world->getNumKarts() ; i++ )
{
Kart *kart = RaceManager::getKart(i);
Kart *kart = world->getKart(i);
// Handle the actual explosion. The kart that fired a flyable will
// only be affected if it's a direct hit. This allows karts to use
// rockets on short distance.

39
src/items/item.cpp
View File

@ -35,6 +35,8 @@ Item::Item(ItemType type, const Vec3& xyz, const Vec3& normal,
// Sets heading to 0, and sets pitch and roll depending on the normal. */
Vec3 hpr = Vec3(0, normal);
m_coord = Coord(xyz, hpr);
m_rotate_to_normal = core::quaternion(hpr.toIrrVector());
m_rotate_amount = 0;
m_item_id = item_id;
m_original_type = ITEM_NONE;
m_collected = false;
@ -74,6 +76,7 @@ void Item::switchTo(ItemType type, scene::IMesh *mesh)
*/
void Item::switchBack()
{
// FIXME: debug only - printf to be able to set a breakpoint.
if(m_original_type==ITEM_NONE)
printf("XX");
assert(m_original_type!=ITEM_NONE);
@ -155,15 +158,39 @@ void Item::update(float dt)
m_node->setPosition(m_coord.getXYZ().toIrrVector());
return;
core::quaternion q;
q.rotationFromTo(core::vector3df(0,1,0), m_normal.toIrrVector());
m_rotate_amount += dt*M_PI;
if(m_rotate_amount>2*M_PI) m_rotate_amount -= 2*M_PI;
core::quaternion qx;
qx.fromAngleAxis(m_rotate_amount, m_normal.toIrrVector());
core::quaternion qall = m_rotate_to_normal*qx;
core::vector3df qeuler;
qx.toEuler(qeuler);
qeuler *= 180/3.1415926f;
m_node->setRotation(qeuler);
return;
const core::matrix4 &m=m_node->getAbsoluteTransformation();
core::quaternion current_rotation(m);
float anglec;
core::vector3df axisc;
current_rotation.toAngleAxis(anglec, axisc);
printf("curre %f axis %f %f %f\n", anglec,axisc.X, axisc.Y, axisc.Z);
core::quaternion q2;
static float t=0;
t += dt;
q2.fromAngleAxis(t, m_normal.toIrrVector());
core::quaternion all=q*q2;
q2.fromAngleAxis(dt*M_PI, m_normal.toIrrVector());
float angle2;
core::vector3df axis2;
q2.toAngleAxis(angle2, axis2);
printf("new %f axis %f %f %f\n", angle2,axis2.X, axis2.Y, axis2.Z);
core::quaternion all=current_rotation*q2;
float angle;
core::vector3df axis;
all.toAngleAxis(angle, axis);
printf("angle %f axis %f %f %f\n", angle,axis.X, axis.Y, axis.Z);
core::vector3df euler;
all.toEuler(euler);
euler *=180/3.1415926f;
m_node->setRotation(euler);
return;

4
src/items/item.hpp
View File

@ -61,7 +61,9 @@ private:
float m_time_till_return;
/** Original coordinates, used mainly when collected items reappear. */
Coord m_coord;
Coord m_coord;
core::quaternion m_rotate_to_normal;
float m_rotate_amount;
/** Scene node of this item. */
scene::IMeshSceneNode *m_node;

16
src/items/powerup.cpp
View File

@ -108,7 +108,7 @@ void Powerup::set(PowerupType type, int n)
} // set
//-----------------------------------------------------------------------------
Material *Powerup::getIcon()
Material *Powerup::getIcon() const
{
// Check if it's one of the types which have a separate
// data file which includes the icon:
@ -125,6 +125,7 @@ void Powerup::use()
if(m_sound_use == NULL) m_sound_use = sfx_manager->newSFX(SFXManager::SOUND_SHOT);
m_number--;
World *world = RaceManager::getWorld();
switch (m_type)
{
case POWERUP_ZIPPER: m_owner->handleZipper();
@ -163,9 +164,9 @@ void Powerup::use()
//Attach an anvil(twice as good as the one given
//by the bananas) to the kart in the 1st position.
for(unsigned int i = 0 ; i < race_manager->getNumKarts(); ++i)
for(unsigned int i = 0 ; i < world->getNumKarts(); ++i)
{
Kart *kart=RaceManager::getKart(i);
Kart *kart=world->getKart(i);
if(kart->isEliminated()) continue;
if(kart == m_owner) continue;
if(kart->getPosition() == 1)
@ -196,9 +197,9 @@ void Powerup::use()
//Attach a parachutte(that last as twice as the
//one from the bananas) to all the karts that
//are in front of this one.
for(unsigned int i = 0 ; i < race_manager->getNumKarts(); ++i)
for(unsigned int i = 0 ; i < world->getNumKarts(); ++i)
{
Kart *kart=RaceManager::getKart(i);
Kart *kart=world->getKart(i);
if(kart->isEliminated() || kart== m_owner) continue;
if(m_owner->getPosition() > kart->getPosition())
{
@ -256,9 +257,10 @@ void Powerup::hitBonusBox(int n, const Item &item, int add_info)
{
//If the driver in the first position has finished, give the driver
//the parachute.
for(unsigned int i=0; i < race_manager->getNumKarts(); ++i)
World *world = RaceManager::getWorld();
for(unsigned int i=0; i < world->getNumKarts(); ++i)
{
Kart *kart = RaceManager::getKart(i);
Kart *kart = world->getKart(i);
if(kart->isEliminated() || kart == m_owner) continue;
if(kart->getPosition() == 1 && kart->hasFinishedRace())
{

2
src/items/powerup.hpp
View File

@ -48,7 +48,7 @@ public:
int getNum () const {return m_number;}
PowerupType getType () const {return m_type; }
void hitBonusBox (int n, const Item &item, int newC=-1);
Material* getIcon ();
Material* getIcon () const;
void use ();
};

6
src/karts/kart.cpp
View File

@ -83,6 +83,7 @@ Kart::Kart (const std::string& kart_name, int position,
m_slip_stream = NULL;
m_skidmarks = NULL;
m_animated_node = NULL;
m_camera = NULL;
m_view_blocked_by_plunger = 0;
@ -824,12 +825,13 @@ float Kart::handleSlipstream(float dt)
// ------------------------------------------------------------------
m_slipstream_original_quad->transform(getTrans(), m_slipstream_quad);
unsigned int n = race_manager->getNumKarts();
World *world = RaceManager::getWorld();
unsigned int n = world->getNumKarts();
bool is_sstreaming = false;
Kart *target_kart;
for(unsigned int i=0; i<n; i++)
{
target_kart = race_manager->getKart(i);
target_kart = world->getKart(i);
// Don't test for slipstream with itself.
if(target_kart==this) continue;

30
src/karts/kart.hpp
View File

@ -23,6 +23,7 @@
#include "btBulletDynamicsCommon.h"
#include "graphics/camera.hpp"
#include "items/attachment.hpp"
#include "items/powerup.hpp"
#include "karts/moveable.hpp"
@ -48,17 +49,28 @@ class Stars;
class Kart : public TerrainInfo, public Moveable
{
private:
btTransform m_reset_transform; // reset position
unsigned int m_world_kart_id; // index of kart in world
float m_skidding; ///< Accumulated skidding factor.
/** Reset position. */
btTransform m_reset_transform;
/** Index of kart in world. */
unsigned int m_world_kart_id;
/** Accumulated skidding factor. */
float m_skidding;
int m_initial_position; // initial position of kart
int m_race_position; // current race position (1-numKarts)
/** The camera for each kart. Not all karts have cameras (e.g. AI karts
* usually don't), but there are exceptions: e.g. after the end of a
* race an AI kart is replacing the kart for a player.
*/
protected: // Used by the AI atm
KartControl m_controls; // The kart controls (e.g. steering, fire, ...)
Powerup m_powerup;
float m_zipper_time_left; /**<Zipper time left. */
Attachment m_attachment;
/** Easier access for player_kart. */
Camera *m_camera;
private:
float m_max_speed; // maximum speed of the kart, computed from
/** Depending on terrain a certain reduction to the maximum speed applies.
@ -205,7 +217,19 @@ public:
m_attachment.set(t, time_left, k);
}
// ------------------------------------------------------------------------
/** Returns the camera of this kart (or NULL if no camera is attached
* to this kart. */
Camera* getCamera () {return m_camera;}
/** Sets the camera for this kart. */
void setCamera(Camera *camera) {m_camera=camera; }
/** Sets viewport etc. for the camera of this kart. */
void activateCamera () {m_camera->activate(); }
/** Returns the viewport of the camera of this kart. */
const core::recti& getViewport() const {return m_camera->getViewport(); }
/** Returns the scaling in x/y direction for the camera of this kart. */
const core::vector2df& getScaling() const {return m_camera->getScaling(); }
const Powerup *getPowerup () const { return &m_powerup; }
Powerup *getPowerup () { return &m_powerup; }
int getNumPowerup () const { return m_powerup.getNum();}
float getEnergy () const { return m_collected_energy;}

7
src/karts/player_kart.cpp
View File

@ -47,7 +47,7 @@ PlayerKart::PlayerKart(const std::string& kart_name, int position,
{
m_player = player;
m_penalty_time = 0.0f;
m_camera = new Camera(player_index, this);
setCamera(new Camera(player_index, this));
m_camera->setMode(Camera::CM_NORMAL);
m_bzzt_sound = sfx_manager->newSFX(SFXManager::SOUND_BZZT );
@ -320,11 +320,12 @@ void PlayerKart::setPosition(int p)
{
if(getPosition()<p)
{
World *world = RaceManager::getWorld();
//have the kart that did the passing beep.
//I'm not sure if this method of finding the passing kart is fail-safe.
for(unsigned int i = 0 ; i < race_manager->getNumKarts(); i++ )
for(unsigned int i = 0 ; i < world->getNumKarts(); i++ )
{
Kart *kart = RaceManager::getWorld()->getKart(i);
Kart *kart = world->getKart(i);
if(kart->getPosition() == p + 1)
{
kart->beep();

10
src/karts/player_kart.hpp
View File

@ -23,12 +23,10 @@
#define HEADER_PLAYERKART_HPP
#include "config/player.hpp"
#include "graphics/camera.hpp"
#include "karts/kart.hpp"
class SFXBase;
class Player;
class Camera;
/** PlayerKart manages control events from the player and moves
them to the Kart */
@ -41,7 +39,6 @@ private:
ActivePlayer *m_player;
float m_penalty_time;
Camera *m_camera;
SFXBase *m_bzzt_sound;
SFXBase *m_wee_sound;
@ -66,15 +63,8 @@ public:
virtual void setPosition (int p);
virtual void raceFinished (float time);
bool isPlayerKart () const {return true;}
Camera* getCamera () {return m_camera;}
void reset ();
void resetInputState ();
/** Sets viewport etc. for the camera of this kart. */
void activateCamera () {m_camera->activate(); }
/** Returns the viewport of the camera of this kart. */
const core::recti& getViewport() const {return m_camera->getViewport(); }
/** Returns the scaling in x/y direction for the camera of this kart. */
const core::vector2df& getScaling() const {return m_camera->getScaling(); }
};
#endif

2
src/main_loop.cpp
View File

@ -103,7 +103,7 @@ void MainLoop::updateRace(float dt)
// Client: send current controls to server
// But don't do this if the race is in finish phase (otherwise
// messages can be mixed up in the race manager)
if(!race_manager->getWorld()->isFinishPhase())
if(!RaceManager::getWorld()->isFinishPhase())
network_manager->sendUpdates();
if(ProfileWorld::isProfileMode()) dt=1.0f/60.0f;

4
src/modes/follow_the_leader.cpp
View File

@ -131,7 +131,7 @@ RaceGUI::KartIconDisplayInfo* FollowTheLeaderRace::getKartsDisplayInfo()
//-----------------------------------------------------------------------------
void FollowTheLeaderRace::raceResultOrder( int* order )
{
const unsigned int NUM_KARTS = race_manager->getNumKarts();
const unsigned int NUM_KARTS = getNumKarts();
int *scores = new int[NUM_KARTS];
double *race_time = new double[NUM_KARTS];
@ -170,7 +170,7 @@ void FollowTheLeaderRace::raceResultOrder( int* order )
} while(!sorted);
for(unsigned int i=1; i<NUM_KARTS; i++)
RaceManager::getKart(order[i])->setPosition(i);
RaceManager::getWorld()->getKart(order[i])->setPosition(i);
delete []scores;
delete []race_time;

10
src/modes/linear_world.cpp
View File

@ -126,7 +126,7 @@ void LinearWorld::update(float delta)
// especially updates the kart positions.
World::update(delta);
const unsigned int kart_amount = race_manager->getNumKarts();
const unsigned int kart_amount = getNumKarts();
// Do stuff specific to this subtype of race.
// ------------------------------------------
@ -323,7 +323,7 @@ RaceGUI::KartIconDisplayInfo* LinearWorld::getKartsDisplayInfo()
// Find the best time for the lap. We can't simply use
// the time of the kart at position 1, since the kart
// might have been overtaken by now
const unsigned int kart_amount = race_manager->getNumKarts();
const unsigned int kart_amount = getNumKarts();
for(unsigned int i = 0; i < kart_amount ; i++)
{
RaceGUI::KartIconDisplayInfo& rank_info = m_kart_display_info[i];
@ -422,12 +422,14 @@ void LinearWorld::terminateRace()
} // terminateRace
// ----------------------------------------------------------------------------
/** Sets up the mapping from kart position to kart index.
*/
void LinearWorld::raceResultOrder( int* order )
{
const unsigned int NUM_KARTS = race_manager->getNumKarts();
const unsigned int NUM_KARTS = getNumKarts();
for(unsigned int i=0; i < NUM_KARTS; i++)
{
order[RaceManager::getKart(i)->getPosition()-1] = i; // even for eliminated karts
order[getKart(i)->getPosition()-1] = i; // even for eliminated karts
}
} // raceResultOrder

4
src/modes/profile_world.cpp
View File

@ -85,7 +85,7 @@ Kart *ProfileWorld::createKart(const std::string &kart_ident, int index,
// karts can be seen.
Kart *newkart = loadRobot(kart_ident, index+1, init_pos);
if (index == (int)race_manager->getNumKarts()-1)
if (index == (int)getNumKarts()-1)
{
// The pointer to the camera does not have to be stored, since it
// the camera for robots is not modified.
@ -110,7 +110,7 @@ bool ProfileWorld::isRaceOver()
return getTime()>m_time;
// Now it must be laps based profiling:
return race_manager->getFinishedKarts()==race_manager->getNumKarts();
return race_manager->getFinishedKarts()==getNumKarts();
} // isRaceOver
//-----------------------------------------------------------------------------

4
src/modes/standard_race.cpp
View File

@ -41,7 +41,7 @@ void StandardRace::update(float dt)
if(!WorldStatus::isRacePhase()) return;
// All karts are finished
if(race_manager->getFinishedKarts() >= race_manager->getNumKarts() )
if(race_manager->getFinishedKarts() >= getNumKarts() )
{
enterRaceOverState();
unlock_manager->raceFinished();
@ -53,7 +53,7 @@ void StandardRace::update(float dt)
{
// Update the estimated finishing time for all karts that haven't
// finished yet.
const unsigned int kart_amount = race_manager->getNumKarts();
const unsigned int kart_amount = getNumKarts();
for(unsigned int i = 0; i < kart_amount ; i++)
{
if(!m_kart[i]->hasFinishedRace())

14
src/modes/three_strikes_battle.cpp
View File

@ -32,7 +32,7 @@ ThreeStrikesBattle::ThreeStrikesBattle() : World()
World::init();
// check for possible problems if AI karts were incorrectly added
if(race_manager->getNumKarts() > race_manager->getNumPlayers())
if(getNumKarts() > race_manager->getNumPlayers())
{
fprintf(stderr, "No AI exists for this game mode\n");
exit(1);
@ -96,7 +96,7 @@ void ThreeStrikesBattle::kartHit(const int kart_id)
removeKart(kart_id);
}
const unsigned int NUM_KARTS = race_manager->getNumKarts();
const unsigned int NUM_KARTS = getNumKarts();
int num_karts_many_lives = 0;
for( unsigned int n = 0; n < NUM_KARTS; ++n )
@ -127,7 +127,7 @@ void ThreeStrikesBattle::updateKartRanks()
// sort karts by their times then give each one its position.
// in battle-mode, long time = good (meaning he survived longer)
const unsigned int NUM_KARTS = race_manager->getNumKarts();
const unsigned int NUM_KARTS = getNumKarts();
int *karts_list = new int[NUM_KARTS];
for( unsigned int n = 0; n < NUM_KARTS; ++n ) karts_list[n] = n;
@ -173,7 +173,7 @@ void ThreeStrikesBattle::enterRaceOverState(const bool delay)
{
World::enterRaceOverState(delay);
// Add the results for the remaining kart
for(int i=0; i<(int)race_manager->getNumKarts(); i++)
for(unsigned int i=0; i<getNumKarts(); i++)
if(!m_kart[i]->isEliminated())
race_manager->RaceFinished(m_kart[i], WorldStatus::getTime());
} // enterRaceOverState
@ -205,7 +205,7 @@ void ThreeStrikesBattle::restartRace()
//-----------------------------------------------------------------------------
RaceGUI::KartIconDisplayInfo* ThreeStrikesBattle::getKartsDisplayInfo()
{
const unsigned int kart_amount = race_manager->getNumKarts();
const unsigned int kart_amount = getNumKarts();
for(unsigned int i = 0; i < kart_amount ; i++)
{
RaceGUI::KartIconDisplayInfo& rank_info = m_kart_display_info[i];
@ -313,8 +313,8 @@ void ThreeStrikesBattle::raceResultOrder( int* order )
{
updateKartRanks();
const unsigned int num_karts = race_manager->getNumKarts();
for( unsigned int kart_id = 0; kart_id < num_karts; ++kart_id )
const unsigned int num_karts = getNumKarts();
for( unsigned int kart_id = 0; kart_id < num_karts; ++kart_id )
{
const int pos = m_kart[kart_id]->getPosition() - 1;
assert(pos >= 0);

22
src/modes/world.cpp
View File

@ -102,7 +102,9 @@ void World::init()
// Create the physics
m_physics = new Physics();
assert(race_manager->getNumKarts() > 0);
unsigned int num_karts = race_manager->getNumberOfKarts();
assert(num_karts > 0);
// Load the track models - this must be done before the karts so that the
// karts can be positioned properly on (and not in) the tracks.
@ -112,7 +114,7 @@ void World::init()
m_network_karts.resize(race_manager->getNumPlayers());
m_local_player_karts.resize(race_manager->getNumLocalPlayers());
for(unsigned int i=0; i<race_manager->getNumKarts(); i++)
for(unsigned int i=0; i<num_karts; i++)
{
btTransform init_pos=m_track->getStartTransform(i);
const std::string& kart_ident = race_manager->getKartIdent(i);
@ -384,13 +386,14 @@ HighscoreEntry* World::getHighscores() const
HighscoreEntry* highscores =
highscore_manager->getHighscoreEntry(type,
race_manager->getNumKarts(),
getNumKarts(),
race_manager->getDifficulty(),
race_manager->getTrackName(),
race_manager->getNumLaps());
return highscores;
}
} // getHighscores
// ----------------------------------------------------------------------------
/*
* Usually called at the end of a race. Checks if the current times are worth a new
@ -458,6 +461,17 @@ void World::updateHighscores()
} // updateHighscores
//-----------------------------------------------------------------------------
/** Returns the n-th player kart. Note that this function is O(N), not O(1),
* so it shouldn't be called inside of loops.
*/
PlayerKart *World::getPlayerKart(int player) const
{
for(unsigned int i=0; i<m_kart.size(); i++)
if(m_kart[i]->isPlayerKart()) return (PlayerKart*)m_kart[i];
return NULL;
} // getPlayerKart
//-----------------------------------------------------------------------------
/** Called in follow-leader-mode to remove the last kart
*/

5
src/modes/world.hpp
View File

@ -32,7 +32,6 @@
class btRigidBody;
class Kart;
class PlayerKart;
class RaceGUI;
class SFXBase;
class Track;
@ -136,10 +135,11 @@ public:
void disableRace(); // Put race into limbo phase
/** Returns a pointer to the race gui. */
RaceGUI *getRaceGUI() const { return m_race_gui; }
PlayerKart *getPlayerKart(int player) const { return m_player_karts[player]; }
PlayerKart *getPlayerKart(int player) const;
unsigned int getCurrentNumLocalPlayers() const { return m_local_player_karts.size(); }
PlayerKart *getLocalPlayerKart(int n) const { return m_local_player_karts[n]; }
NetworkKart *getNetworkKart(int n) const { return m_network_karts[n]; }
unsigned int getNumKarts() const { return m_kart.size(); }
Kart *getKart(int kartId) const { assert(kartId >= 0 &&
kartId < int(m_kart.size()));
return m_kart[kartId]; }
@ -214,6 +214,7 @@ public:
/** Called by the race result GUI at the end of the race to know the final order
(fill in the 'order' array) */
virtual void raceResultOrder( int* order ) = 0;
};
#endif

8
src/network/kart_update_message.cpp
View File

@ -25,7 +25,8 @@
KartUpdateMessage::KartUpdateMessage()
: Message(Message::MT_KART_INFO)
{
unsigned int num_karts = RaceManager::getWorld()->getCurrentNumKarts();
World *world = RaceManager::getWorld();
unsigned int num_karts = world->getNumKarts();
// Send the number of karts and for each kart the compressed
// control structure (3 ints) and xyz,hpr (4 floats: quaternion:
@ -35,7 +36,7 @@ KartUpdateMessage::KartUpdateMessage()
addChar(num_karts);
for(unsigned int i=0; i<num_karts; i++)
{
const Kart* kart = RaceManager::getKart(i);
const Kart* kart = world->getKart(i);
const KartControl& kc=kart->getControls();
kc.serialise(this);
addVec3(kart->getXYZ());
@ -46,6 +47,7 @@ KartUpdateMessage::KartUpdateMessage()
KartUpdateMessage::KartUpdateMessage(ENetPacket* pkt)
: Message(pkt, MT_KART_INFO)
{
World *world = RaceManager::getWorld();
unsigned int num_karts = getInt();
for(unsigned int i=0; i<num_karts; i++)
{
@ -53,7 +55,7 @@ KartUpdateMessage::KartUpdateMessage(ENetPacket* pkt)
KartControl kc(this);
Vec3 xyz = getVec3();
btQuaternion q = getQuaternion();
Kart *kart = RaceManager::getKart(i);
Kart *kart = world->getKart(i);
kart->setXYZ(xyz);
kart->setRotation(q);
} // for i

8
src/network/race_info_message.cpp
View File

@ -52,10 +52,10 @@ RaceInfoMessage::RaceInfoMessage(const std::vector<RemoteKartInfo>& kart_info)
len += getStringVectorLength(rkl);
allocate(len);
addChar(race_manager->getMajorMode() );
addInt (race_manager->getMinorMode() );
addChar(race_manager->getDifficulty());
addChar(race_manager->getNumKarts() );
addChar(race_manager->getMajorMode() );
addInt (race_manager->getMinorMode() );
addChar(race_manager->getDifficulty() );
addChar(race_manager->getNumberOfKarts());
if(race_manager->getMajorMode()==RaceManager::MAJOR_MODE_GRAND_PRIX)
addString(cup->getId());
else

6
src/network/race_result_message.cpp
View File

@ -28,9 +28,9 @@
*/
RaceResultMessage::RaceResultMessage() : Message(MT_RACE_RESULT)
{
const unsigned int num_karts = race_manager->getNumKarts();
allocate(num_karts * (getFloatLength()+getCharLength()));
World *world = race_manager->getWorld();
const unsigned int num_karts = world->getNumKarts();
allocate(num_karts * (getFloatLength()+getCharLength()));
for(unsigned int i=0; i<num_karts; i++)
{
const Kart *kart = world->getKart(i);
@ -47,8 +47,8 @@ RaceResultMessage::RaceResultMessage() : Message(MT_RACE_RESULT)
RaceResultMessage::RaceResultMessage(ENetPacket* pkt)
: Message(pkt, MT_RACE_RESULT)
{
const unsigned int num_karts = race_manager->getNumKarts();
World *world = race_manager->getWorld();
const unsigned int num_karts = world->getNumKarts();
for(unsigned int i=0; i<num_karts; i++)
{
Kart *kart = world->getKart(i);

18
src/network/race_state.cpp
View File

@ -62,9 +62,10 @@ void RaceState::serialise()
// 1. Kart positions
// -----------------
addChar(num_karts);
World *world = RaceManager::getWorld();
for(unsigned int i=0; i<num_karts; i++)
{
const Kart* kart = RaceManager::getKart(i);
const Kart* kart = world->getKart(i);
m_kart_controls[i].serialise(this);
addVec3(kart->getXYZ());
addQuaternion(kart->getRotation());
@ -116,13 +117,14 @@ void RaceState::receive(ENetPacket *pkt)
// 1. Kart information
// -------------------
unsigned int num_karts = getChar();
World *world = RaceManager::getWorld();
for(unsigned int i=0; i<num_karts; i++)
{
KartControl kc(this);
// Currently not used!
Vec3 xyz = getVec3();
btQuaternion q = getQuaternion();
Kart *kart = RaceManager::getKart(i);
Kart *kart = world->getKart(i);
// Firing needs to be done from here to guarantee that any potential
// new rockets are created before the update for the rockets is handled
if(kc.m_fire)
@ -139,10 +141,10 @@ void RaceState::receive(ENetPacket *pkt)
{
ItemInfo hi(this);
if(hi.m_item_id==-1) // Rescue triggered
RaceManager::getKart(hi.m_kart_id)->forceRescue();
world->getKart(hi.m_kart_id)->forceRescue();
else
item_manager->collectedItem(hi.m_item_id,
RaceManager::getKart(hi.m_kart_id),
world->getKart(hi.m_kart_id),
hi.m_add_info);
}
@ -167,12 +169,12 @@ void RaceState::receive(ENetPacket *pkt)
signed char kart_id2 = getChar();
if(kart_id2==-1)
{ // kart - track collision
RaceManager::getKart(kart_id1)->crashed(NULL);
}
world->getKart(kart_id1)->crashed(NULL);
}
else
{
RaceManager::getWorld()->getPhysics()->KartKartCollision(RaceManager::getKart(kart_id1),
RaceManager::getKart(kart_id2));
world->getPhysics()->KartKartCollision(world->getKart(kart_id1),
world->getKart(kart_id2));
}
} // for(i=0; i<num_collisions; i+=2)
clear(); // free message buffer

3
src/network/race_state.hpp
View File

@ -26,6 +26,7 @@
#include "items/item.hpp"
#include "karts/kart.hpp"
#include "karts/kart_control.hpp"
#include "modes/world.hpp"
#include "network/flyable_info.hpp"
#include "network/item_info.hpp"
#include "network/message.hpp"
@ -54,7 +55,7 @@ private:
/** Initialise the global race state. */
RaceState() : Message(MT_RACE_STATE)
{
m_kart_controls.resize(race_manager->getNumKarts());
m_kart_controls.resize(race_manager->getWorld()->getNumKarts());
} // RaceState()
// --------------------------------------------------------------------
void itemCollected(int kartid, int item_id, char add_info=-1)

4
src/race/highscores.cpp
View File

@ -151,7 +151,7 @@ int HighscoreEntry::addData(const std::string& kart_name,
if(position>=0)
{
m_track = race_manager->getTrackName();
m_number_of_karts = race_manager->getNumKarts();
m_number_of_karts = race_manager->getNumberOfKarts();
m_difficulty = race_manager->getDifficulty();
m_number_of_laps = race_manager->getNumLaps();
m_name[position] = name;
@ -160,8 +160,8 @@ int HighscoreEntry::addData(const std::string& kart_name,
}
return position+1;
} // addData
// -----------------------------------------------------------------------------
int HighscoreEntry::getNumberEntries() const
{

37
src/race/history.cpp
View File

@ -64,9 +64,10 @@ void History::initRecording()
void History::allocateMemory(int number_of_frames)
{
m_all_deltas.resize (number_of_frames);
m_all_controls.resize (number_of_frames*race_manager->getNumKarts());
m_all_xyz.resize (number_of_frames*race_manager->getNumKarts());
m_all_rotations.resize(number_of_frames*race_manager->getNumKarts());
unsigned int num_karts = RaceManager::getWorld()->getNumKarts();
m_all_controls.resize (number_of_frames*num_karts);
m_all_xyz.resize (number_of_frames*num_karts);
m_all_rotations.resize(number_of_frames*num_karts);
} // allocateMemory
//-----------------------------------------------------------------------------
@ -100,14 +101,12 @@ void History::updateSaving(float dt)
}
m_all_deltas[m_current] = dt;
unsigned int max_num_karts = race_manager->getNumKarts();
// n<=max_num_karts, e.g. if karts are eliminated
unsigned int n = race_manager->getNumKarts();
for(unsigned int i=0; i<n; i++)
World *world = RaceManager::getWorld();
unsigned int num_karts = world->getNumKarts();
for(unsigned int i=0; i<num_karts; i++)
{
unsigned int index=m_current*max_num_karts+i;
const Kart *kart = RaceManager::getKart(i);
unsigned int index = m_current*num_karts+i;
const Kart *kart = world->getKart(i);
m_all_controls[index] = kart->getControls();
m_all_xyz[index] = kart->getXYZ();
m_all_rotations[index] = kart->getRotation();
@ -126,10 +125,11 @@ void History::updateReplay(float dt)
printf("Replay finished.\n");
exit(2);
}
unsigned int num_karts = race_manager->getNumKarts();
World *world = RaceManager::getWorld();
unsigned int num_karts = world->getNumKarts();
for(unsigned k=0; k<num_karts; k++)
{
Kart *kart = RaceManager::getKart(k);
Kart *kart = world->getKart(k);
unsigned int index=m_current*num_karts+k;
if(m_replay_mode==HISTORY_POSITION)
{
@ -149,20 +149,21 @@ void History::updateReplay(float dt)
*/
void History::Save()
{
FILE *fd = fopen("history.dat","w");
int nKarts = race_manager->getNumKarts();
FILE *fd = fopen("history.dat","w");
World *world = RaceManager::getWorld();
int num_karts = world->getNumKarts();
#ifdef VERSION
fprintf(fd, "Version: %s\n", VERSION);
#endif
fprintf(fd, "numkarts: %d\n", nKarts);
fprintf(fd, "numkarts: %d\n", num_karts);
fprintf(fd, "numplayers: %d\n", race_manager->getNumPlayers());
fprintf(fd, "difficulty: %d\n", race_manager->getDifficulty());
fprintf(fd, "track: %s\n", RaceManager::getTrack()->getIdent().c_str());
int k;
for(k=0; k<nKarts; k++)
for(k=0; k<num_karts; k++)
{
fprintf(fd, "model %d: %s\n",k, RaceManager::getKart(k)->getIdent().c_str());
fprintf(fd, "model %d: %s\n",k, world->getKart(k)->getIdent().c_str());
}
fprintf(fd, "size: %d\n", m_size);
@ -173,7 +174,7 @@ void History::Save()
j=(j+1)%m_size;
}
for(int k=0; k<nKarts; k++)
for(int k=0; k<num_karts; k++)
{
//Kart* kart= RaceManager::getKart(k);
j = m_wrapped ? m_current : 0;

23
src/race/race_manager.cpp
View File

@ -40,27 +40,20 @@
RaceManager* race_manager= NULL;
World *RaceManager::m_world=NULL;
//-----------------------------------------------------------------------------
/** Call to set the world, or call setWorld(NULL) to delete the current world.
*/
void RaceManager::setWorld(World* world)
{
assert(!m_world);
m_world = world;
}
Track* RaceManager::getTrack()
{
return m_world->getTrack();
}
} // getTrack
//-----------------------------------------------------------------------------
PlayerKart* RaceManager::getPlayerKart(const unsigned int n)
{
return m_world->getPlayerKart(n);
}
Kart* RaceManager::getKart(const unsigned int n)
{
//if (n<0||n>2) printf("X");
return m_world->getKart(n);
}
} // getPlayerKart
//-----------------------------------------------------------------------------
/** Constructs the race manager.
@ -322,7 +315,7 @@ void RaceManager::exitRace()
if (m_major_mode==MAJOR_MODE_GRAND_PRIX && m_track_number==(int)m_tracks.size())
{
// calculate the rank of each kart
const unsigned int NUM_KARTS = race_manager->getNumKarts();
const unsigned int NUM_KARTS = getNumberOfKarts();
int *scores = new int[NUM_KARTS];
int *position = new int[NUM_KARTS];

13
src/race/race_manager.hpp
View File

@ -188,10 +188,10 @@ private:
unsigned int m_num_finished_karts;
unsigned int m_num_finished_players;
int m_coin_target;
static World *m_world;
/** 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)
@ -199,14 +199,15 @@ private:
return (left.m_score < right.m_score);
}
public:
bool m_active_race; //True if there is a race
static World* getWorld() {return m_world;}
static void setWorld(World* world);
/** Returns the world object. */
static World *getWorld() { return m_world; }
static Track* getTrack();
static PlayerKart* getPlayerKart(const unsigned int n);
static Kart* getKart(const unsigned int n);
public:
RaceManager();
@ -217,6 +218,9 @@ public:
getLocalKartInfo(unsigned int n) const {return m_local_kart_info[n];}
void setNumLocalPlayers(unsigned int n);
unsigned int getNumLocalPlayers() const {return m_local_kart_info.size(); };
/** Returns the selected number of karts (selected=number of players and
* AI karts. */
unsigned int getNumberOfKarts() const {return m_num_karts; }
void setNumPlayers(int num);
void setPlayerKart(unsigned int player_id, const RemoteKartInfo& ki);
@ -236,7 +240,6 @@ public:
getMajorMode() const { return m_major_mode; }
MinorRaceModeType
getMinorMode() const { return m_minor_mode; }
unsigned int getNumKarts() const { return m_num_karts; }
unsigned int getNumPlayers() const { return m_player_karts.size(); }
int getNumLaps() const { return m_num_laps[m_track_number];}
Difficulty getDifficulty() const { return m_difficulty; }

12
src/robots/default_robot.cpp
View File

@ -285,8 +285,8 @@ void DefaultRobot::handleBraking()
// In follow the leader mode, the kart should brake if they are ahead of
// the leader (and not the leader, i.e. don't have initial position 1)
if(race_manager->getMinorMode() == RaceManager::MINOR_MODE_FOLLOW_LEADER &&
getPosition() < RaceManager::getKart(0)->getPosition() &&
getInitialPosition()>1 )
getPosition() < m_world->getKart(0)->getPosition() &&
getInitialPosition()>1 )
{
m_controls.m_brake = true;
return;
@ -576,7 +576,7 @@ void DefaultRobot::computeNearestKarts()
m_kart_behind = m_kart_ahead = NULL;
m_distance_ahead = m_distance_behind = 9999999.9f;
float my_dist = m_world->getDistanceDownTrackForKart(getWorldKartId());
for(unsigned int i=0; i<race_manager->getNumKarts(); i++)
for(unsigned int i=0; i<m_world->getNumKarts(); i++)
{
Kart *k = m_world->getKart(i);
if(k->isEliminated() || k==this) continue;
@ -847,7 +847,7 @@ void DefaultRobot::checkCrashes( const int STEPS, const Vec3& pos )
//tell when a kart is going to get out of the track so it steers.
m_crashes.clear();
const size_t NUM_KARTS = race_manager->getNumKarts();
const size_t NUM_KARTS = m_world->getNumKarts();
//Protection against having vel_normal with nan values
const Vec3 &VEL = getVelocity();
@ -872,9 +872,9 @@ void DefaultRobot::checkCrashes( const int STEPS, const Vec3& pos )
{
for( unsigned int j = 0; j < NUM_KARTS; ++j )
{
const Kart* kart = RaceManager::getKart(j);
const Kart* kart = m_world->getKart(j);
if(kart==this||kart->isEliminated()) continue; // ignore eliminated karts
const Kart *other_kart = RaceManager::getKart(j);
const Kart *other_kart = m_world->getKart(j);
// Ignore karts ahead that are faster than this kart.
if(getVelocityLC().getY() < other_kart->getVelocityLC().getY())
continue;

10
src/robots/new_ai.cpp
View File

@ -289,7 +289,7 @@ void NewAI::handleBraking()
// In follow the leader mode, the kart should brake if they are ahead of
// the leader (and not the leader, i.e. don't have initial position 1)
if(race_manager->getMinorMode() == RaceManager::MINOR_MODE_FOLLOW_LEADER &&
getPosition() < RaceManager::getKart(0)->getPosition() &&
getPosition() < m_world->getKart(0)->getPosition() &&
getInitialPosition()>1 )
{
m_controls.m_brake = true;
@ -572,7 +572,7 @@ void NewAI::computeNearestKarts()
m_kart_behind = m_kart_ahead = NULL;
m_distance_ahead = m_distance_behind = 9999999.9f;
float my_dist = m_world->getDistanceDownTrackForKart(getWorldKartId());
for(unsigned int i=0; i<race_manager->getNumKarts(); i++)
for(unsigned int i=0; i<m_world->getNumKarts(); i++)
{
Kart *k = m_world->getKart(i);
if(k->isEliminated() || k==this) continue;
@ -843,7 +843,7 @@ void NewAI::checkCrashes( const int STEPS, const Vec3& pos )
//tell when a kart is going to get out of the track so it steers.
m_crashes.clear();
const size_t NUM_KARTS = race_manager->getNumKarts();
const size_t NUM_KARTS = m_world->getNumKarts();
//Protection against having vel_normal with nan values
const Vec3 &VEL = getVelocity();
@ -868,9 +868,9 @@ void NewAI::checkCrashes( const int STEPS, const Vec3& pos )
{
for( unsigned int j = 0; j < NUM_KARTS; ++j )
{
const Kart* kart = RaceManager::getKart(j);
const Kart* kart = m_world->getKart(j);
if(kart==this||kart->isEliminated()) continue; // ignore eliminated karts
const Kart *other_kart = RaceManager::getKart(j);
const Kart *other_kart = m_world->getKart(j);
// Ignore karts ahead that are faster than this kart.
if(getVelocityLC().getY() < other_kart->getVelocityLC().getY())
continue;

16
src/states_screens/dialogs/race_over_dialog.cpp
View File

@ -61,14 +61,12 @@ RaceOverDialog::RaceOverDialog(const float percentWidth,
caption->setTabStop(false);
caption->setTextAlignment(EGUIA_CENTER, EGUIA_CENTER);
const unsigned int num_karts = race_manager->getNumKarts();
int* order = new int [num_karts];
RaceManager::getWorld()->raceResultOrder( order );
const bool display_time =
(RaceManager::getWorld()->getClockMode() == WorldStatus::CLOCK_CHRONO);
World *world = RaceManager::getWorld();
const unsigned int num_karts = world->getNumKarts();
int* order = new int [num_karts];
world->raceResultOrder(order);
const bool display_time = (world->getClockMode() == WorldStatus::CLOCK_CHRONO);
int line_h = text_height + 15;
const int lines_from_y = text_height + 15;
@ -86,7 +84,7 @@ RaceOverDialog::RaceOverDialog(const float percentWidth,
stringw kart_results_line;
const Kart *current_kart = RaceManager::getKart(order[i]);
const Kart *current_kart = world->getKart(order[i]);
const stringw& kart_name = current_kart->getName();
char sTime[20];

11
src/states_screens/dialogs/track_info_dialog.cpp
View File

@ -197,11 +197,12 @@ void TrackInfoDialog::updateHighScores()
std::string game_mode_ident = RaceManager::getIdentOf( race_manager->getMinorMode() );
const HighscoreEntry::HighscoreType type = "HST_" + game_mode_ident;
HighscoreEntry* highscores = highscore_manager->getHighscoreEntry(type,
race_manager->getNumKarts(),
race_manager->getDifficulty(),
m_track_ident,
race_manager->getNumLaps());
HighscoreEntry* highscores =
highscore_manager->getHighscoreEntry(type,
race_manager->getNumberOfKarts(),
race_manager->getDifficulty(),
m_track_ident,
race_manager->getNumLaps() );
const int amount = highscores->getNumberEntries();
std::string kart_name;

60
src/states_screens/race_gui.cpp
View File

@ -94,10 +94,11 @@ RaceGUI::~RaceGUI()
*/
void RaceGUI::createMarkerTexture()
{
unsigned int n=race_manager->getNumKarts();
unsigned int npower2 = 1;
World *world = RaceManager::getWorld();
unsigned int num_karts = race_manager->getNumberOfKarts();
unsigned int npower2 = 1;
// Textures must be power of 2, so
while(npower2<n) npower2*=2;
while(npower2<num_karts) npower2*=2;
int radius = (m_marker_rendered_size>>1)-1;
IrrDriver::RTTProvider rttProvider(core::dimension2du(m_marker_rendered_size * npower2,
@ -126,7 +127,7 @@ void RaceGUI::createMarkerTexture()
video::SMaterial m;
m.setTexture(0, NULL);
irr_driver->getVideoDriver()->setMaterial(m);
for(unsigned int i=0; i<race_manager->getNumKarts(); i++)
for(unsigned int i=0; i<num_karts; i++)
{
const std::string& kart_ident = race_manager->getKartIdent(i);
const KartProperties *kp = kart_properties_manager->getKart(kart_ident);
@ -218,26 +219,23 @@ void RaceGUI::renderGlobal(float dt)
//-----------------------------------------------------------------------------
/** Render the details for a single player, i.e. speed, energy,
* collectibles, ...
* \param player_id Player id.
* \param viewport Viewport to use (already set in the camera).
* \param scaling Scaling to use.
* \param kart Pointer to the kart for which to render the view.
*/
void RaceGUI::renderPlayerView(unsigned int player_id)
void RaceGUI::renderPlayerView(const Kart *kart)
{
PlayerKart* player_kart = RaceManager::getWorld()->getLocalPlayerKart(player_id);
const core::recti &viewport = player_kart->getViewport();
const core::vector2df &scaling = player_kart->getScaling();
drawAllMessages (player_kart, viewport, scaling);
const core::recti &viewport = kart->getViewport();
const core::vector2df &scaling = kart->getScaling();
drawAllMessages (kart, viewport, scaling);
if(!RaceManager::getWorld()->isRacePhase()) return;
RaceGUI::KartIconDisplayInfo* info = RaceManager::getWorld()->getKartsDisplayInfo();
drawPowerupIcons (player_kart, viewport, scaling);
drawEnergyMeter (player_kart, viewport, scaling);
drawSpeed (player_kart, viewport, scaling);
drawLap (info, player_kart, viewport, scaling);
drawPowerupIcons (kart, viewport, scaling);
drawEnergyMeter (kart, viewport, scaling);
drawSpeed (kart, viewport, scaling);
drawLap (info, kart, viewport, scaling);
if(player_kart->hasViewBlockedByPlunger())
if(kart->hasViewBlockedByPlunger())
{
int offset_y = viewport.UpperLeftCorner.Y;
@ -300,9 +298,10 @@ void RaceGUI::drawGlobalMiniMap()
core::rect<s32> source(core::position2di(0, 0), mini_map->getOriginalSize());
irr_driver->getVideoDriver()->draw2DImage(mini_map, dest, source, 0, 0, true);
for(unsigned int i=0; i<race_manager->getNumKarts(); i++)
World *world = RaceManager::getWorld();
for(unsigned int i=0; i<world->getNumKarts(); i++)
{
const Kart *kart = RaceManager::getKart(i);
const Kart *kart = world->getKart(i);
if(kart->isEliminated()) continue; // don't draw eliminated kart
const Vec3& xyz = kart->getXYZ();
Vec3 draw_at;
@ -347,10 +346,11 @@ void RaceGUI::drawGlobalPlayerIcons(const KartIconDisplayInfo* info)
}
gui::IGUIFont* font = GUIEngine::getFont();
const unsigned int kart_amount = race_manager->getNumKarts();
World *world = RaceManager::getWorld();
const unsigned int kart_amount = world->getNumKarts();
for(unsigned int i = 0; i < kart_amount ; i++)
{
Kart* kart = RaceManager::getKart(i);
Kart* kart = world->getKart(i);
if(kart->isEliminated()) continue;
const int position = kart->getPosition();
@ -391,14 +391,14 @@ void RaceGUI::drawGlobalPlayerIcons(const KartIconDisplayInfo* info)
} // drawGlobalPlayerIcons
//-----------------------------------------------------------------------------
void RaceGUI::drawPowerupIcons(Kart* player_kart,
void RaceGUI::drawPowerupIcons(const Kart* kart,
const core::recti &viewport,
const core::vector2df &scaling)
{
// If player doesn't have anything, do nothing.
Powerup* powerup=player_kart->getPowerup();
const Powerup* powerup = kart->getPowerup();
if(powerup->getType() == POWERUP_NOTHING) return;
int n = player_kart->getNumPowerup() ;
int n = kart->getNumPowerup() ;
if(n<1) return; // shouldn't happen, but just in case
if(n>5) n=5; // Display at most 5 items
@ -424,11 +424,11 @@ void RaceGUI::drawPowerupIcons(Kart* player_kart,
//-----------------------------------------------------------------------------
/* Energy meter that gets filled with coins */
void RaceGUI::drawEnergyMeter (Kart *player_kart,
void RaceGUI::drawEnergyMeter (const Kart *kart,
const core::recti &viewport,
const core::vector2df &scaling)
{
float state = (float)(player_kart->getEnergy()) / MAX_ITEMS_COLLECTED;
float state = (float)(kart->getEnergy()) / MAX_ITEMS_COLLECTED;
int x = (int)((UserConfigParams::m_width-24) * scaling.X) + viewport.UpperLeftCorner.X;
//int y = (int)(250 * scaling.Y) + viewport.UpperLeftCorner.Y;
int y = viewport.LowerRightCorner.Y - (int)(250 * scaling.Y);
@ -485,7 +485,7 @@ void RaceGUI::drawEnergyMeter (Kart *player_kart,
} // drawEnergyMeter
//-----------------------------------------------------------------------------
void RaceGUI::drawSpeed(Kart* kart, const core::recti &viewport,
void RaceGUI::drawSpeed(const Kart* kart, const core::recti &viewport,
const core::vector2df &scaling)
{
@ -576,7 +576,7 @@ void RaceGUI::drawSpeed(Kart* kart, const core::recti &viewport,
} // drawSpeed
//-----------------------------------------------------------------------------
void RaceGUI::drawLap(const KartIconDisplayInfo* info, Kart* kart,
void RaceGUI::drawLap(const KartIconDisplayInfo* info, const Kart* kart,
const core::recti &viewport,
const core::vector2df &scaling)
{
@ -640,7 +640,7 @@ void RaceGUI::cleanupMessages(const float dt)
//-----------------------------------------------------------------------------
/** Displays all messages in the message queue
**/
void RaceGUI::drawAllMessages(Kart* player_kart,
void RaceGUI::drawAllMessages(const Kart* kart,
const core::recti &viewport,
const core::vector2df &scaling)
{
@ -657,7 +657,7 @@ void RaceGUI::drawAllMessages(Kart* player_kart,
TimedMessage const &msg = *i;
// Display only messages for all karts, or messages for this kart
if( msg.m_kart && msg.m_kart!=player_kart) continue;
if( msg.m_kart && msg.m_kart!=kart) continue;
core::rect<s32> pos(x, y, x, y);
GUIEngine::getFont()->draw(core::stringw(msg.m_message.c_str()).c_str(),

12
src/states_screens/race_gui.hpp
View File

@ -145,18 +145,18 @@ private:
video::S3DVertex *v, unsigned short int *index);
/* Display informat for one player on the screen. */
void drawEnergyMeter (Kart *player_kart,
void drawEnergyMeter (const Kart *kart,
const core::recti &viewport,
const core::vector2df &scaling);
void drawPowerupIcons (Kart* player_kart,
void drawPowerupIcons (const Kart* kart,
const core::recti &viewport,
const core::vector2df &scaling);
void drawAllMessages (Kart* player_kart,
void drawAllMessages (const Kart* kart,
const core::recti &viewport,
const core::vector2df &scaling);
void drawSpeed (Kart* kart, const core::recti &viewport,
void drawSpeed (const Kart* kart, const core::recti &viewport,
const core::vector2df &scaling);
void drawLap (const KartIconDisplayInfo* info, Kart* kart,
void drawLap (const KartIconDisplayInfo* info, const Kart* kart,
const core::recti &viewport,
const core::vector2df &scaling);
void drawGlobalPlayerIcons (const KartIconDisplayInfo* info);
@ -171,7 +171,7 @@ public:
RaceGUI();
~RaceGUI();
void renderGlobal(float dt);
void renderPlayerView(unsigned int player_id);
void renderPlayerView(const Kart *kart);
void addMessage(const irr::core::stringw &m, const Kart *kart, float time,
int fonst_size,

2
src/states_screens/race_setup_screen.cpp
View File

@ -152,7 +152,7 @@ void RaceSetupScreen::init()
w->setSelection( race_manager->getDifficulty(), GUI_PLAYER_ID );
SpinnerWidget* kartamount = getWidget<SpinnerWidget>("aikartamount");
kartamount->setValue( race_manager->getNumKarts() - race_manager->getNumPlayers() );
kartamount->setValue( race_manager->getNumberOfKarts() - race_manager->getNumPlayers() );
DynamicRibbonWidget* w2 = getWidget<DynamicRibbonWidget>("gamemode");
assert( w2 != NULL );

12
src/tracks/ambient_light_sphere.cpp
View File

@ -49,17 +49,17 @@ AmbientLightSphere::AmbientLightSphere(CheckManager *check_manager,
void AmbientLightSphere::update(float dt)
{
CheckStructure::update(dt);
race_manager->getNumLocalPlayers();
for(unsigned int i=0; i<race_manager->getNumKarts(); i++)
World *world = RaceManager::getWorld();
for(unsigned int i=0; i<world->getNumKarts(); i++)
{
Kart *kart=race_manager->getKart(i);
if(!kart->isPlayerKart()) continue;
Kart *kart=world->getKart(i);
if(!kart->getCamera()) continue;
if(isInside(i))
{
float d2=getDistance2ForKart(i);
video::SColor color;
Track *track=RaceManager::getWorld()->getTrack();
Track *track=world->getTrack();
if(d2<m_inner_radius2)
{ // Inside inner radius --> use new ambient color
color = m_ambient_color;

5
src/tracks/check_line.cpp
View File

@ -22,6 +22,7 @@
#include <string>
#include "io/xml_node.hpp"
#include "modes/world.hpp"
#include "race/race_manager.hpp"
/** Constructor for a checkline.
@ -32,7 +33,9 @@
CheckLine::CheckLine(CheckManager *check_manager, const XMLNode &node)
: CheckStructure(check_manager, node)
{
m_previous_sign.resize(race_manager->getNumKarts());
// Note that when this is called the karts have not been allocated
// in world, so we can't call world->getNumKarts()
m_previous_sign.resize(race_manager->getNumberOfKarts());
core::vector2df p1, p2;
node.get("p1", &p1);
node.get("p2", &p2);

7
src/tracks/check_sphere.cpp
View File

@ -39,9 +39,10 @@ CheckSphere::CheckSphere(CheckManager *check_manager, const XMLNode &node)
node.get("radius", &m_radius2);
m_radius2 *= m_radius2;
node.get("xyz", &m_center_point);
m_is_inside.resize(race_manager->getNumKarts());
m_distance2.resize(race_manager->getNumKarts());
for(unsigned int i=0; i< race_manager->getNumKarts(); i++)
unsigned int num_karts = RaceManager::getWorld()->getNumKarts();
m_is_inside.resize(num_karts);
m_distance2.resize(num_karts);
for(unsigned int i=0; i< num_karts; i++)
{
m_is_inside[i] = false;
}

10
src/tracks/check_structure.cpp
View File

@ -62,9 +62,10 @@ void CheckStructure::reset(const Track &track)
{
m_previous_position.clear();
m_is_active.clear();
for(unsigned int i=0; i<race_manager->getNumKarts(); i++)
World *world = RaceManager::getWorld();
for(unsigned int i=0; i<world->getNumKarts(); i++)
{
const Vec3 &xyz = race_manager->getKart(i)->getXYZ();
const Vec3 &xyz = world->getKart(i)->getXYZ();
m_previous_position.push_back(xyz);
// Activate all checkline
@ -78,9 +79,10 @@ void CheckStructure::reset(const Track &track)
*/
void CheckStructure::update(float dt)
{
for(unsigned int i=0; i<race_manager->getNumKarts(); i++)
World *world = RaceManager::getWorld();
for(unsigned int i=0; i<world->getNumKarts(); i++)
{
const Vec3 &xyz = race_manager->getKart(i)->getXYZ();
const Vec3 &xyz = world->getKart(i)->getXYZ();
// Only check active checklines.
if(m_is_active[i] && isTriggered(m_previous_position[i], xyz, i))
{

4
src/tracks/track.cpp
View File

@ -904,8 +904,8 @@ void Track::itemCommand(const Vec3 &xyz, Item::ItemType type,
// Don't tilt the items, since otherwise the rotation will look odd,
// i.e. the items will not rotate around the normal, but 'wobble'
// around.
//Vec3 normal(0.7, 0, 0.7);
Vec3 normal(0, 0, 1);
Vec3 normal(0.7071f, 0, 0.7071f);
//Vec3 normal(0, 0, 1);
item_manager->newItem(type, loc, normal);
} // itemCommand