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

Added files forgotten in previous commit

Browse Source 
git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/main/trunk@5455 178a84e3-b1eb-0310-8ba1-8eac791a3b58
This commit is contained in:
auria
2010-05-30 15:48:24 +00:00
parent 1bdca718cb
commit 759cbff2b7
5 changed files with 357 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

250
src/states_screens/grand_prix_lose.cpp Normal file
View File

@@ -0,0 +1,250 @@
#include "states_screens/grand_prix_lose.hpp"
#include "audio/music_manager.hpp"
#include "audio/sfx_manager.hpp"
#include "challenges/unlock_manager.hpp"
#include "graphics/irr_driver.hpp"
#include "guiengine/engine.hpp"
#include "guiengine/widgets/label_widget.hpp"
#include "io/file_manager.hpp"
#include "items/item_manager.hpp"
#include "karts/kart_properties_manager.hpp"
#include "states_screens/feature_unlocked.hpp"
#include "states_screens/state_manager.hpp"
#include "utils/translation.hpp"
#include <SColor.h>
#include <iostream>
using namespace irr::core;
using namespace irr::gui;
using namespace irr::video;
const float INITIAL_Y = -3.0f;
const float DURATION = 20.0f;
const float CAMERA_END_X = -15.0f;
const float CAMERA_END_Y = 1.5f;
const float CAMERA_END_Z = 5.0f;
const float CAMERA_START_X = -17.0f;
const float CAMERA_START_Y = 2.0f;
const float CAMERA_START_Z = 5.5f;
const float KART_START_X = -17.0f;
const float KART_END_X = -5.0f;
const float KART_Y = -3.0f;
const float KART_Z = 0.0f;
DEFINE_SCREEN_SINGLETON( GrandPrixLose );
// -------------------------------------------------------------------------------------
GrandPrixLose::GrandPrixLose() : Screen("grand_prix_lose.stkgui")
{
setNeeds3D(true);
m_throttle_FPS = false;
}
// -------------------------------------------------------------------------------------
void GrandPrixLose::loadedFromFile()
{
m_kart_node = NULL;
}
// -------------------------------------------------------------------------------------
void GrandPrixLose::init()
{
// TODO: change music
music_manager->startMusic(music_manager->getMusicInformation(file_manager->getMusicFile("win_theme.music")));
m_phase = 1;
m_sky_angle = 0.0f;
m_global_time = 0.0f;
m_sky = irr_driver->addSkyDome(file_manager->getTextureFile("clouds.png"),
16 /* hori_res */, 16 /* vert_res */,
1.0f /* texture_percent */, 2.0f /* sphere_percent */);
m_camera = irr_driver->addCameraSceneNode();
m_camera_x = CAMERA_START_X;
m_camera_y = CAMERA_START_Y;
m_camera_z = CAMERA_START_Z;
m_camera->setPosition( core::vector3df(m_camera_x, m_camera_y, m_camera_z) );
m_camera->setUpVector( core::vector3df(0.0, 1.0, 0.0) );
m_camera_target_x = 0.0f;
m_camera_target_z = -2.0f;
m_camera->setTarget( core::vector3df(m_camera_target_x, -2.0f, m_camera_target_z) );
m_camera->setFOV( DEGREE_TO_RAD*50.0f );
m_camera->updateAbsolutePosition();
scene::IAnimatedMesh* model_garage_door = irr_driver->getAnimatedMesh( file_manager->getModelFile("gplose_door.b3d") );
assert(model_garage_door!= NULL);
m_garage_door = irr_driver->addAnimatedMesh(model_garage_door);
m_garage_door->setPosition( core::vector3df(2, INITIAL_Y, 0) );
m_garage_door->setAnimationSpeed(0);
scene::IMesh* model_garage = irr_driver->getMesh( file_manager->getModelFile("gplose.b3d") );
assert(model_garage!= NULL);
m_garage = irr_driver->addMesh(model_garage);
m_garage->setPosition( core::vector3df(2, INITIAL_Y, 0) );
scene::ISceneManager* sceneManager = irr_driver->getSceneManager();
sceneManager->setAmbientLight(video::SColor(255, 120, 120, 120));
const core::vector3df &sun_pos = core::vector3df( 0, 200, 100.0f );
m_light = irr_driver->getSceneManager()->addLightSceneNode(NULL, sun_pos,
video::SColorf(1.0f,1.0f,1.0f),
300.0f /* radius */);
m_light->getLightData().DiffuseColor = irr::video::SColorf(1.0f, 1.0f, 1.0f, 1.0f);
m_light->getLightData().SpecularColor = irr::video::SColorf(1.0f, 0.0f, 0.0f, 0.0f);
}
// -------------------------------------------------------------------------------------
void GrandPrixLose::tearDown()
{
irr_driver->removeNode(m_sky);
m_sky = NULL;
irr_driver->removeCameraSceneNode(m_camera);
m_camera = NULL;
irr_driver->removeNode(m_light);
m_light = NULL;
irr_driver->removeNode(m_garage);
m_garage = NULL;
irr_driver->removeNode(m_kart_node);
irr_driver->removeNode(m_garage_door);
}
// -------------------------------------------------------------------------------------
void GrandPrixLose::onUpdate(float dt, irr::video::IVideoDriver* driver)
{
m_global_time += dt;
m_sky_angle += dt*2;
if (m_sky_angle > 360) m_sky_angle -= 360;
m_sky->setRotation( core::vector3df(0, m_sky_angle, 0) );
const int lastFrame = m_garage_door->getEndFrame();
if (m_global_time < 6.0f)
{
m_garage_door->setCurrentFrame( (m_global_time/10.0f)*lastFrame );
}
else if (m_global_time > DURATION - 6.0f )
{
m_garage_door->setCurrentFrame( (1.0f - ((m_global_time - (DURATION - 10.0f))/10.0f))*lastFrame );
}
//else if (m_global_time < DURATION)
//{
// m_garage_door->setCurrentFrame( lastFrame );
//}
const float kartProgression = m_global_time/(DURATION - 5.0f);
if (kartProgression <= 1.0f)
{
m_kart_x = KART_START_X + (KART_END_X - KART_START_X)*kartProgression;
m_kart_node->setPosition( core::vector3df(m_kart_x, m_kart_y, m_kart_z) );
}
const float progression = m_global_time / DURATION;
m_camera_x = CAMERA_START_X + (CAMERA_END_X - CAMERA_START_X)*progression;
m_camera_y = CAMERA_START_Y + (CAMERA_END_Y - CAMERA_START_Y)*progression;
m_camera_z = CAMERA_START_Z + (CAMERA_END_Z - CAMERA_START_Z)*progression;
m_camera->setPosition( core::vector3df(m_camera_x, m_camera_y, m_camera_z) );
m_camera->setUpVector( core::vector3df(0.0, 1.0, 0.0) );
m_camera->updateAbsolutePosition();
// ---- title
static const int w = irr_driver->getFrameSize().Width;
static const int h = irr_driver->getFrameSize().Height;
const irr::video::SColor color(255, 255, 255, 255);
static int test_y = 0;
//I18N: when failing a GP
GUIEngine::getTitleFont()->draw(_("Better luck next time!"),
core::rect< s32 >( 0, test_y, w, h ),
color,
true/* center h */, false /* center v */ );
}
// -------------------------------------------------------------------------------------
void GrandPrixLose::eventCallback(GUIEngine::Widget* widget,
const std::string& name,
const int playerID)
{
if (name == "continue")
{
// un-set the GP mode so that after unlocking, it doesn't try to continue the GP
race_manager->setMajorMode (RaceManager::MAJOR_MODE_SINGLE);
if (unlock_manager->getRecentlyUnlockedFeatures().size() > 0)
{
std::vector<const Challenge*> unlocked = unlock_manager->getRecentlyUnlockedFeatures();
unlock_manager->clearUnlocked();
FeatureUnlockedCutScene* scene = FeatureUnlockedCutScene::getInstance();
assert(unlocked.size() > 0);
scene->addUnlockedThings(unlocked);
StateManager::get()->replaceTopMostScreen(scene);
}
else
{
// we assume the main menu was pushed before showing this menu
StateManager::get()->popMenu();
}
}
}
// -------------------------------------------------------------------------------------
void GrandPrixLose::setKart(const std::string ident_arg)
{
scene::ISceneNode* kart_main_node = NULL;
const KartProperties* kart = kart_properties_manager->getKart(ident_arg);
if (kart != NULL)
{
KartModel* kartModel = kart->getKartModel();
m_kart_x = KART_START_X;
m_kart_y = KART_Y;
m_kart_z = KART_Z;
kart_main_node = irr_driver->addMesh(kartModel->getModel());
kart_main_node->setPosition( core::vector3df(m_kart_x, m_kart_y, m_kart_z) );
//kart_main_node->setScale( core::vector3df(0.4f, 0.4f, 0.4f) );
kart_main_node->updateAbsolutePosition();
for (int wheel=0; wheel<4; wheel++)
{
scene::ISceneNode* wheel_model = irr_driver->getSceneManager()->addMeshSceneNode(
kartModel->getWheelModel(wheel),
kart_main_node);
wheel_model->setPosition( kartModel->getWheelGraphicsPosition(wheel).toIrrVector() );
wheel_model->updateAbsolutePosition();
}
kart_main_node->setRotation(vector3df(0, 90, 0));
}
m_kart_node = kart_main_node;
}
// -------------------------------------------------------------------------------------

