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

Added handling of local/global player and player ids.

Browse Source 
git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/trunk/supertuxkart@2229 178a84e3-b1eb-0310-8ba1-8eac791a3b58
This commit is contained in:
hikerstk 2008-09-07 13:51:44 +00:00
parent ea579a3f62
commit ee0bb967c3
11 changed files with 423 additions and 379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/camera.cpp
View File

@ -22,11 +22,11 @@
#include "coord.hpp" #include "coord.hpp"
#include "world.hpp" #include "world.hpp"
#include "player_kart.hpp" #include "player_kart.hpp"
#include "track_manager.hpp"
#include "track.hpp" #include "track.hpp"
#include "camera.hpp" #include "camera.hpp"
#include "user_config.hpp" #include "user_config.hpp"
#include "constants.hpp" #include "constants.hpp"
#include "race_manager.hpp"
Camera::Camera(int camera_index, const Kart* kart) Camera::Camera(int camera_index, const Kart* kart)
{ {

2
src/gui/char_sel.cpp
View File

@ -357,7 +357,7 @@ void CharSel::select()
const KartProperties* KP = kart_properties_manager->getKartById(kart_id); const KartProperties* KP = kart_properties_manager->getKartById(kart_id);
if (KP != NULL) if (KP != NULL)
{ {
race_manager->setLocalPlayerKart(m_player_index, KP->getIdent()); race_manager->setLocalKartInfo(m_player_index, KP->getIdent());
user_config->m_player[m_player_index].setLastKartId(kart_id); user_config->m_player[m_player_index].setLastKartId(kart_id);
// Add selected kart (token) to selected karts vector so it cannot be // Add selected kart (token) to selected karts vector so it cannot be
// selected again // selected again

14
src/kart_properties_manager.cpp
View File

@ -160,7 +160,7 @@ int KartPropertiesManager::getKartByGroup(const std::string& group, int n) const
} // getKartByGroup } // getKartByGroup
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void KartPropertiesManager::fillWithRandomKarts(std::vector<std::string>& vec) void KartPropertiesManager::fillWithRandomKarts(std::vector<RemoteKartInfo>& vec)
{ {
// First: set up flags (based on global kart // First: set up flags (based on global kart
// index) for which karts are already used // index) for which karts are already used
@ -172,8 +172,8 @@ void KartPropertiesManager::fillWithRandomKarts(std::vector<std::string>& vec)
std::vector<std::string> all_karts; std::vector<std::string> all_karts;
for(unsigned int i=0; i<vec.size(); i++) for(unsigned int i=0; i<vec.size(); i++)
{ {
if(vec[i].empty()) continue; if(vec[i].getKartName()=="") continue;
int id=getKartId(vec[i]); int id=getKartId(vec[i].getKartName());
used[id] = true; used[id] = true;
count --; count --;
} }
@ -197,10 +197,10 @@ void KartPropertiesManager::fillWithRandomKarts(std::vector<std::string>& vec)
// there are no more karts in the current group // there are no more karts in the current group
for(unsigned int i=0; i<vec.size() && count>0 && karts.size()>0; i++) for(unsigned int i=0; i<vec.size() && count>0 && karts.size()>0; i++)
{ {
if(vec[i].empty()) if(vec[i].getKartName()=="")
{ {
used[karts.back()] = true; used[karts.back()] = true;
vec[i] = m_karts_properties[karts.back()]->getIdent(); vec[i] = RemoteKartInfo(m_karts_properties[karts.back()]->getIdent());
karts.pop_back(); karts.pop_back();
count --; count --;
} }
@ -219,9 +219,9 @@ void KartPropertiesManager::fillWithRandomKarts(std::vector<std::string>& vec)
// Then fill up the remaining empty spaces // Then fill up the remaining empty spaces
for(unsigned int i=0; i<vec.size() && count>0 && karts.size()>0; i++) for(unsigned int i=0; i<vec.size() && count>0 && karts.size()>0; i++)
{ {
if(vec[i].empty()) if(vec[i].getKartName()=="")
{ {
vec[i] = m_karts_properties[karts.back()]->getIdent(); vec[i] = RemoteKartInfo(m_karts_properties[karts.back()]->getIdent());
karts.pop_back(); karts.pop_back();
count --; count --;
} }

3
src/kart_properties_manager.hpp
View File

@ -22,6 +22,7 @@
#include <vector> #include <vector>
#include <map> #include <map>
#include "network/remote_kart_info.hpp"
class KartProperties; class KartProperties;
@ -59,7 +60,7 @@ public:
{return m_groups[g]; } {return m_groups[g]; }
/** Fill the empty positions in the given vector with random karts */ /** Fill the empty positions in the given vector with random karts */
void fillWithRandomKarts (std::vector<std::string>& vec); void fillWithRandomKarts (std::vector<RemoteKartInfo>& vec);
void removeTextures (); void removeTextures ();
}; };

4
src/main.cpp
View File

@ -184,7 +184,7 @@ int handleCmdLine(int argc, char **argv)
std::string filename=file_manager->getKartFile(std::string(argv[i+1])+".tkkf"); std::string filename=file_manager->getKartFile(std::string(argv[i+1])+".tkkf");
if(filename!="") if(filename!="")
{ {
race_manager->setLocalPlayerKart(0, argv[i+1]); race_manager->setLocalKartInfo(0, argv[i+1]);
fprintf ( stdout, "You choose to use kart '%s'.\n", argv[i+1] ) ; fprintf ( stdout, "You choose to use kart '%s'.\n", argv[i+1] ) ;
} }
else else
@ -555,7 +555,7 @@ int main(int argc, char *argv[] )
// Profiling // Profiling
// ========= // =========
race_manager->setNumPlayers(1); race_manager->setNumPlayers(1);
race_manager->setLocalPlayerKart(0, kart_properties_manager->getKart("tuxkart")->getIdent()); race_manager->setLocalKartInfo(0, kart_properties_manager->getKart("tuxkart")->getIdent());
race_manager->setMajorMode (RaceManager::RM_SINGLE); race_manager->setMajorMode (RaceManager::RM_SINGLE);
race_manager->setMinorMode (RaceManager::RM_QUICK_RACE); race_manager->setMinorMode (RaceManager::RM_QUICK_RACE);
race_manager->setDifficulty(RaceManager::RD_HARD); race_manager->setDifficulty(RaceManager::RD_HARD);

46
src/network/network_manager.cpp
View File

@ -38,9 +38,6 @@ NetworkManager::NetworkManager()
fprintf (stderr, "An error occurred while initializing ENet.\n"); fprintf (stderr, "An error occurred while initializing ENet.\n");
exit(-1); exit(-1);
} }
// FIXME: debugging
m_kart_info.push_back(RemoteKartInfo("tuxkart","xx", 1));
m_kart_info.push_back(RemoteKartInfo("yeti", "yy", 1));
#endif #endif
} // NetworkManager } // NetworkManager
@ -211,6 +208,7 @@ void NetworkManager::update(float dt)
} }
} // update } // update
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
/** Send race_manager->getNumPlayers(), the kart and the name of each /** Send race_manager->getNumPlayers(), the kart and the name of each
player to the server. player to the server.
@ -220,7 +218,7 @@ void NetworkManager::sendKartsInformationToServer()
for(int i=0; i<(int)race_manager->getNumLocalPlayers(); i++) for(int i=0; i<(int)race_manager->getNumLocalPlayers(); i++)
{ {
fprintf(stderr, "Sending name '%s', ",user_config->m_player[i].getName().c_str()); fprintf(stderr, "Sending name '%s', ",user_config->m_player[i].getName().c_str());
fprintf(stderr, "kart name '%s'\n", race_manager->getLocalPlayerKart(i).getKartName().c_str()); fprintf(stderr, "kart name '%s'\n", race_manager->getLocalKartInfo(i).getKartName().c_str());
} // for i<getNumLocalPlayers } // for i<getNumLocalPlayers
fprintf(stderr, "Client sending kart information to server\n"); fprintf(stderr, "Client sending kart information to server\n");
} // sendKartsInformationToServer } // sendKartsInformationToServer
@ -230,23 +228,32 @@ void NetworkManager::sendKartsInformationToServer()
*/ */
void NetworkManager::waitForKartsInformation() void NetworkManager::waitForKartsInformation()
{ {
m_kart_info.clear();
fprintf(stderr, "Server receiving all kart information\n"); fprintf(stderr, "Server receiving all kart information\n");
// FIXME: debugging
m_kart_info.push_back(RemoteKartInfo(0, "tuxkart","xx", 1));
m_kart_info.push_back(RemoteKartInfo(1, "yetikart", "yy", 1));
// First put the local karts into the race_manager: // Get the local kart info
for(unsigned int i=0; i<race_manager->getNumLocalPlayers(); i++)
m_kart_info.push_back(race_manager->getLocalKartInfo(i));
for(unsigned int i=0; i<(int)race_manager->getNumLocalPlayers(); i++) // Now sort by (hostid, playerid)
{ std::sort(m_kart_info.begin(), m_kart_info.end());
//FIXME race_manager->setPlayerKart(i, race_manager->getLocalPlayerKart(i),
// m_host_id); // Set the global player ID for each player
} for(unsigned int i=0; i<m_kart_info.size(); i++)
int offset=race_manager->getNumLocalPlayers(); m_kart_info[i].setGlobalPlayerId(i);
// FIXME: distribute m_kart_info to all clients
// Set the player kart information
race_manager->setNumPlayers(m_kart_info.size());
for(unsigned int i=0; i<m_kart_info.size(); i++) for(unsigned int i=0; i<m_kart_info.size(); i++)
{ {
// receive number of karts, kart name, and player name for each hosts, race_manager->setPlayerKart(i, m_kart_info[i]);
// and put it into the race_manager data structure: }
//FIXME race_manager->setPlayerKart(offset+i, m_kart_info[i].m_kart_name,
// m_kart_info[i].m_client_id);
} // for i
} // waitForKartsInformation } // waitForKartsInformation
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@ -255,10 +262,11 @@ void NetworkManager::waitForKartsInformation()
void NetworkManager::sendRaceInformationToClients() void NetworkManager::sendRaceInformationToClients()
{ {
fprintf(stderr, "server sending race_manager information to all clients\n"); fprintf(stderr, "server sending race_manager information to all clients\n");
for(unsigned i=0; i<race_manager->getNumPlayers(); i++) for(unsigned i=0; i<race_manager->getNumLocalPlayers(); i++)
{ {
// fprintf(stderr, "Sending kart '%s' host %d\n", const RemoteKartInfo& ki=race_manager->getLocalKartInfo(i);
//FIXME race_manager->getKartName(i), race_manager->getHostId(i)); fprintf(stderr, "Sending kart '%s' playerid %d host %d\n",
ki.getKartName(), ki.getLocalPlayerId(), ki.getHostId());
} // for i } // for i
} // sendRaceInformationToClients } // sendRaceInformationToClients

6
src/network/network_manager.hpp
View File

@ -63,10 +63,12 @@ public:
NetworkMode getMode() const {return m_mode; } NetworkMode getMode() const {return m_mode; }
void setState(NetworkState s) {m_state = s; } void setState(NetworkState s) {m_state = s; }
NetworkState getState() const {return m_state; } NetworkState getState() const {return m_state; }
int getClientId() const {return m_host_id; } int getHostId() const {return m_host_id; }
int getNumClients() const {return m_num_clients;} int getNumClients() const {return m_num_clients; }
void setPort(int p) {m_port=p; } void setPort(int p) {m_port=p; }
void setServerIP(const std::string &s) {m_server_address=s; } void setServerIP(const std::string &s) {m_server_address=s; }
void setKartInfo(int player_id, const std::string& kart,
const std::string& user="", int hostid=-1);
bool initialiseConnections(); bool initialiseConnections();
void update(float dt); void update(float dt);
void sendKartsInformationToServer(); void sendKartsInformationToServer();

31
src/network/remote_kart_info.hpp
View File

@ -26,19 +26,36 @@ class RemoteKartInfo
{ {
std::string m_kart_name; std::string m_kart_name;
std::string m_user_name; std::string m_user_name;
int m_client_id; int m_host_id;
int m_player_id; int m_local_player_id;
int m_global_player_id;
public: public:
RemoteKartInfo(std::string kart_name, std::string user_name, int id) RemoteKartInfo(int player_id, const std::string& kart_name,
: m_kart_name(kart_name), m_user_name(user_name), m_client_id(id) const std::string& user_name, int host_id)
: m_kart_name(kart_name), m_user_name(user_name),
m_local_player_id(player_id), m_host_id(host_id)
{}; {};
RemoteKartInfo() {m_kart_name=""; m_user_name=""; m_client_id=-1; m_player_id=-1;} RemoteKartInfo(const std::string& kart_name)
{m_kart_name=kart_name; m_user_name="";
m_host_id=-1; m_local_player_id=-1;}
RemoteKartInfo() {m_kart_name=""; m_user_name="";
m_host_id=-1; m_local_player_id=-1;}
void setKartName(const std::string& n) { m_kart_name = n; } void setKartName(const std::string& n) { m_kart_name = n; }
void setUserName(const std::string& u) { m_user_name = u; } void setUserName(const std::string& u) { m_user_name = u; }
void setClientId(int id) { m_client_id = id; } void setHostId(int id) { m_host_id = id; }
void setPlayerId(int id) { m_player_id = id; } void setLocalPlayerId(int id) { m_local_player_id = id; }
void setGlobalPlayerId(int id) { m_global_player_id = id; }
int getHostId() const { return m_host_id; }
int getLocalPlayerId() const { return m_local_player_id; }
int getGlobalPlayerId() const { return m_global_player_id; }
const std::string& getKartName() const {return m_kart_name; } const std::string& getKartName() const {return m_kart_name; }
const std::string& getPlayerName() const{return m_user_name; }
bool operator<(const RemoteKartInfo& other)
{
return (m_host_id<other.m_host_id ||
m_host_id==other.m_host_id && m_local_player_id<other.m_local_player_id);
}
}; // RemoteKartInfo }; // RemoteKartInfo
#endif #endif

49
src/race_manager.hpp
View File

@ -62,14 +62,16 @@ private:
double m_last_time; // needed for restart double m_last_time; // needed for restart
int m_prev_finish_pos; // previous finished position int m_prev_finish_pos; // previous finished position
KartType m_kart_type; // Kart type: AI, player, network player etc. KartType m_kart_type; // Kart type: AI, player, network player etc.
int m_player_id; // player controling the kart, for AI: -1 int m_local_player_id; // player controling the kart, for AI: -1
int m_global_player_id; // global ID of player
KartStatus(const std::string& ident, const int& prev_finish_pos, KartStatus(const std::string& ident, const int& prev_finish_pos,
const int& player_id, KartType kt) : int local_player_id, int global_player_id, KartType kt) :
m_ident(ident), m_score(0), m_last_score(0), m_ident(ident), m_score(0), m_last_score(0),
m_overall_time(0.0f), m_last_time(0.0f), m_overall_time(0.0f), m_last_time(0.0f),
m_prev_finish_pos(prev_finish_pos), m_kart_type(kt), m_prev_finish_pos(prev_finish_pos), m_kart_type(kt),
m_player_id(player_id) m_local_player_id(local_player_id),
m_global_player_id(global_player_id)
{} {}
}; // KartStatus }; // KartStatus
@ -78,8 +80,8 @@ private:
Difficulty m_difficulty; Difficulty m_difficulty;
RaceModeType m_major_mode, m_minor_mode; RaceModeType m_major_mode, m_minor_mode;
typedef std::vector<std::string> PlayerKarts; typedef std::vector<std::string> PlayerKarts;
PlayerKarts m_player_karts; std::vector<RemoteKartInfo> m_player_karts;
std::vector<RemoteKartInfo> m_local_player_karts; std::vector<RemoteKartInfo> m_local_kart_info;
std::vector<std::string> m_tracks; std::vector<std::string> m_tracks;
std::vector<int> m_host_ids; std::vector<int> m_host_ids;
std::vector<int> m_num_laps; std::vector<int> m_num_laps;
@ -102,20 +104,19 @@ public:
bool m_active_race; //True if there is a race bool m_active_race; //True if there is a race
public: public:
RaceManager(); RaceManager();
~RaceManager(); ~RaceManager();
void setPlayerKart(unsigned int player, const std::string& kart,
const std::string& player_name, int hostid);
void setLocalPlayerKart(unsigned int player, const std::string& kart);
const RemoteKartInfo&
getLocalPlayerKart(unsigned int p) const {return m_local_player_karts[p]; }
void reset(); void reset();
void setLocalKartInfo(unsigned int player_id, const std::string& kart);
const RemoteKartInfo&
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(); };
void setNumPlayers(int num);
void setPlayerKart(unsigned int player_id, const RemoteKartInfo& ki);
void RaceFinished(const Kart* kart, float time); void RaceFinished(const Kart* kart, float time);
void setTrack(const std::string& track); void setTrack(const std::string& track);
void setNumPlayers(int num);
void setNumLocalPlayers(int num) {m_local_player_karts.resize(num); }
void setGrandPrix(const GrandPrixData &gp){ m_grand_prix = gp; } void setGrandPrix(const GrandPrixData &gp){ m_grand_prix = gp; }
void setDifficulty(Difficulty diff); void setDifficulty(Difficulty diff);
void setNumLaps(int num) { m_num_laps.clear(); void setNumLaps(int num) { m_num_laps.clear();
@ -127,8 +128,7 @@ public:
RaceModeType getMajorMode() const { return m_major_mode; } RaceModeType getMajorMode() const { return m_major_mode; }
RaceModeType getMinorMode() const { return m_minor_mode; } RaceModeType getMinorMode() const { return m_minor_mode; }
unsigned int getNumKarts() const { return m_num_karts; } unsigned int getNumKarts() const { return m_num_karts; }
unsigned int getNumPlayers() const { return (int)m_player_karts.size();} unsigned int getNumPlayers() const { return m_player_karts.size(); }
unsigned int getNumLocalPlayers() const { return (int)m_local_player_karts.size();}
int getNumLaps() const { return m_num_laps[m_track_number];} int getNumLaps() const { return m_num_laps[m_track_number];}
Difficulty getDifficulty() const { return m_difficulty; } Difficulty getDifficulty() const { return m_difficulty; }
const std::string& const std::string&
@ -138,20 +138,21 @@ public:
unsigned int getFinishedKarts() const { return m_num_finished_karts; } unsigned int getFinishedKarts() const { return m_num_finished_karts; }
unsigned int getFinishedPlayers() const { return m_num_finished_players; } unsigned int getFinishedPlayers() const { return m_num_finished_players; }
const std::string& const std::string&
getKartName(int kart) const { return m_kart_status[kart].m_ident;} getHerringStyle() const { return m_grand_prix.getHerringStyle(); }
const std::string& const std::string&
getHerringStyle() const { return m_grand_prix.getHerringStyle();} getKartName(int kart) const { return m_kart_status[kart].m_ident;}
int getKartScore(int krt) const { return m_kart_status[krt].m_score;} int getKartScore(int krt) const { return m_kart_status[krt].m_score; }
int getKartPrevScore(int krt)const { return m_kart_status[krt].m_last_score;} int getKartPrevScore(int krt)const { return m_kart_status[krt].m_last_score;}
int getKartPlayerId(int krt) const { return m_kart_status[krt].m_player_id;} int getKartLocalPlayerId(int k) const { return m_kart_status[k].m_local_player_id; }
int getPositionScore(int p) const { return m_score_for_position[p-1]; } int getKartGlobalPlayerId(int k) const { return m_kart_status[k].m_global_player_id; }
double getOverallTime(int kart) const { return m_kart_status[kart].m_overall_time;} double getOverallTime(int kart) const { return m_kart_status[kart].m_overall_time;}
KartType getKartType(int kart) const { return m_kart_status[kart].m_kart_type;}
int getCoinTarget() const { return m_coin_target; } int getCoinTarget() const { return m_coin_target; }
bool raceHasLaps() const { return m_minor_mode!=RM_FOLLOW_LEADER;} bool raceHasLaps() const { return m_minor_mode!=RM_FOLLOW_LEADER; }
int getPositionScore(int p) const { return m_score_for_position[p-1]; }
int allPlayerFinished() const {return int allPlayerFinished() const {return
m_num_finished_players==m_player_karts.size(); } m_num_finished_players==m_player_karts.size();}
int raceIsActive() const { return m_active_race; } int raceIsActive() const { return m_active_race; }
KartType getKartType(int kart) const {return m_kart_status[kart].m_kart_type; }
void setMirror() {/*FIXME*/} void setMirror() {/*FIXME*/}
void setReverse(){/*FIXME*/} void setReverse(){/*FIXME*/}

26
src/world.cpp
View File

@ -45,6 +45,8 @@
#include "camera.hpp" #include "camera.hpp"
#include "robots/default_robot.hpp" #include "robots/default_robot.hpp"
#include "unlock_manager.hpp" #include "unlock_manager.hpp"
#include "network/network_kart.hpp"
#include "network/network_manager.hpp"
#ifdef HAVE_GHOST_REPLAY #ifdef HAVE_GHOST_REPLAY
# include "replay_player.hpp" # include "replay_player.hpp"
#endif #endif
@ -103,8 +105,9 @@ World::World()
int position = i+1; // position start with 1 int position = i+1; // position start with 1
btTransform init_pos=m_track->getStartTransform(position); btTransform init_pos=m_track->getStartTransform(position);
Kart* newkart; Kart* newkart;
const std::string& kart_name=race_manager->getKartName(i); const std::string& kart_name = race_manager->getKartName(i);
int player_id = race_manager->getKartPlayerId(i); int local_player_id = race_manager->getKartLocalPlayerId(i);
int global_player_id = race_manager->getKartGlobalPlayerId(i);
if(user_config->m_profile) if(user_config->m_profile)
{ {
// In profile mode, load only the old kart // In profile mode, load only the old kart
@ -113,7 +116,7 @@ World::World()
// karts can be seen. // karts can be seen.
if(i==race_manager->getNumKarts()-1) if(i==race_manager->getNumKarts()-1)
{ {
scene->createCamera(player_id, newkart); scene->createCamera(local_player_id, newkart);
} }
} }
else else
@ -122,11 +125,22 @@ World::World()
{ {
case RaceManager::KT_PLAYER: case RaceManager::KT_PLAYER:
newkart = new PlayerKart(kart_name, position, newkart = new PlayerKart(kart_name, position,
&(user_config->m_player[player_id]), &(user_config->m_player[local_player_id]),
init_pos, player_id); init_pos, local_player_id);
m_player_karts[player_id] = (PlayerKart*)newkart; m_player_karts[global_player_id] = (PlayerKart*)newkart;
m_local_player_karts[local_player_id] = static_cast<PlayerKart*>(newkart);
break; break;
case RaceManager::KT_NETWORK_PLAYER: case RaceManager::KT_NETWORK_PLAYER:
if(network_manager->getMode()==NetworkManager::NW_SERVER)
{
newkart = new NetworkKart(kart_name, position, init_pos,
global_player_id);
}
else
{
newkart = new NetworkKart(kart_name, position, init_pos,
global_player_id);
}
break; break;
case RaceManager::KT_AI: case RaceManager::KT_AI:
newkart = loadRobot(kart_name, position, init_pos); newkart = loadRobot(kart_name, position, init_pos);

1
src/world.hpp
View File

@ -21,6 +21,7 @@
#define HEADER_WORLD_H #define HEADER_WORLD_H
#include <vector> #include <vector>
#define _WINSOCKAPI_
#include <plib/ssg.h> #include <plib/ssg.h>
#include "track.hpp" #include "track.hpp"
#include "player_kart.hpp" #include "player_kart.hpp"