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

Work on cutscenes

Browse Source
This commit is contained in:
Marianne Gagnon 2014-05-04 18:54:37 -04:00
parent 30929ef0a7
commit 5acb763ac8
12 changed files with 93 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
data/models/door.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 111 KiB

BIN
data/models/gplose.b3d
View File

Binary file not shown.

BIN
data/models/gplose_door.b3d
View File

Binary file not shown.

BIN
data/models/village.b3d
View File

Binary file not shown.

BIN
data/models/wood_podium.b3d
View File

Binary file not shown.

13
src/modes/cutscene_world.cpp
View File

@ -386,9 +386,18 @@ void CutsceneWorld::enterRaceOverState()
// TODO: remove hardcoded knowledge of cutscenes, replace with scripting probably
else if (m_parts.size() == 1 && m_parts[0] == "gpwin")
{
MainMenuScreen* mainMenu = MainMenuScreen::getInstance();
race_manager->exitRace();
StateManager::get()->resetAndGoToScreen(mainMenu);
StateManager::get()->resetAndGoToScreen(MainMenuScreen::getInstance());
if (race_manager->raceWasStartedFromOverworld())
OverWorld::enterOverWorld();
}
// TODO: remove hardcoded knowledge of cutscenes, replace with scripting probably
else if (m_parts.size() == 1 && m_parts[0] == "gplose")
{
race_manager->exitRace();
StateManager::get()->resetAndGoToScreen(MainMenuScreen::getInstance());
if (race_manager->raceWasStartedFromOverworld())
OverWorld::enterOverWorld();
}
// TODO: remove hardcoded knowledge of cutscenes, replace with scripting probably
else if (race_manager->getTrackName() == "introcutscene" ||

16
src/race/race_manager.cpp
View File

@ -700,18 +700,28 @@ void RaceManager::exitRace(bool delete_world)
}
else
{
StateManager::get()->pushScreen( GrandPrixLose::getInstance() );
if (delete_world) World::deleteWorld();
delete_world = false;
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts(0);
race_manager->setNumPlayers(0);
race_manager->setNumLocalPlayers(0);
race_manager->startSingleRace("gplose", 999, false);
GrandPrixLose* scene = GrandPrixLose::getInstance();
StateManager::get()->pushScreen(scene);
if (humanLosers.size() >= 1)
{
GrandPrixLose::getInstance()->setKarts( humanLosers );
scene->setKarts(humanLosers);
}
else
{
std::cerr << "RaceManager::exitRace() : what's going on?? no winners and no losers??\n";
std::vector<std::string> karts;
karts.push_back(UserConfigParams::m_default_kart);
GrandPrixLose::getInstance()->setKarts( karts );
scene->setKarts(karts);
}
}
}

219
src/states_screens/grand_prix_lose.cpp
View File

