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

Implement capture and return of flags

Browse Source
This commit is contained in:
Benau 2018-08-18 01:05:00 +08:00
parent f54c1eb2b6
commit df69e7f6b6
9 changed files with 427 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

382
src/modes/capture_the_flag.cpp
View File

@ -16,20 +16,35 @@
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "modes/capture_the_flag.hpp"
#include "audio/sfx_base.hpp"
#include "io/file_manager.hpp"
#include "graphics/irr_driver.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/controller/controller.hpp"
#include "karts/kart_model.hpp"
#include "network/network_config.hpp"
#include "network/network_string.hpp"
#include "network/protocols/game_events_protocol.hpp"
#include "network/stk_host.hpp"
#include "physics/triangle_mesh.hpp"
#include "states_screens/race_gui.hpp"
#include "tracks/track.hpp"
#include "tracks/track_object_manager.hpp"
#include <algorithm>
//-----------------------------------------------------------------------------
const Vec3 g_kart_flag_offset(0.0, 0.2f, -0.5f);
const float g_capture_length = 2.0f;
const int g_captured_score = 10;
// ----------------------------------------------------------------------------
/** Constructor. Sets up the clock mode etc.
*/
CaptureTheFlag::CaptureTheFlag() : FreeForAll()
{
m_red_flag_node = m_blue_flag_node = NULL;
m_red_flag_mesh = m_blue_flag_mesh = NULL;
m_scored_sound = NULL;
#ifndef SERVER_ONLY
file_manager->pushTextureSearchPath(
file_manager->getAsset(FileManager::MODEL,""), "models");
@ -42,10 +57,11 @@ CaptureTheFlag::CaptureTheFlag() : FreeForAll()
irr_driver->grabAllTextures(m_red_flag_mesh);
irr_driver->grabAllTextures(m_blue_flag_mesh);
file_manager->popTextureSearchPath();
m_scored_sound = SFXManager::get()->createSoundSource("goal_scored");
#endif
} // CaptureTheFlag
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
CaptureTheFlag::~CaptureTheFlag()
{
#ifndef SERVER_ONLY
@ -53,13 +69,16 @@ CaptureTheFlag::~CaptureTheFlag()
irr_driver->dropAllTextures(m_blue_flag_mesh);
irr_driver->removeMeshFromCache(m_red_flag_mesh);
irr_driver->removeMeshFromCache(m_blue_flag_mesh);
m_scored_sound->deleteSFX();
#endif
} // ~CaptureTheFlag
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void CaptureTheFlag::init()
{
FreeForAll::init();
m_orig_red_trans = Track::getCurrentTrack()->getRedFlag();
m_orig_blue_trans = Track::getCurrentTrack()->getBlueFlag();
#ifndef SERVER_ONLY
m_red_flag_node = irr_driver->addAnimatedMesh(m_red_flag_mesh, "red_flag");
@ -70,35 +89,326 @@ void CaptureTheFlag::init()
#endif
} // init
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void CaptureTheFlag::reset()
{
FreeForAll::reset();
m_red_trans = Track::getCurrentTrack()->getRedFlag();
m_blue_trans = Track::getCurrentTrack()->getBlueFlag();
m_red_trans = m_orig_red_trans;
m_blue_trans = m_orig_blue_trans;
m_red_scores = m_blue_scores = 0;
m_red_holder = m_blue_holder = -1;
#ifndef SERVER_ONLY
m_red_flag_node->setPosition(
Vec3(m_red_trans.getOrigin()).toIrrVector());
Vec3 hpr;
hpr.setHPR(m_red_trans.getRotation());
m_red_flag_node->setRotation(hpr.toIrrHPR());
m_blue_flag_node->setPosition(
Vec3(m_blue_trans.getOrigin()).toIrrVector());
hpr.setHPR(m_blue_trans.getRotation());
m_blue_flag_node->setRotation(hpr.toIrrHPR());
#endif
updateFlagNodes();
} // reset
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void CaptureTheFlag::updateGraphics(float dt)
{
FreeForAll::updateGraphics(dt);
if (!NetworkConfig::get()->isNetworking() ||
NetworkConfig::get()->isClient())
{
if (m_red_holder != -1)
{
m_red_trans = getKart(m_red_holder)->getSmoothedTrans();
m_red_trans.setOrigin(m_red_trans(g_kart_flag_offset));
m_red_flag_node->setAnimationSpeed(fabsf(getKart(m_red_holder)
->getSpeed()) * 3.0f + 25.0f);
}
else
m_red_flag_node->setAnimationSpeed(25.0f);
if (m_blue_holder != -1)
{
m_blue_trans = getKart(m_blue_holder)->getSmoothedTrans();
m_blue_trans.setOrigin(m_blue_trans(g_kart_flag_offset));
m_blue_flag_node->setAnimationSpeed(fabsf(getKart(m_blue_holder)
->getSpeed()) * 3.0f + 25.0f);
}
else
m_blue_flag_node->setAnimationSpeed(25.0f);
}
} // updateGraphics
// ----------------------------------------------------------------------------
void CaptureTheFlag::update(int ticks)
{
if (m_red_holder != -1 && m_blue_holder != -1 &&
m_red_holder == m_blue_holder)
Log::fatal("CaptureTheFlag", "Flag management messed up, abort.");
FreeForAll::update(ticks);
if (!NetworkConfig::get()->isNetworking() ||
NetworkConfig::get()->isClient())
return;
if (m_red_holder != -1)
{
m_red_trans = getKart(m_red_holder)->getTrans();
m_red_trans.setOrigin(m_red_trans(g_kart_flag_offset));
}
if (m_blue_holder != -1)
{
m_blue_trans = getKart(m_blue_holder)->getTrans();
m_blue_trans.setOrigin(m_blue_trans(g_kart_flag_offset));
}
if (m_red_holder != -1 &&
m_blue_trans.getOrigin() == m_orig_blue_trans.getOrigin() &&
(m_orig_blue_trans.getOrigin() - m_red_trans.getOrigin()).length() <
g_capture_length)
{
// Blue team scored
NetworkString p(PROTOCOL_GAME_EVENTS);
p.setSynchronous(true);
p.addUInt8(GameEventsProtocol::GE_CTF_RESET)
.addUInt8(1) // Reset red flag
.addUInt8((int8_t)m_red_holder);
STKHost::get()->sendPacketToAllPeers(&p, true);
m_scores.at(m_red_holder) += g_captured_score;
m_red_holder = -1;
m_red_trans = m_orig_red_trans;
m_blue_scores++;
return;
}
else if (m_blue_holder != -1 &&
m_red_trans.getOrigin() == m_orig_red_trans.getOrigin() &&
(m_orig_red_trans.getOrigin() - m_blue_trans.getOrigin()).length() <
g_capture_length)
{
// Red team scored
NetworkString p(PROTOCOL_GAME_EVENTS);
p.setSynchronous(true);
p.addUInt8(GameEventsProtocol::GE_CTF_RESET)
.addUInt8(0) // Reset blue flag
.addUInt8((int8_t)m_blue_holder);
STKHost::get()->sendPacketToAllPeers(&p, true);
m_scores.at(m_blue_holder) += g_captured_score;
m_blue_holder = -1;
m_blue_trans = m_orig_blue_trans;
m_red_scores++;
return;
}
// Test if red or blue flag is touched
for (auto& k : m_karts)
{
if (k->isEliminated() || k->getKartAnimation() || k->isSquashed() ||
(int)k->getWorldKartId() == m_blue_holder ||
(int)k->getWorldKartId() == m_red_holder)
continue;
if (m_red_holder == -1 &&
(k->getXYZ() - m_red_trans.getOrigin()).length() <
g_capture_length)
{
uint8_t kart_id = (uint8_t)k->getWorldKartId();
if (getKartTeam(kart_id) == KART_TEAM_RED)
{
if (m_red_trans.getOrigin() != m_orig_red_trans.getOrigin())
{
// Return the flag
NetworkString p(PROTOCOL_GAME_EVENTS);
p.setSynchronous(true);
p.addUInt8(GameEventsProtocol::GE_CTF_RESET)
.addUInt8(1) // Reset red flag
.addUInt8(((int8_t)-1))
.add(Vec3(m_orig_red_trans.getOrigin()))
.add(m_orig_red_trans.getRotation());
STKHost::get()->sendPacketToAllPeers(&p, true);
m_red_trans = m_orig_red_trans;
}
}
else
{
// Get the flag
NetworkString p(PROTOCOL_GAME_EVENTS);
p.setSynchronous(true);
p.addUInt8(GameEventsProtocol::GE_CTF_ATTACH)
.addUInt8(1) // Attach red flag
.addUInt8(kart_id);
STKHost::get()->sendPacketToAllPeers(&p, true);
m_red_holder = kart_id;
}
}
if (m_blue_holder == -1 &&
(k->getXYZ() - m_blue_trans.getOrigin()).length() <
g_capture_length)
{
uint8_t kart_id = (uint8_t)k->getWorldKartId();
if (getKartTeam(kart_id) == KART_TEAM_BLUE)
{
if (m_blue_trans.getOrigin() != m_orig_blue_trans.getOrigin())
{
// Return the flag
NetworkString p(PROTOCOL_GAME_EVENTS);
p.setSynchronous(true);
p.addUInt8(GameEventsProtocol::GE_CTF_RESET)
.addUInt8(0) // Reset blue flag
.addUInt8(((int8_t)-1))
.add(Vec3(m_orig_blue_trans.getOrigin()))
.add(m_orig_blue_trans.getRotation());
STKHost::get()->sendPacketToAllPeers(&p, true);
m_blue_trans = m_orig_blue_trans;
}
}
else
{
// Get the flag
NetworkString p(PROTOCOL_GAME_EVENTS);
p.setSynchronous(true);
p.addUInt8(GameEventsProtocol::GE_CTF_ATTACH)
.addUInt8(0) // Attach blue flag
.addUInt8(kart_id);
STKHost::get()->sendPacketToAllPeers(&p, true);
m_blue_holder = kart_id;
}
}
}
} // update
// ----------------------------------------------------------------------------
void CaptureTheFlag::updateFlagNodes()
{
#ifndef SERVER_ONLY
Vec3 hpr;
if (m_red_holder == -1)
{
m_red_flag_node->setPosition(
Vec3(m_red_trans.getOrigin()).toIrrVector());
hpr.setHPR(m_red_trans.getRotation());
m_red_flag_node->setRotation(hpr.toIrrHPR());
}
if (m_blue_holder == -1)
{
m_blue_flag_node->setPosition(
Vec3(m_blue_trans.getOrigin()).toIrrVector());
hpr.setHPR(m_blue_trans.getRotation());
m_blue_flag_node->setRotation(hpr.toIrrHPR());
}
#endif
} // updateFlagNodes
// ----------------------------------------------------------------------------
void CaptureTheFlag::attachFlag(NetworkString& ns)
{
#ifndef SERVER_ONLY
bool attach_red_flag = ns.getUInt8() == 1;
unsigned kart_id = ns.getUInt8();
core::stringw get_msg;
const core::stringw& name = getKart(kart_id)->getController()
->getName();
if (attach_red_flag)
{
m_red_holder = kart_id;
m_red_flag_node->setParent(getKart(kart_id)->getNode());
m_red_flag_node->setPosition(g_kart_flag_offset.toIrrVector());
m_red_flag_node->setRotation(core::vector3df(0.0f, 180.0f, 0.0f));
// I18N: Show when a player gets the flag in CTF
get_msg = _("%s has the red flag!", name);
}
else
{
m_blue_holder = kart_id;
m_blue_flag_node->setParent(getKart(kart_id)->getNode());
m_blue_flag_node->setPosition(g_kart_flag_offset.toIrrVector());
m_blue_flag_node->setRotation(core::vector3df(0.0f, 180.0f, 0.0f));
// I18N: Show when a player gets the flag in CTF
get_msg = _("%s has the blue flag!", name);
}
m_race_gui->addMessage(get_msg, NULL, 1.5f);
#endif
} // attachFlag
// ----------------------------------------------------------------------------
void CaptureTheFlag::resetFlag(NetworkString& ns)
{
#ifndef SERVER_ONLY
bool reset_red_flag = ns.getUInt8() == 1;
int8_t kart_id = ns.getUInt8();
if (kart_id != -1)
{
core::stringw scored_msg;
AbstractKart* kart = getKart(kart_id);
const core::stringw& name = kart->getController()->getName();
if (reset_red_flag)
{
m_scores.at(kart_id) += g_captured_score;
m_red_holder = -1;
m_red_trans = m_orig_red_trans;
// I18N: Show when a player captured the flag in CTF
scored_msg = _("%s captured the red flag!", name);
m_red_flag_node->setParent(
irr_driver->getSceneManager()->getRootSceneNode());
m_blue_scores++;
}
else
{
m_scores.at(kart_id) += g_captured_score;
m_blue_holder = -1;
m_blue_trans = m_orig_blue_trans;
// I18N: Show when a player captured the flag in CTF
scored_msg = _("%s captured the blue flag!", name);
m_blue_flag_node->setParent(
irr_driver->getSceneManager()->getRootSceneNode());
m_red_scores++;
}
m_race_gui->addMessage(scored_msg, NULL, 3.0f);
kart->getKartModel()
->setAnimation(KartModel::AF_WIN_START, true/* play_non_loop*/);
m_scored_sound->play();
}
else
{
btTransform t;
t.setOrigin(ns.getVec3());
t.setRotation(ns.getQuat());
if (reset_red_flag)
{
m_red_holder = -1;
m_red_trans = t;
m_red_flag_node->setParent(
irr_driver->getSceneManager()->getRootSceneNode());
}
else
{
m_blue_holder = -1;
m_blue_trans = t;
m_blue_flag_node->setParent(
irr_driver->getSceneManager()->getRootSceneNode());
}
}
updateFlagNodes();
#endif
} // resetFlag
// ----------------------------------------------------------------------------
btTransform CaptureTheFlag::getDroppedFlagTrans(const btTransform& kt,
bool red_flag) const
{
Vec3 from = kt.getOrigin() + kt.getBasis().getColumn(1);
Vec3 to = kt.getOrigin() + kt.getBasis().getColumn(1) * -10000.0f;
Vec3 hit_point, normal;
const Material* material = NULL;
// From TerrainInfo::update
const TriangleMesh &tm = Track::getCurrentTrack()->getTriangleMesh();
bool ret = tm.castRay(from, to, &hit_point, &material, &normal,
/*interpolate*/false);
if (!ret || material == NULL)
{
if (red_flag)
return m_orig_red_trans;
else
return m_orig_blue_trans;
}
Track::getCurrentTrack()->getTrackObjectManager()->castRay
(from, to, &hit_point, &material, &normal, /*interpolate*/false);
return btTransform(shortestArcQuat(Vec3(0, 1, 0), normal),
hit_point);
} // getDroppedFlagTrans
// ----------------------------------------------------------------------------
video::SColor CaptureTheFlag::getColor(unsigned int kart_id) const
{
@ -120,3 +430,35 @@ bool CaptureTheFlag::isRaceOver()
return false;
} // isRaceOver
// ----------------------------------------------------------------------------
bool CaptureTheFlag::kartHit(int kart_id, int hitter)
{
if (!FreeForAll::kartHit(kart_id, hitter))
return false;
if (m_red_holder == kart_id || m_blue_holder == kart_id)
{
bool reset_red_flag = m_red_holder == kart_id;
btTransform dropped_trans = getDroppedFlagTrans(
getKart(kart_id)->getTrans(), reset_red_flag);
NetworkString p(PROTOCOL_GAME_EVENTS);
p.setSynchronous(true);
p.addUInt8(GameEventsProtocol::GE_CTF_RESET)
.addUInt8(reset_red_flag ? 1 : 0) // Reset red flag
.addUInt8(((int8_t)-1))
.add(Vec3(dropped_trans.getOrigin()))
.add(dropped_trans.getRotation());
STKHost::get()->sendPacketToAllPeers(&p, true);
if (reset_red_flag)
{
m_red_holder = -1;
m_red_trans = dropped_trans;
}
else
{
m_blue_holder = -1;
m_blue_trans = dropped_trans;
}
}
return true;
} // kartHit