65
src/states_screens/grand_prix_lose.hpp Normal file
View File

@@ -0,0 +1,65 @@
#ifndef HEADER_GRAND_PRIX_LOSE_HPP
#define HEADER_GRAND_PRIX_LOSE_HPP
#include "guiengine/screen.hpp"
namespace irr { namespace scene { class ISceneNode; class ICameraSceneNode; class ILightSceneNode; } }
class KartProperties;
/**
* \brief Screen shown at the end of a Grand Prix
* \ingroup states_screens
*/
class GrandPrixLose : public GUIEngine::Screen, public GUIEngine::ScreenSingleton<GrandPrixLose>
{
friend class GUIEngine::ScreenSingleton<GrandPrixLose>;
GrandPrixLose();
/** sky angle, 0-360 */
float m_sky_angle;
/** Global evolution of time */
double m_global_time;
irr::scene::IMeshSceneNode* m_garage;
irr::scene::IAnimatedMeshSceneNode* m_garage_door;
irr::scene::ISceneNode* m_kart_node;
irr::scene::ISceneNode* m_sky;
irr::scene::ICameraSceneNode* m_camera;
irr::scene::ILightSceneNode* m_light;
int m_phase;
float m_kart_x, m_kart_y, m_kart_z;
float m_camera_x, m_camera_y, m_camera_z;
float m_camera_target_x, m_camera_target_z;
public:
/** \brief implement callback from parent class GUIEngine::Screen */
virtual void loadedFromFile();
/** \brief implement optional callback from parent class GUIEngine::Screen */
void onUpdate(float dt, irr::video::IVideoDriver*);
/** \brief implement callback from parent class GUIEngine::Screen */
void init();
/** \brief implement callback from parent class GUIEngine::Screen */
void tearDown();
/** \brief implement callback from parent class GUIEngine::Screen */
void eventCallback(GUIEngine::Widget* widget, const std::string& name, const int playerID);
void setKart(const std::string ident);
};
#endif