@ -31,10 +31,15 @@
#include "items/item_manager.hpp"
#include "karts/kart_properties.hpp"
#include "karts/kart_properties_manager.hpp"
#include "modes/cutscene_world.hpp"
#include "modes/overworld.hpp"
#include "modes/world.hpp"
#include "states_screens/feature_unlocked.hpp"
#include "states_screens/main_menu_screen.hpp"
#include "states_screens/state_manager.hpp"
#include "tracks/track.hpp"
#include "tracks/track_object.hpp"
#include "tracks/track_object_manager.hpp"
#include "utils/translation.hpp"
#include <ISceneManager.h>
@ -61,10 +66,11 @@ const float CAMERA_START_Z = 5.5f;
const float DISTANCE_BETWEEN_KARTS = 2.0f;
const float KART_SCALE = 0.75f;
const float KART_START_X = -17.0f;
const float KART_END_X = -5.0f;
const float KART_Y = -3.0f;
const float KART_Y = 0.0f;
const float KART_Z = 0.0f;
@ -76,22 +82,11 @@ DEFINE_SCREEN_SINGLETON( GrandPrixLose );
// -------------------------------------------------------------------------------------
GrandPrixLose::GrandPrixLose() : Screen("grand_prix_lose.stkgui")
GrandPrixLose::GrandPrixLose() : Screen("grand_prix_lose.stkgui", false /* pause race */)
{
setNeeds3D(true);
m_throttle_FPS = false;
try
{
std::string path = file_manager->getAsset(FileManager::MUSIC, "lose_theme.music");
m_music = music_manager->getMusicInformation(path);
}
catch (std::exception& e)
{
fprintf(stderr, "[GrandPrixLose] WARNING: exception caught when trying to load music: %s\n", e.what());
m_music = NULL;
}
} // GrandPrixLose
// -------------------------------------------------------------------------------------
@ -108,61 +103,17 @@ void GrandPrixLose::loadedFromFile()
void GrandPrixLose::init()
{
std::vector<std::string> parts;
parts.push_back("gplose");
((CutsceneWorld*)World::getWorld())->setParts(parts);
CutsceneWorld::setUseDuration(false);
Screen::init();
World::getWorld()->setPhase(WorldStatus::RACE_PHASE);
m_phase = 1;
m_sky_angle = 0.0f;
m_global_time = 0.0f;
video::ITexture *t = irr_driver->getTexture(FileManager::TEXTURE, "clouds.png");
m_sky = irr_driver->addSkyDome(t,
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) );
irr_driver->getSceneManager()->setActiveCamera(m_camera);
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->getAsset(FileManager::MODEL,"gplose_door.b3d") );
assert(model_garage_door!= NULL);
m_garage_door = irr_driver->addAnimatedMesh(model_garage_door);
#ifdef DEBUG
m_garage_door->setName("garage-door");
#endif
m_garage_door->setPosition( core::vector3df(2, INITIAL_Y, 0) );
m_garage_door->setAnimationSpeed(0);
scene::IMesh* model_garage = irr_driver->getMesh( file_manager->getAsset(FileManager::MODEL,"gplose.b3d") );
assert(model_garage!= NULL);
m_garage = irr_driver->addMesh(model_garage);
#ifdef DEBUG
m_garage->setName("garage");
#endif
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->addLight(sun_pos, 300.0f, 1, 1, 1);
if (!irr_driver->isGLSL())
{
scene::ILightSceneNode *lnode = (scene::ILightSceneNode *) m_light;
lnode->getLightData().DiffuseColor = irr::video::SColorf(1.0f, 1.0f, 1.0f, 1.0f);
lnode->getLightData().SpecularColor = irr::video::SColorf(1.0f, 0.0f, 0.0f, 0.0f);
}
} // init
// -------------------------------------------------------------------------------------
@ -170,32 +121,17 @@ void GrandPrixLose::init()
void GrandPrixLose::tearDown()
{
Screen::tearDown();
irr_driver->removeNode(m_sky);
m_sky = NULL;
((CutsceneWorld*)World::getWorld())->abortCutscene();
irr_driver->removeCameraSceneNode(m_camera);
m_camera = NULL;
irr_driver->removeNode(m_light);
m_light = NULL;
irr_driver->removeNode(m_garage);
irr_driver->removeNode(m_garage_door);
m_garage = NULL;
for(unsigned int i=0; i<m_all_kart_models.size(); i++)
for (unsigned int i=0; i<m_all_kart_models.size(); i++)
delete m_all_kart_models[i];
m_all_kart_models.clear();
for (int n=0; n<MAX_KART_COUNT; n++)
{
if (m_kart_node[n] != NULL)
{
irr_driver->removeNode(m_kart_node[n]);
}
}
m_kart_node[0] = NULL;
m_kart_node[1] = NULL;
m_kart_node[2] = NULL;
m_kart_node[3] = NULL;
} // tearDown
// -------------------------------------------------------------------------------------
@ -204,54 +140,25 @@ void GrandPrixLose::onUpdate(float dt)
{
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 < GARAGE_DOOR_OPEN_TIME)
{
m_garage_door->setCurrentFrame( (m_global_time/GARAGE_DOOR_OPEN_TIME)*lastFrame );
}
else if (m_global_time > DURATION - GARAGE_DOOR_OPEN_TIME)
{
m_garage_door->setCurrentFrame( (1.0f - ((m_global_time -
(DURATION - GARAGE_DOOR_OPEN_TIME))/GARAGE_DOOR_OPEN_TIME))
*lastFrame );
}
//else if (m_global_time < DURATION)
//{
// m_garage_door->setCurrentFrame( lastFrame );
//}
const float kartProgression = m_global_time/(DURATION - 6.0f);
if (kartProgression <= 1.0f)
{
m_kart_x = KART_START_X + (KART_END_X - KART_START_X)*kartProgression;
core::vector3df kart_rot(0.0f, 90.0f, 0.0f);
core::vector3df kart_scale(KART_SCALE, KART_SCALE, KART_SCALE);
for (int n=0; n<MAX_KART_COUNT; n++)
{
if (m_kart_node[n] != NULL)
{
m_kart_node[n]->setPosition( core::vector3df(m_kart_x + n*DISTANCE_BETWEEN_KARTS,
m_kart_y,
m_kart_z) );
core::vector3df kart_pos(m_kart_x + n*DISTANCE_BETWEEN_KARTS,
m_kart_y,
m_kart_z);
m_kart_node[n]->move(kart_pos, kart_rot, kart_scale, false);
}
}
}
const float progression = m_global_time / DURATION;
if (progression <= 1.5f)
{
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
const int w = irr_driver->getFrameSize().Width;
const int h = irr_driver->getFrameSize().Height;
@ -311,7 +218,7 @@ void GrandPrixLose::eventCallback(GUIEngine::Widget* widget,
void GrandPrixLose::setKarts(std::vector<std::string> ident_arg)
{
scene::ISceneNode* kart_main_node = NULL;
TrackObjectManager* tobjman = World::getWorld()->getTrack()->getTrackObjectManager();
assert(ident_arg.size() > 0);
if ((int)ident_arg.size() > MAX_KART_COUNT)
@ -324,6 +231,10 @@ void GrandPrixLose::setKarts(std::vector<std::string> ident_arg)
m_kart_node[2] = NULL;
m_kart_node[3] = NULL;
m_kart_x = KART_START_X;
m_kart_y = KART_Y;
m_kart_z = KART_Z;
const int count = ident_arg.size();
for (int n=0; n<count; n++)
{
@ -332,59 +243,29 @@ void GrandPrixLose::setKarts(std::vector<std::string> ident_arg)
{
KartModel* kart_model = kart->getKartModelCopy();
m_all_kart_models.push_back(kart_model);
m_kart_x = KART_START_X;
m_kart_y = KART_Y;
m_kart_z = KART_Z;
scene::ISceneNode* kart_main_node = kart_model->attachModel(false);
kart_main_node = kart_model->attachModel(false);
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();
kart_main_node->setRotation(vector3df(0, 90, 0));
float susp[4]={0,0,0,0};
kart_model->update(0.0f, 0.0f, 0.0f, susp, 0.0f);
core::vector3df kart_pos(m_kart_x + n*DISTANCE_BETWEEN_KARTS,
m_kart_y,
m_kart_z);
core::vector3df kart_rot(0, 90.0f, 0);
core::vector3df kart_scale(KART_SCALE, KART_SCALE, KART_SCALE);
//FIXME: it's not ideal that both the track object and the presentation know the initial coordinates of the object
TrackObjectPresentationSceneNode* presentation = new TrackObjectPresentationSceneNode(
kart_main_node, kart_pos, kart_rot, kart_scale);
TrackObject* tobj = new TrackObject(kart_pos, kart_rot, kart_scale,
"ghost", presentation, false /* isDynamic */, NULL /* physics settings */);
tobjman->insertObject(tobj);
m_kart_node[n] = tobj;
}
else
{
fprintf(stderr, "[GrandPrixLose] WARNING: could not find a kart named '%s'\n", ident_arg[n].c_str());
m_kart_node[n] = NULL;
}// if kart !=NULL
m_kart_node[n] = kart_main_node;
}
/*
const int w = UserConfigParams::m_width;
const int h = UserConfigParams::m_height;
switch (count)
{
case 1:
m_viewport[0] = core::recti(0, 0, w, h);
break;
case 2:
m_viewport[0] = core::recti(0, 0, w, h/2);
m_viewport[1] = core::recti(0, h/2, w, h);
break;
case 3:
m_viewport[0] = core::recti(0, 0, w/2, h/2);
m_viewport[1] = core::recti(w/2, 0, 2, h/2);
m_viewport[2] = core::recti(0, h/2, w, h);
break;
case 4:
m_viewport[0] = core::recti(0, 0, w/2, h/2);
m_viewport[1] = core::recti(w/2, 0, 2, h/2);
m_viewport[2] = core::recti(0, h/2, w/2, h);
m_viewport[3] = core::recti(w/2, h/2, w, h);
break;
default:
assert(false);
}
*/
} // setKarts
// -------------------------------------------------------------------------------------

25
src/states_screens/grand_prix_lose.hpp
View File

@ -27,6 +27,7 @@
namespace irr { namespace scene { class ISceneNode; class ICameraSceneNode; class ILightSceneNode; class IMeshSceneNode; } }
class KartProperties;
class TrackObject;
/**
* \brief Screen shown at the end of a Grand Prix
@ -38,22 +39,10 @@ class GrandPrixLose : public GUIEngine::Screen, public GUIEngine::ScreenSingleto
GrandPrixLose();
/** sky angle, 0-360 */
float m_sky_angle;
/** Global evolution of time */
float m_global_time;
irr::scene::IMeshSceneNode* m_garage;
irr::scene::IAnimatedMeshSceneNode* m_garage_door;
irr::scene::ISceneNode* m_kart_node[4];
irr::scene::ISceneNode* m_sky;
irr::scene::ICameraSceneNode* m_camera;
irr::scene::ISceneNode* m_light;
TrackObject* m_kart_node[4];
/** A copy of the kart model for each kart used. */
std::vector<KartModel*> m_all_kart_models;
@ -62,13 +51,6 @@ class GrandPrixLose : public GUIEngine::Screen, public GUIEngine::ScreenSingleto
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;
MusicInformation* m_music;
//irr::core::recti m_viewport[4];
public:
/** \brief implement callback from parent class GUIEngine::Screen */
@ -89,9 +71,6 @@ public:
/** \brief set which karts lost this GP */
void setKarts(std::vector<std::string> ident);
virtual MusicInformation* getMusic() const OVERRIDE { return m_music; }
};
#endif

2
src/states_screens/grand_prix_win.cpp
View File

@ -65,7 +65,7 @@ DEFINE_SCREEN_SINGLETON( GrandPrixWin );
// -------------------------------------------------------------------------------------
GrandPrixWin::GrandPrixWin() : Screen("grand_prix_win.stkgui", false)
GrandPrixWin::GrandPrixWin() : Screen("grand_prix_win.stkgui", false /* pause race */)
{
setNeeds3D(true);

18
src/states_screens/main_menu_screen.cpp
View File

@ -235,6 +235,7 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
// The DEBUG item
// GP WIN
/*
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts(0);
@ -242,20 +243,27 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
race_manager->setNumLocalPlayers(0);
race_manager->startSingleRace("gpwin", 999, false);
GrandPrixWin* scene = GrandPrixWin::getInstance();
const std::string winners[] = { "elephpant", "nolok", "pidgin" };
StateManager::get()->pushScreen(scene);
const std::string winners[] = { "elephpant", "nolok", "pidgin" };
scene->setKarts(winners);
*/
// GP Lose
/*
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts(0);
race_manager->setNumPlayers(0);
race_manager->setNumLocalPlayers(0);
race_manager->startSingleRace("gplose", 999, false);
GrandPrixLose* scene = GrandPrixLose::getInstance();
StateManager::get()->pushScreen(scene);
std::vector<std::string> losers;
losers.push_back("nolok");
losers.push_back("elephpant");
losers.push_back("wilber");
scene->setKarts( losers );
*/
//losers.push_back("wilber");
//losers.push_back("tux");
scene->setKarts(losers);
/*
// FEATURE UNLOCKED

7
src/tracks/track_object_presentation.cpp
View File

@ -393,10 +393,9 @@ void TrackObjectPresentationMesh::reset()
a_node->OnAnimate(0);
a_node->OnAnimate(0);
if(m_is_looped)
{
a_node->setFrameLoop(m_frame_start, m_frame_end);
}
// irrlicht's "setFrameLoop" is a misnomer, it just sets the first and
// last frame, even if looping is disabled
a_node->setFrameLoop(m_frame_start, m_frame_end);
}
}