21
src/modes/capture_the_flag.hpp
View File

@ -42,10 +42,17 @@ private:
irr::scene::IAnimatedMesh* m_blue_flag_mesh;
SFXBase* m_scored_sound;
int m_red_scores, m_blue_scores, m_red_holder, m_blue_holder;
btTransform m_red_trans, m_blue_trans;
btTransform m_red_trans, m_blue_trans, m_orig_red_trans, m_orig_blue_trans;
// ------------------------------------------------------------------------
void updateFlagNodes();
// ------------------------------------------------------------------------
btTransform getDroppedFlagTrans(const btTransform& kt,
bool red_flag) const;
// ------------------------------------------------------------------------
virtual video::SColor getColor(unsigned int kart_id) const OVERRIDE;
@ -61,8 +68,18 @@ public:
// ------------------------------------------------------------------------
virtual void update(int ticks) OVERRIDE;
// ------------------------------------------------------------------------
virtual void updateGraphics(float dt) OVERRIDE;
// ------------------------------------------------------------------------
virtual bool hasTeam() const OVERRIDE { return true; }
// ------------------------------------------------------------------------
virtual bool isRaceOver() OVERRIDE;
// ------------------------------------------------------------------------
virtual bool kartHit(int kart_id, int hitter = -1) OVERRIDE;
// ------------------------------------------------------------------------
void attachFlag(NetworkString& ns);
// ------------------------------------------------------------------------
void resetFlag(NetworkString& ns);
// ------------------------------------------------------------------------
bool getKartCTFResult(unsigned int kart_id) const
{
if (m_red_scores == m_blue_scores)
@ -89,8 +106,6 @@ public:
const Vec3& getRedFlag() const { return (Vec3&)m_red_trans.getOrigin(); }
// ------------------------------------------------------------------------
const Vec3& getBlueFlag() const { return (Vec3&)m_blue_trans.getOrigin(); }
// ------------------------------------------------------------------------
virtual bool isRaceOver() OVERRIDE;
}; // CaptureTheFlag