35
src/states_screens/grand_prix_over.cpp → src/states_screens/grand_prix_win.cpp
View File

@@ -1,5 +1,5 @@
#include "states_screens/grand_prix_over.hpp"
#include "states_screens/grand_prix_win.hpp"
#include "audio/music_manager.hpp"
#include "audio/sfx_manager.hpp"
@@ -25,11 +25,11 @@ const float INITIAL_Y = -3.0f;
const float INITIAL_PODIUM_Y = -3.6f;
const float PODIUM_HEIGHT[3] = { 0.325f, 0.5f, 0.15f };
DEFINE_SCREEN_SINGLETON( GrandPrixOver );
DEFINE_SCREEN_SINGLETON( GrandPrixWin );
// -------------------------------------------------------------------------------------
GrandPrixOver::GrandPrixOver() : Screen("grand_prix_over.stkgui")
GrandPrixWin::GrandPrixWin() : Screen("grand_prix_win.stkgui")
{
setNeeds3D(true);
@@ -38,7 +38,7 @@ GrandPrixOver::GrandPrixOver() : Screen("grand_prix_over.stkgui")
// -------------------------------------------------------------------------------------
void GrandPrixOver::loadedFromFile()
void GrandPrixWin::loadedFromFile()
{
m_kart_node[0] = NULL;
m_kart_node[1] = NULL;
@@ -77,7 +77,7 @@ void traverse(scene::ISceneNode* curr, int level=0)
// -------------------------------------------------------------------------------------
void GrandPrixOver::init()
void GrandPrixWin::init()
{
if (unlock_manager->getRecentlyUnlockedFeatures().size() > 0)
{
@@ -185,7 +185,7 @@ void GrandPrixOver::init()
// -------------------------------------------------------------------------------------
void GrandPrixOver::tearDown()
void GrandPrixWin::tearDown()
{
irr_driver->removeNode(m_sky);
m_sky = NULL;
@@ -211,10 +211,10 @@ void GrandPrixOver::tearDown()
// -------------------------------------------------------------------------------------
void GrandPrixOver::onUpdate(float dt, irr::video::IVideoDriver* driver)
void GrandPrixWin::onUpdate(float dt, irr::video::IVideoDriver* driver)
{
m_global_time += dt;
m_sky_angle += dt*2;
if (m_sky_angle > 360) m_sky_angle -= 360;
m_sky->setRotation( core::vector3df(0, m_sky_angle, 0) );
@@ -223,6 +223,8 @@ void GrandPrixOver::onUpdate(float dt, irr::video::IVideoDriver* driver)
// ---- karts move
if (m_phase == 1)
{
assert(m_kart_node[0] != NULL || m_kart_node[1] != NULL || m_kart_node[2] != NULL);
int karts_not_yet_done = 0;
for (int k=0; k<3; k++)
{
@@ -328,7 +330,7 @@ void GrandPrixOver::onUpdate(float dt, irr::video::IVideoDriver* driver)
static int test_y = 0;
GUIEngine::getTitleFont()->draw(_("Grand Prix Results"),
GUIEngine::getTitleFont()->draw(_("You won the Grand Prix!"),
core::rect< s32 >( 0, test_y, w, h/10 ),
color,
true/* center h */, true /* center v */ );
@@ -336,7 +338,7 @@ void GrandPrixOver::onUpdate(float dt, irr::video::IVideoDriver* driver)
// -------------------------------------------------------------------------------------
void GrandPrixOver::eventCallback(GUIEngine::Widget* widget,
void GrandPrixWin::eventCallback(GUIEngine::Widget* widget,
const std::string& name,
const int playerID)
{
@@ -367,7 +369,7 @@ void GrandPrixOver::eventCallback(GUIEngine::Widget* widget,
// -------------------------------------------------------------------------------------
void GrandPrixOver::setKarts(const std::string idents_arg[3])
void GrandPrixWin::setKarts(const std::string idents_arg[3])
{
// reorder in "podium order" (i.e. second player to the left, first player in the middle, last at the right)
std::string idents[3];
@@ -385,6 +387,7 @@ void GrandPrixOver::setKarts(const std::string idents_arg[3])
if (kart != NULL)
{
KartModel* kartModel = kart->getKartModel();
assert(kartModel != NULL);
m_kart_x[n] = m_podium_x[n];
m_kart_y[n] = INITIAL_Y;
@@ -392,9 +395,9 @@ void GrandPrixOver::setKarts(const std::string idents_arg[3])
m_kart_rotation[n] = 0.0f;
kart_main_node = irr_driver->addMesh(kartModel->getModel());
assert(kart_main_node != NULL);
kart_main_node->setPosition( core::vector3df(m_kart_x[n], m_kart_y[n], m_kart_z[n]) );
kart_main_node->setScale( core::vector3df(0.4f, 0.4f, 0.4f) );
kart_main_node->updateAbsolutePosition();
for (int wheel=0; wheel<4; wheel++)
{
@@ -405,9 +408,15 @@ void GrandPrixOver::setKarts(const std::string idents_arg[3])
wheel_model->updateAbsolutePosition();
}
}
else
{
std::cerr << "GrandPrixWin : warning : kart '" << idents[n] << "' not found!\n";
}
m_kart_node[n] = kart_main_node;
}
} // end for
assert(m_kart_node[0] != NULL || m_kart_node[1] != NULL || m_kart_node[2] != NULL);
}
// -------------------------------------------------------------------------------------

11
src/states_screens/grand_prix_over.hpp → src/states_screens/grand_prix_win.hpp
View File

@@ -1,5 +1,5 @@
#ifndef HEADER_GRAND_PRIX_OVER_HPP
#define HEADER_GRAND_PRIX_OVER_HPP
#ifndef HEADER_GRAND_PRIX_WIN_HPP
#define HEADER_GRAND_PRIX_WIN_HPP
#include "guiengine/screen.hpp"
@@ -10,11 +10,11 @@ class KartProperties;
* \brief Screen shown at the end of a Grand Prix
* \ingroup states_screens
*/
class GrandPrixOver : public GUIEngine::Screen, public GUIEngine::ScreenSingleton<GrandPrixOver>
class GrandPrixWin : public GUIEngine::Screen, public GUIEngine::ScreenSingleton<GrandPrixWin>
{
friend class GUIEngine::ScreenSingleton<GrandPrixOver>;
friend class GUIEngine::ScreenSingleton<GrandPrixWin>;
GrandPrixOver();
GrandPrixWin();
/** sky angle, 0-360 */
float m_sky_angle;
@@ -58,6 +58,7 @@ public:
/** \brief implement callback from parent class GUIEngine::Screen */
void eventCallback(GUIEngine::Widget* widget, const std::string& name, const int playerID);
/** \pre must be called after pushing the screen, but before onUpdate had the chance to be invoked */
void setKarts(const std::string idents[3]);
};

21
src/states_screens/main_menu_screen.cpp
View File

@@ -31,7 +31,8 @@
// FIXME : remove, temporary test
#include "states_screens/feature_unlocked.hpp"
#include "states_screens/grand_prix_over.hpp"
#include "states_screens/grand_prix_lose.hpp"
#include "states_screens/grand_prix_win.hpp"
#include "tracks/track_manager.hpp"
#include "tracks/track.hpp"
@@ -82,17 +83,17 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name, cons
{
FeatureUnlockedCutScene* scene = FeatureUnlockedCutScene::getInstance();
static int i = 0;
static int i = 2;
i++;
if (i % 3 == 0)
if (i % 4 == 0)
{
// the passed kart will not be modified, that's why I allow myself to use const_cast
scene->addUnlockedKart( const_cast<KartProperties*>(kart_properties_manager->getKart("gnu")),
L"Unlocked");
StateManager::get()->pushScreen(scene);
}
else if (i % 3 == 1)
else if (i % 4 == 1)
{
std::vector<video::ITexture*> textures;
textures.push_back(irr_driver->getTexture(track_manager->getTrack("lighthouse")->getScreenshotFile().c_str()));
@@ -109,12 +110,18 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name, cons
StateManager::get()->pushScreen(scene);
}
else if (i % 4 == 2)
{
GrandPrixWin* scene = GrandPrixWin::getInstance();
const std::string winners[] = { "mriceblock", "nolok", "pidgin" };
StateManager::get()->pushScreen(scene);
scene->setKarts( winners );
}
else
{
GrandPrixOver* scene = GrandPrixOver::getInstance();
const std::string winners[] = { "mriceblock", "nolok", "pidgin" };
scene->setKarts( winners );
GrandPrixLose* scene = GrandPrixLose::getInstance();
StateManager::get()->pushScreen(scene);
scene->setKart( "nolok" );
}
}