Initial work on end-of-GP

git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/main/trunk@4787 178a84e3-b1eb-0310-8ba1-8eac791a3b58

src/race/race_manager.cpp

@@ -351,7 +351,7 @@ void RaceManager::exitRace()
             }
         } while(!sorted);
         
-        for(unsigned int i=start; i < NUM_KARTS; ++i)
+        for (unsigned int i=start; i < NUM_KARTS; ++i)
         {
             //printf("setting kart %s to rank %i\n", race_manager->getKartName(position[i]).c_str(), i-start);
             m_kart_status[position[i]].m_gp_final_rank = i - start;
@@ -365,6 +365,18 @@ void RaceManager::exitRace()
         
         StateManager::get()->resetAndGoToScreen( MainMenuScreen::getInstance() );
         StateManager::get()->pushScreen        ( GrandPrixOver::getInstance()  );
+        
+        std::string winners[3];
+        for (unsigned int i=start; i < m_kart_status.size(); ++i)
+        {
+            const int rank = m_kart_status[i].m_gp_final_rank;
+            if (rank >= 0 && rank < 3)
+            {
+                winners[rank] = m_kart_status[i].m_ident;
+            }
+        }
+        
+        GrandPrixOver::getInstance()->setKarts(winners);
     }
 
     delete World::getWorld();

src/states_screens/grand_prix_over.cpp

@@ -1,19 +1,25 @@
 
 #include "states_screens/grand_prix_over.hpp"
 
-
+#include "graphics/irr_driver.hpp"
 #include "guiengine/engine.hpp"
 #include "io/file_manager.hpp"
 #include "items/item_manager.hpp"
+#include "karts/kart_properties_manager.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 INITIAL_PODIUM_Y = -3.6f;
+const float PODIUM_HEIGHT[3] = { 0.325f, 0.5f, 0.15f };
+
 // -------------------------------------------------------------------------------------
 
 GrandPrixOver::GrandPrixOver() : Screen("grand_prix_over.stkgui")
@@ -21,34 +27,60 @@ GrandPrixOver::GrandPrixOver() : Screen("grand_prix_over.stkgui")
     setNeeds3D(true);
     
     throttleFPS = false;
+    
+    m_kart_node[0] = NULL;
+    m_kart_node[1] = NULL;
+    m_kart_node[2] = NULL;
 }
 
 // -------------------------------------------------------------------------------------
 
 void GrandPrixOver::init()
 {
+    m_phase = 1;
     m_sky_angle = 0.0f;
     m_global_time = 0.0f;
     
-    //m_sky = irr_driver->addSkyDome(file_manager->getTextureFile("lscales.png"), 16 /* hori_res */, 16 /* vert_res */,
-    //                       1.0f /* texture_percent */,  2.0f /* sphere_percent */);
-    
-    std::vector<std::string> texture_names(6);
-    texture_names[0] = file_manager->getTextureFile("purplenebula.png");
-    texture_names[1] = file_manager->getTextureFile("purplenebula2.png");
-    texture_names[2] = file_manager->getTextureFile("purplenebula.png");
-    texture_names[3] = file_manager->getTextureFile("purplenebula2.png");
-    texture_names[4] = file_manager->getTextureFile("purplenebula.png");
-    texture_names[5] = file_manager->getTextureFile("purplenebula2.png");
-    m_sky = irr_driver->addSkyBox(texture_names);
+    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->setPosition( core::vector3df(0.0, 30.0f, 70.0f) );
+    m_camera->setPosition( core::vector3df(3.0, 0.0f, -5.0f) );
     m_camera->setUpVector( core::vector3df(0.0, 1.0, 0.0) );
-    m_camera->setTarget( core::vector3df(0, 10, 0.0f) );
+    m_camera->setTarget( core::vector3df(1.5f, -2.0f, 0.0f) );
     m_camera->setFOV( DEGREE_TO_RAD*50.0f );
     m_camera->updateAbsolutePosition();
     
+    
+    scene::IMesh* model_village = irr_driver->getMesh( file_manager->getModelFile("village.b3d") );
+    assert(model_village != NULL);
+    m_village = irr_driver->addMesh(model_village);
+    m_village->setPosition( core::vector3df(2, INITIAL_Y, 0) );
+    
+    
+    scene::IMesh* podium_model = irr_driver->getMesh( file_manager->getModelFile("wood_podium.b3d") );
+    assert(podium_model != NULL);
+    
+    
+    m_podium_x[0] = 1.4f;
+    m_podium_z[0] = 0.0f;
+    
+    m_podium_x[1] = 2.2f;
+    m_podium_z[1] = 0.5f;
+    
+    m_podium_x[2] = 3.0f;
+    m_podium_z[2] = 0.0f;
+    
+    m_podium_step[0] = irr_driver->addMesh(podium_model);
+    m_podium_step[0]->setPosition( core::vector3df(m_podium_x[0], INITIAL_PODIUM_Y, m_podium_z[0]) );
+    
+    m_podium_step[1] = irr_driver->addMesh(podium_model);
+    m_podium_step[1]->setPosition( core::vector3df(m_podium_x[1], INITIAL_PODIUM_Y, m_podium_z[1]) );
+    
+    m_podium_step[2] = irr_driver->addMesh(podium_model);
+    m_podium_step[2]->setPosition( core::vector3df(m_podium_x[2], INITIAL_PODIUM_Y, m_podium_z[2]) );
+    
     irr_driver->getSceneManager()->setAmbientLight(video::SColor(255, 120, 120, 120));
     
     const core::vector3df &sun_pos = core::vector3df( 0, 200, 100.0f );
@@ -70,6 +102,17 @@ void GrandPrixOver::tearDown()
     
     irr_driver->removeNode(m_light);
     m_light = NULL;
+    
+    irr_driver->removeNode(m_village);
+    m_village = NULL;
+    
+    for (int n=0; n<3; n++)
+    {
+        irr_driver->removeNode(m_podium_step[n]);
+        m_podium_step[n] = NULL;
+        irr_driver->removeNode(m_kart_node[n]);
+        m_kart_node[n] = NULL;
+    }
 }
 
 // -------------------------------------------------------------------------------------