36
src/modes/free_for_all.cpp
View File

@ -16,7 +16,7 @@
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "modes/free_for_all.hpp"
#include "karts/kart.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/controller/controller.hpp"
#include "network/network_config.hpp"
#include "network/network_string.hpp"
@ -26,7 +26,7 @@
#include <algorithm>
#include <utility>
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/** Constructor. Sets up the clock mode etc.
*/
FreeForAll::FreeForAll() : WorldWithRank()
@ -42,12 +42,12 @@ FreeForAll::FreeForAll() : WorldWithRank()
}
} // FreeForAll
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
FreeForAll::~FreeForAll()
{
} // ~FreeForAll
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void FreeForAll::init()
{
WorldWithRank::init();
@ -55,7 +55,7 @@ void FreeForAll::init()
m_count_down_reached_zero = false;
} // init
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/** Called when a battle is restarted.
*/
void FreeForAll::reset()
@ -74,7 +74,7 @@ void FreeForAll::reset()
m_scores.resize(m_karts.size(), 0);
} // reset
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/** Called when the match time ends.
*/
void FreeForAll::countdownReachedZero()
@ -85,18 +85,19 @@ void FreeForAll::countdownReachedZero()
m_count_down_reached_zero = true;
} // countdownReachedZero
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/** Called when a kart is hit.
* \param kart_id The world kart id of the kart that was hit.
* \param hitter The world kart id of the kart who hit(-1 if none).
*/
void FreeForAll::kartHit(int kart_id, int hitter)
bool FreeForAll::kartHit(int kart_id, int hitter)
{
if (NetworkConfig::get()->isNetworking() &&
NetworkConfig::get()->isClient())
return;
return false;
if (isRaceOver()) return;
if (isRaceOver())
return false;
NetworkString p(PROTOCOL_GAME_EVENTS);
p.setSynchronous(true);
@ -106,9 +107,10 @@ void FreeForAll::kartHit(int kart_id, int hitter)
else
p.addUInt8((uint8_t)hitter).addUInt32(++m_scores[hitter]);
STKHost::get()->sendPacketToAllPeers(&p, true);
return true;
} // kartHit
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void FreeForAll::setKartScoreFromServer(NetworkString& ns)
{
int kart_id = ns.getUInt8();
@ -116,7 +118,7 @@ void FreeForAll::setKartScoreFromServer(NetworkString& ns)
m_scores.at(kart_id) = score;
} // setKartScoreFromServer
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/** Returns the internal identifier for this race.
*/
const std::string& FreeForAll::getIdent() const
@ -144,7 +146,7 @@ void FreeForAll::update(int ticks)
endSetKartPositions();
} // update
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/** The battle is over if only one kart is left, or no player kart.
*/
bool FreeForAll::isRaceOver()
@ -160,7 +162,7 @@ bool FreeForAll::isRaceOver()
m_scores[top_id] >= race_manager->getHitCaptureLimit();
} // isRaceOver
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
/** Returns the data to display in the race gui.
*/
void FreeForAll::getKartsDisplayInfo(
@ -173,18 +175,18 @@ void FreeForAll::getKartsDisplayInfo(
rank_info.lap = -1;
rank_info.m_outlined_font = true;
rank_info.m_color = getColor(i);
rank_info.m_text = m_karts[i]->getController()->getName() + L" (" +
rank_info.m_text = getKart(i)->getController()->getName() + L" (" +
StringUtils::toWString(m_scores[i]) + L")";
}
} // getKartsDisplayInfo
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
void FreeForAll::terminateRace()
{
const unsigned int kart_amount = getNumKarts();
for (unsigned int i = 0; i < kart_amount ; i++)
{
m_karts[i]->finishedRace(0.0f, true/*from_server*/);
getKart(i)->finishedRace(0.0f, true/*from_server*/);
} // i<kart_amount
WorldWithRank::terminateRace();
} // terminateRace