@@ -83,6 +126,112 @@ void GrandPrixOver::onUpdate(float dt, irr::video::IVideoDriver* driver)
     m_sky->setRotation( core::vector3df(0, m_sky_angle, 0) );
 
         
+    // ---- karts move
+    if (m_phase == 1)
+    {
+        int karts_on_target = 0;
+        for (int k=0; k<3; k++)
+        {
+            if (m_kart_node[k] != NULL)
+            {
+                bool x_target_reached = false, z_target_reached = false;
+                
+                if (fabsf(m_kart_x[k] - m_podium_x[k]) > dt)
+                {
+                    if (m_kart_x[k] < m_podium_x[k])
+                    {
+                        m_kart_x[k] += dt;
+                    }
+                    else if (m_kart_x[k] > m_podium_x[k])
+                    {
+                        m_kart_x[k] -= dt;
+                    }
+                }
+                else
+                {
+                    m_kart_x[k] = m_podium_x[k];
+                    x_target_reached = true;
+                }
+                
+                if (fabsf(m_kart_z[k] - m_podium_z[k]) > dt)
+                {
+                    if (m_kart_z[k] < m_podium_z[k])
+                    {
+                        m_kart_z[k] += dt;
+                    }
+                    else if (m_kart_z[k] > m_podium_z[k])
+                    {
+                        m_kart_z[k] -= dt;
+                    }
+                }
+                else
+                {
+                    m_kart_z[k] = m_podium_z[k];
+                    z_target_reached=true;
+                }
+                
+                
+                if (x_target_reached && z_target_reached) karts_on_target++;
+                
+                //std::cout << "kart position [" << k << "] = " << m_kart_x[k] << ", " << m_kart_z[k] << std::endl;
+                
+                m_kart_node[k]->setPosition( core::vector3df(m_kart_x[k], m_kart_y[k], m_kart_z[k]) );
+            }
+        } // end for
+        
+        if (karts_on_target == 3)
+        {
+            m_phase = 2;
+        }
+    }
+    
+    // ---- Karts Rotate
+    else if (m_phase == 2)
+    {
+        int karts_on_target = 0;
+        for (int k=0; k<3; k++)
+        {
+            if (m_kart_node[k] != NULL)
+            {
+                if (m_kart_rotation[k] < 180.f)
+                {
+                    m_kart_rotation[k] += 25.0f*dt;
+                    m_kart_node[k]->setRotation( core::vector3df(0, m_kart_rotation[k], 0) );
+                    m_podium_step[k]->setRotation( core::vector3df(0, m_kart_rotation[k], 0) );
+                }
+                else
+                {
+                    karts_on_target++;
+                }
+            }
+        } // end for
+        
+        if (karts_on_target == 3) m_phase = 3;
+    }
+    
+    // ---- Podium Rises
+    else if (m_phase == 3)
+    {
+        for (int k=0; k<3; k++)
+        {
+            if (m_kart_node[k] != NULL)
+            {
+                const float y_target = INITIAL_Y + PODIUM_HEIGHT[k];
+                if (m_kart_y[k] < y_target)
+                {
+                    m_kart_y[k] += dt*(PODIUM_HEIGHT[k]);
+                    m_kart_node[k]->setPosition(   core::vector3df(m_kart_x[k], m_kart_y[k], m_kart_z[k]) );
+                    m_podium_step[k]->setPosition( core::vector3df(m_podium_x[k],
+                                                                   INITIAL_PODIUM_Y - (INITIAL_Y - m_kart_y[k]),
+                                                                   m_podium_z[k]) );
+
+                }
+            }
+        } // end for
+        
+    }
+    
+    // ---- 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);
@@ -109,3 +258,48 @@ void GrandPrixOver::eventCallback(GUIEngine::Widget* widget,
 }
 
 // -------------------------------------------------------------------------------------
+
+void GrandPrixOver::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];
+    idents[0] = idents_arg[1];
+    idents[1] = idents_arg[0];
+    idents[2] = idents_arg[2];
+
+    for (int n=0; n<3; n++)
+    {
+        if (idents[n].size() == 0) continue;
+        
+        scene::ISceneNode* kart_main_node = NULL;
+        
+        const KartProperties* kart = kart_properties_manager->getKart(idents[n]);
+        if (kart != NULL)
+        {
+            KartModel* kartModel = kart->getKartModel();
+            
+            m_kart_x[n] = n*2;
+            m_kart_y[n] = INITIAL_Y;
+            m_kart_z[n] = -4;
+            m_kart_rotation[n] = 0.0f;
+            
+            kart_main_node = irr_driver->addMesh(kartModel->getModel());
+            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.4, 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();
+            }
+        }
+        
+        m_kart_node[n] = kart_main_node;
+    }
+}
+
+// -------------------------------------------------------------------------------------

src/states_screens/grand_prix_over.hpp

@@ -19,11 +19,22 @@ class GrandPrixOver : public GUIEngine::Screen, public GUIEngine::ScreenSingleto
     /** Global evolution of time */
     double m_global_time;
     
+    irr::scene::IMeshSceneNode* m_village;
+
+    irr::scene::IMeshSceneNode* m_podium_step[3];
+    irr::scene::ISceneNode* m_kart_node[3];
     
     irr::scene::ISceneNode* m_sky;
     irr::scene::ICameraSceneNode* m_camera;
 
     irr::scene::ILightSceneNode* m_light;
+    
+    int m_phase;
+    
+    float m_kart_x[3], m_kart_y[3], m_kart_z[3];
+    float m_podium_x[3], m_podium_z[3];
+    float m_kart_rotation[3];
+    
 public:
 
     void onUpdate(float dt, irr::video::IVideoDriver*);
@@ -31,6 +42,8 @@ public:
     void init();
     void tearDown();
     
+    void setKarts(const std::string idents[3]);
+    
     void eventCallback(GUIEngine::Widget* widget, const std::string& name, const int playerID);
 
 };

src/states_screens/main_menu_screen.cpp

@@ -31,6 +31,8 @@
 
 // FIXME : remove, temporary test
 #include "states_screens/feature_unlocked.hpp"
+#include "states_screens/grand_prix_over.hpp"
+
 #include "tracks/track_manager.hpp"
 #include "tracks/track.hpp"
 
@@ -65,6 +67,12 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name, cons
     if (selection == "network")
     {
         // FIXME : remove, temporary test
+        GrandPrixOver* scene = GrandPrixOver::getInstance();
+        const std::string winners[] = { "tux", "nolok", "pidgin" };
+        scene->setKarts( winners );
+        StateManager::get()->pushScreen(scene);
+
+        /*
         FeatureUnlockedCutScene* scene = FeatureUnlockedCutScene::getInstance();
         
         static int i = 0;
@@ -81,6 +89,7 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name, cons
             scene->setUnlockedPicture( irr_driver->getTexture(track_manager->getTrack("beach")->getScreenshotFile().c_str()) );
             StateManager::get()->pushScreen(scene);
         }
+         */
     }
     
     if (selection == "new")