4
src/modes/free_for_all.hpp
View File

@ -30,9 +30,9 @@ class FreeForAll : public WorldWithRank
protected:
bool m_count_down_reached_zero;
private:
std::vector<int> m_scores;
private:
// ------------------------------------------------------------------------
virtual video::SColor getColor(unsigned int kart_id) const;
@ -55,7 +55,7 @@ public:
// ------------------------------------------------------------------------
virtual const std::string& getIdent() const OVERRIDE;
// ------------------------------------------------------------------------
virtual void kartHit(int kart_id, int hitter = -1) OVERRIDE;
virtual bool kartHit(int kart_id, int hitter = -1) OVERRIDE;
// ------------------------------------------------------------------------
virtual void update(int ticks) OVERRIDE;
// ------------------------------------------------------------------------

8
src/modes/three_strikes_battle.cpp
View File

@ -209,9 +209,9 @@ void ThreeStrikesBattle::kartAdded(AbstractKart* kart, scene::ISceneNode* node)
* \param kart_id The world kart id of the kart that was hit.
* \param hitter The world kart id of the kart who hit(-1 if none).
*/
void ThreeStrikesBattle::kartHit(int kart_id, int hitter)
bool ThreeStrikesBattle::kartHit(int kart_id, int hitter)
{
if (isRaceOver()) return;
if (isRaceOver()) return false;
SpareTireAI* sta =
dynamic_cast<SpareTireAI*>(m_karts[kart_id]->getController());
@ -219,7 +219,7 @@ void ThreeStrikesBattle::kartHit(int kart_id, int hitter)
{
// Unspawn the spare tire kart if it get hit
sta->unspawn();
return;
return false;
}
assert(kart_id < (int)m_karts.size());
@ -338,7 +338,7 @@ void ThreeStrikesBattle::kartHit(int kart_id, int hitter)
m_tire_dir = m_karts[kart_id]->getKartProperties()->getKartDir();
if(m_insert_tire == 5 && m_karts[kart_id]->isWheeless())
m_insert_tire = 0;
return true;
} // kartHit
//-----------------------------------------------------------------------------

2
src/modes/three_strikes_battle.hpp
View File

@ -111,7 +111,7 @@ public:
// ------------------------------------------------------------------------
virtual const std::string& getIdent() const OVERRIDE;
// ------------------------------------------------------------------------
virtual void kartHit(int kart_id, int hitter = -1) OVERRIDE;
virtual bool kartHit(int kart_id, int hitter = -1) OVERRIDE;
// ------------------------------------------------------------------------
virtual void update(int ticks) OVERRIDE;
// ------------------------------------------------------------------------

2
src/modes/world.hpp
View File

@ -283,7 +283,7 @@ public:
virtual void newLap(unsigned int kart_index) {}
// ------------------------------------------------------------------------
/** Called when a kart was hit by a projectile. */
virtual void kartHit(int kart_id, int hitter = -1) {};
virtual bool kartHit(int kart_id, int hitter = -1) { return false; }
// ------------------------------------------------------------------------
virtual void onMouseClick(int x, int y) {};

19
src/network/protocols/game_events_protocol.cpp
View File

@ -1,7 +1,7 @@
#include "network/protocols/game_events_protocol.hpp"
#include "karts/abstract_kart.hpp"
#include "modes/free_for_all.hpp"
#include "modes/capture_the_flag.hpp"
#include "modes/soccer_world.hpp"
#include "network/event.hpp"
#include "network/game_setup.hpp"
@ -45,6 +45,7 @@ bool GameEventsProtocol::notifyEvent(Event* event)
return true;
}
uint8_t type = data.getUInt8();
CaptureTheFlag* ctf = dynamic_cast<CaptureTheFlag*>(World::getWorld());
FreeForAll* ffa = dynamic_cast<FreeForAll*>(World::getWorld());
SoccerWorld* sw = dynamic_cast<SoccerWorld*>(World::getWorld());
switch (type)
@ -70,10 +71,24 @@ bool GameEventsProtocol::notifyEvent(Event* event)
case GE_BATTLE_KART_SCORE:
{
if (!ffa)
throw std::invalid_argument("No free for all world");
throw std::invalid_argument("No free-for-all world");
ffa->setKartScoreFromServer(data);
break;
}
case GE_CTF_ATTACH:
{
if (!ctf)
throw std::invalid_argument("No CTF world");
ctf->attachFlag(data);
break;
}
case GE_CTF_RESET:
{
if (!ctf)
throw std::invalid_argument("No CTF world");
ctf->resetFlag(data);
break;
}
default:
Log::warn("GameEventsProtocol", "Unkown message type.");
break;

4
src/network/protocols/game_events_protocol.hpp
View File

@ -15,7 +15,9 @@ public:
GE_PLAYER_DISCONNECT = 2,
GE_RESET_BALL = 3,
GE_PLAYER_GOAL = 4,
GE_BATTLE_KART_SCORE = 5
GE_BATTLE_KART_SCORE = 5,
GE_CTF_ATTACH = 6,
GE_CTF_RESET = 7
}; // GameEventType
private:
void eliminatePlayer(const NetworkString &ns);