Kukatz 3D  0.1
Török Attila szakdolgozata
projects/Kukatz 3D/src/game.cpp
00001 /*
00002  * game.cpp - Kukatz 3D
00003  * Copyright (c) 2010, 2011, 2012 - TÖRÖK Attila (torokati44@gmail.com)
00004  *
00005  * This software is provided 'as-is', without any express or implied
00006  * warranty. In no event will the authors be held liable for any damages
00007  * arising from the use of this software.
00008  *
00009  * Permission is granted to anyone to use this software for any purpose,
00010  * including commercial applications, and to alter it and redistribute it
00011  * freely, subject to the following restrictions:
00012  *
00013  *       1. The origin of this software must not be misrepresented; you must not
00014  *                      claim that you wrote the original software. If you use this software
00015  *                      in a product, an acknowledgment in the product documentation would be
00016  *                      appreciated but is not required.
00017  *
00018  *       2. Altered source versions must be plainly marked as such, and must not be
00019  *                      misrepresented as being the original software.
00020  *
00021  *       3. This notice may not be removed or altered from any source
00022  *                      distribution.
00023  */
00024 
00025 #include "game.hpp"
00026 
00027 #include <cstring> // for memset
00028 #include <iostream>
00029 
00030 #include "opengl.hpp"
00031 #include "misc.hpp"
00032 #include "windowmanager.hpp"
00033 #include "statemanager.hpp"
00034 #include "humanplayer.hpp"
00035 #include "aiplayer.hpp"
00036 #include "configmanager.hpp"
00037 #include "gameover.hpp"
00038 #include "overviewcamera.hpp"
00039 #include "summarygui.hpp"
00040 
00041 Game::Game(unsigned int w, unsigned int h, const std::vector< Profile* >& profiles,
00042                 unsigned int num_edibles, unsigned int s_r):
00043         StateBase(w, h), grid(41, 41, 41), paused(false), supply_rate(s_r),
00044         earthcube(new StaticObject("EARTHCUBE", "GROUND_1"))
00045 {
00046         // edibles
00047         for (size_t i = 0; i < num_edibles; ++i)
00048         {
00049                 edibles.push_back(new Edible(ResourceManager::instance().get_random_edibletype(), get_random_empty_pos()));
00050         }
00051         
00052         bool sides_taken[6] = {false, false, false, false, false, false};
00053         sf::Vector3i positions[6];
00054         sf::Vector3i directions[6];
00055         sf::Vector3i ups[6];
00056         
00057         for (unsigned int i = 0; i < 6; ++i)
00058         {
00059                 unsigned int side;
00060                 do
00061                 {
00062                         side = sf::Randomizer::Random(0, 5);
00063                 } while (sides_taken[side]);
00064                 
00065                 switch (side)
00066                 {
00067                         case 0:
00068                                 positions[i] = sf::Vector3i(19, 0, 0);
00069                                 directions[i] = sf::Vector3i(-1, 0, 0);
00070                                 ups[i] = sf::Vector3i(0, 0, 1);
00071                         break;
00072                         case 1:
00073                                 positions[i] = sf::Vector3i(-19, 0, 0);
00074                                 directions[i] = sf::Vector3i(1, 0, 0);
00075                                 ups[i] = sf::Vector3i(0, 0, -1);
00076                         break;
00077                         case 2:
00078                                 positions[i] = sf::Vector3i(0, 19, 0);
00079                                 directions[i] = sf::Vector3i(0, -1, 0);
00080                                 ups[i] = sf::Vector3i(1, 0, 0);
00081                         break;
00082                         case 3:
00083                                 positions[i] = sf::Vector3i(0, -19, 0);
00084                                 directions[i] = sf::Vector3i(0, 1, 0);
00085                                 ups[i] = sf::Vector3i(-1, 0, 0);
00086                         break;
00087                         case 4:
00088                                 positions[i] = sf::Vector3i(0, 0, 19);
00089                                 directions[i] = sf::Vector3i(0, 0, -1);
00090                                 ups[i] = sf::Vector3i(0, 1, 0);
00091                         break;
00092                         case 5:
00093                                 positions[i] = sf::Vector3i(0, 0, -19);
00094                                 directions[i] = sf::Vector3i(0, 0, 1);
00095                                 ups[i] = sf::Vector3i(0, -1, 0);
00096                         break;
00097                 }
00098                 
00099                 sides_taken[side] = true;
00100         }
00101         
00102         bool show_ai_cameras = ConfigManager::instance().get_bool("show_ai_cameras");
00103         
00104         Kukac* k_ptr;
00105         String* str_ptr;
00106         
00107         for (unsigned int i = 0; i < profiles.size(); ++i)
00108         {
00109                 k_ptr = new Kukac(grid, profiles[i]->head_style, positions[players.size()],
00110                         directions[players.size()], ups[players.size()], 4, 4);
00111                 
00112                 str_ptr = new String(profiles[i]->name, "#44");
00113                 str_ptr->billboard = true;
00114                 player_names.push_back(str_ptr);
00115                 
00116                 if (profiles[i]->is_human)
00117                 {
00118                         players.push_back(new HumanPlayer(profiles[i]->name, k_ptr,
00119                                 profiles[i]->key_up, profiles[i]->key_left,
00120                                 profiles[i]->key_down, profiles[i]->key_right));
00121                         
00122                         cameras.push_back(new FollowerCamera(k_ptr));
00123                         
00124                         PlayerGUI* gui = new PlayerGUI(players[i]);
00125                         
00126                         GUIString* paused_string = new GUIString(L"SZÜNET", "#44");
00127                         
00128                         paused_string->visible = false;
00129                         
00130                         gui->attach(paused_string, 0.25f, GUIElement::SCALE_MODE_SMALLER, 0.5f, 0.5f);
00131                         
00132                         guis.push_back(gui);
00133                 }
00134                 else
00135                 {
00136                         players.push_back(new AIPlayer(profiles[i]->name, profiles[i]->skill, k_ptr, this));
00137                         
00138                         unsigned int num_human_players = 0;
00139                         for (unsigned int j = 0; j < profiles.size(); ++j)
00140                         {
00141                                 if (profiles[j]->is_human)
00142                                 {
00143                                         ++num_human_players;
00144                                 }
00145                         }
00146                         
00147                         if (show_ai_cameras || !num_human_players)
00148                         {
00149                                 cameras.push_back(new FollowerCamera(k_ptr));
00150                                 
00151                                 PlayerGUI* gui = new PlayerGUI(players[i]);
00152                                 
00153                                 GUIString* paused_string = new GUIString(L"SZÜNET", "#44");
00154                                 
00155                                 paused_string->visible = false;
00156                                 
00157                                 gui->attach(paused_string, 0.25f, GUIElement::SCALE_MODE_SMALLER, 0.5f, 0.5f);
00158                                 
00159                                 guis.push_back(gui);
00160                         }
00161                 }
00162         }
00163         
00164         
00165         
00166         /*
00167         Camera* debugger_cam = new Camera(sf::Vector3f(0, 0, 20),
00168         sf::Vector3f(0, 0, 0), sf::Vector3f(1, 0, 0), sf::Vector2i(0, 0), sf::Vector2i(200,200));
00169         
00170         cameras.push_back(debugger_cam);
00171         guis.push_back(new PlayerGUI(players[0]));
00172         */
00173         
00174         
00175         camera_mosaic(sf::Vector2i(
00176                 WindowManager::instance().get_window().GetWidth(),
00177                 WindowManager::instance().get_window().GetHeight()));
00178         
00179         
00180         Texture::unbind();
00181         
00182         std::string render_3D = ConfigManager::instance().get_string("3D");
00183         
00184         if ((render_3D != "off") && (render_3D != ""))
00185         {
00186                 glGenTextures(1, &left_texture);
00187                 glGenTextures(1, &right_texture);
00188                 
00189                 glActiveTexture(GL_TEXTURE1);
00190                 glBindTexture(GL_TEXTURE_2D, left_texture);
00191                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
00192                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
00193                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
00194                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
00195                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
00196                 
00197                 glActiveTexture(GL_TEXTURE2);
00198                 glBindTexture(GL_TEXTURE_2D, right_texture);
00199                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
00200                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
00201                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
00202                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
00203                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
00204                 
00205                 glActiveTexture(GL_TEXTURE0);
00206                 glBindTexture(GL_TEXTURE_2D, 0);
00207                 
00208                 Texture::unbind();
00209                 
00210                 
00211                 glGenRenderbuffersEXT(1, &depth_buffer);
00212                 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_buffer);
00213                 glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, w, h);
00214                 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
00215                 
00216                 glGenFramebuffersEXT(1, &fbo);
00217                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
00218                 
00219                 glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
00220                         GL_RENDERBUFFER_EXT, depth_buffer);
00221                 
00222                 
00223                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
00224         }
00225 }
00226 
00227 void Game::resize(const sf::Vector2i& s)
00228 {
00229         camera_mosaic(s);
00230         size = s;
00231         
00232         std::string render_3D = ConfigManager::instance().get_string("3D");
00233         
00234         if ((render_3D != "off") && (render_3D != ""))
00235         {
00236                 glDeleteFramebuffersEXT(1, &fbo);
00237                 glDeleteRenderbuffersEXT(1, &depth_buffer);
00238                 glDeleteTextures(1, &left_texture);
00239                 glDeleteTextures(1, &right_texture);
00240                 
00241                 // REGENERATING
00242                 
00243                 glGenTextures(1, &left_texture);
00244                 glGenTextures(1, &right_texture);
00245                 
00246                 glActiveTexture(GL_TEXTURE1);
00247                 glBindTexture(GL_TEXTURE_2D, left_texture);
00248                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
00249                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
00250                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
00251                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
00252                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, size.x, size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
00253                 
00254                 glActiveTexture(GL_TEXTURE2);
00255                 glBindTexture(GL_TEXTURE_2D, right_texture);
00256                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
00257                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
00258                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
00259                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
00260                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, size.x, size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
00261                 
00262                 glActiveTexture(GL_TEXTURE0);
00263                 glBindTexture(GL_TEXTURE_2D, 0);
00264                 
00265                 Texture::unbind();
00266                 
00267                 
00268                 glGenRenderbuffersEXT(1, &depth_buffer);
00269                 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depth_buffer);
00270                 glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, size.x, size.y);
00271                 glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
00272                 
00273                 glGenFramebuffersEXT(1, &fbo);
00274                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
00275                 
00276                 glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT,
00277                         GL_RENDERBUFFER_EXT, depth_buffer);
00278                 
00279                 
00280                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
00281         }
00282 }
00283 
00284 Edible* Game::get_closest_edible(const sf::Vector3i& p)
00285 {
00286         if (edibles.size() == 0)
00287         {
00288                 return 0;
00289         }
00290         else
00291         {
00292                 if (edibles.size() == 1)
00293                 {
00294                         return edibles.front();
00295                 }
00296                 else
00297                 {
00298                         Edible* ret = edibles.front();
00299                         float min_dist = step_dist(edibles.front()->pos, p);
00300                         float dist = min_dist;
00301                         
00302                         for (size_t i = 1; i < edibles.size(); ++i)
00303                         {
00304                                 dist = step_dist(edibles[i]->pos, p);
00305                                 if (dist < min_dist)
00306                                 {
00307                                         min_dist = dist;
00308                                         ret = edibles[i];
00309                                 }
00310                         }
00311                         
00312                         return ret;
00313                 }
00314         }
00315 }
00316 
00317 void Game::process_edible(unsigned int e, unsigned int p)
00318 {
00319         players[p]->score += edibles[e]->type->score;
00320         //std::cout << "edibles[e]->type->grows = " << edibles[e]->type->grows << "\n";
00321         players[p]->kukac_ptr->grow(edibles[e]->type->grows);
00322         players[p]->kukac_ptr->accelerate(edibles[e]->type->accelerates);
00323         
00324         if (edibles[e]->type->reverses_others)
00325         {
00326                 for (size_t i = 0; i < players.size(); ++i)
00327                 {
00328                         if ((i != p) && (players[i]->kukac_ptr->is_alive())) // FIXME
00329                         {
00330                                 players[i]->kukac_ptr->reverse();
00331                         }
00332                 }
00333         }
00334 }
00335 
00336 void Game::process_events(std::vector< sf::Event > &events)
00337 {
00338         for (size_t e = 0; e < events.size(); ++e)
00339         {
00340                 if (events[e].Type == sf::Event::KeyPressed)
00341                 {
00342                         switch (events[e].Key.Code)
00343                         {
00344                                 case sf::Key::Escape:
00345                                 {
00346                                         StateManager::instance().push_state(new GameOver(size.x, size.y, players));
00347                                         pop();
00348                                 }
00349                                 break;
00350                                 case sf::Key::P:
00351                                 {
00352                                         paused = !paused;
00353                                         for (size_t i = 0; i < guis.size(); ++i)
00354                                         {
00355                                                 if (!guis[i]->children.empty())
00356                                                 {
00357                                                         guis[i]->children.back()->visible = paused;
00358                                                 }
00359                                         }
00360                                 }
00361                                 break;
00362                                 /* // for testing only, should be configurable
00363                                 case sf::Key::Add:
00364                                 {
00365                                         for (unsigned int i = 0; i < cameras.size(); ++i)
00366                                         {
00367                                                 cameras[i]->eye_distance += 0.01f;
00368                                                 std::cout << "eye_distance = " << cameras[i]->eye_distance << "\n";
00369                                         }
00370                                 }
00371                                 break;
00372                                 case sf::Key::Subtract:
00373                                 {
00374                                         for (unsigned int i = 0; i < cameras.size(); ++i)
00375                                         {
00376                                                 cameras[i]->eye_distance -= 0.01f;
00377                                                 std::cout << "eye_distance = " << cameras[i]->eye_distance << "\n";
00378                                         }
00379                                 }
00380                                 break;
00381                                 case sf::Key::Multiply:
00382                                 {
00383                                         for (unsigned int i = 0; i < cameras.size(); ++i)
00384                                         {
00385                                                 cameras[i]->screen_distance += 0.5f;
00386                                                 std::cout << "screen_distance = " << cameras[i]->screen_distance << "\n";
00387                                         }
00388                                 }
00389                                 break;
00390                                 case sf::Key::Divide:
00391                                 {
00392                                         for (unsigned int i = 0; i < cameras.size(); ++i)
00393                                         {
00394                                                 cameras[i]->screen_distance -= 0.5f;
00395                                                 std::cout << "screen_distance = " << cameras[i]->screen_distance << "\n";
00396                                         }
00397                                 }
00398                                 break;
00399                                 */
00400                                 default:
00401                                 {
00402                                         if (!paused)
00403                                         {
00404                                                 for (size_t i = 0; i < players.size(); ++i)
00405                                                 {
00406                                                         HumanPlayer* hp_ptr = dynamic_cast< HumanPlayer* >(players[i]);
00407                                                         if (hp_ptr)
00408                                                         {
00409                                                                 hp_ptr->keypress(events[e].Key.Code);
00410                                                         }
00411                                                 }
00412                                         }
00413                                 }
00414                         }
00415                 }
00416         }
00417 }
00418 
00419 void Game::update(float dt)
00420 {
00421         if (paused)
00422         {
00423                 return;
00424         }
00425         
00426         bool all_kukacs_are_dead = true;
00427         
00428         for (size_t i = 0; i < players.size(); ++i)
00429         {
00430                 players[i]->update(dt);
00431                 
00432                 if (players[i]->kukac_ptr->is_alive())
00433                 {
00434                         all_kukacs_are_dead = false;
00435                 }
00436                 
00437                 if (players[i]->kukac_ptr->did_move())
00438                 {
00439                         for (size_t j = 0; j < edibles.size(); ++j)
00440                         {
00441                                 if ((edibles[j]->pos == players[i]->kukac_ptr->head->pos)
00442                                         || (players[i]->kukac_ptr->did_reverse() && (edibles[j]->pos == players[i]->kukac_ptr->tail->pos)))
00443                                 {
00444                                         process_edible(j, i);
00445                                         delete edibles[j];
00446                                         
00447                                         edibles[j] = edibles.back();
00448                                         edibles.pop_back();
00449                                         
00450                                         for (unsigned int k = 0; k < supply_rate; ++k)
00451                                         {
00452                                                 edibles.push_back(new Edible(ResourceManager::instance().get_random_edibletype(), get_random_empty_pos()));
00453                                         }
00454                                         
00455                                         if (edibles.empty())
00456                                         {
00457                                                 StateManager::instance().push_state(new GameOver(size.x, size.y, players));
00458                                                 pop();
00459                                         }
00460                                 }
00461                         }
00462                 }
00463         }
00464         
00465         for (size_t i = 0; i < cameras.size(); ++i)
00466         {
00467                 Updatable* u = dynamic_cast< Updatable* >(cameras[i]);
00468                 if (u)
00469                 {
00470                         u->update(dt);
00471                 }
00472         }
00473         
00474         for (size_t i = 0; i < guis.size(); ++i)
00475         {
00476                 Updatable* u = dynamic_cast< Updatable* >(guis[i]);
00477                 if (u)
00478                 {
00479                         u->update(dt);
00480                 }
00481         }
00482         
00483         
00484         if (all_kukacs_are_dead)
00485         {
00486                 StateManager::instance().push_state(new GameOver(size.x, size.y, players));
00487                 pop();
00488         }
00489 }
00490 
00491 void Game::render()
00492 {
00493         std::string render_3D = ConfigManager::instance().get_string("3D");
00494         
00495         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
00496         
00497         if ((render_3D == "off") || (render_3D == ""))
00498         {
00499                 for (size_t i = 0; i < cameras.size(); ++i)
00500                 {
00501                         cameras[i]->look_3d(0.0f);
00502                         
00503                         reset_material();
00504                         
00505                         render_scene();
00506                         /*
00507                         glPushMatrix();
00508                         glTranslatef(40, 0, 0);
00509                         render_scene();
00510                         glPopMatrix();
00511                         */
00512                         glClear(GL_DEPTH_BUFFER_BIT);
00513                         
00514                         cameras[i]->look_2d();
00515                         glPushMatrix();
00516                         glTranslatef(0, 0, -1);
00517                         
00518                         glDisable(GL_DEPTH_TEST);
00519                         guis[i]->render();
00520                         glEnable(GL_DEPTH_TEST);
00521                         
00522                         glPopMatrix();
00523                 }
00524         }
00525         else
00526         {
00527                 // PASS 1
00528                 ResourceManager::instance().use_program(0);
00529                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
00530                 
00531                 // LEFT
00532                 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, left_texture, 0);
00533                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
00534                 
00535                 for (size_t i = 0; i < cameras.size(); ++i)
00536                 {
00537                         cameras[i]->look_3d(-1.0f);
00538                         
00539                         reset_material();
00540                         
00541                         render_scene();
00542                         
00543                         glClear(GL_DEPTH_BUFFER_BIT);
00544                         
00545                         cameras[i]->look_2d();
00546                         glPushMatrix();
00547                         glTranslatef(0, 0, -1);
00548                         
00549                         guis[i]->render();
00550                         
00551                         glPopMatrix();
00552                 }
00553                 
00554                 // RIGHT
00555                 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, right_texture, 0);
00556                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
00557                 
00558                 for (size_t i = 0; i < cameras.size(); ++i)
00559                 {
00560                         cameras[i]->look_3d(1.0f);
00561                         
00562                         reset_material();
00563                         
00564                         render_scene();
00565                         
00566                         glClear(GL_DEPTH_BUFFER_BIT);
00567                         
00568                         cameras[i]->look_2d();
00569                         glPushMatrix();
00570                         glTranslatef(0, 0, -1);
00571                         
00572                         guis[i]->render();
00573                         
00574                         glPopMatrix();
00575                 }
00576                 
00577                 // PASS 2
00578                 ResourceManager::instance().use_program(GL_FRAGMENT_SHADER);
00579                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
00580                 
00581                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
00582                 glViewport(0, 0, size.x, size.y);
00583                 
00584                 glUniform1f(ResourceManager::instance().width_loc, size.x);
00585                 glUniform1f(ResourceManager::instance().height_loc, size.y);
00586                 
00587                 reset_material();
00588                 
00589                 ResourceManager::instance().render_fullscreen_quad();
00590         }
00591 }
00592 
00593 void Game::camera_mosaic(const sf::Vector2i& s)
00594 {
00595         switch (cameras.size())
00596         {
00597                 case 1:
00598                 {
00599                         cameras[0]->set_view(0, 0, s.x, s.y);
00600                 }
00601                 break;
00602                 case 2:
00603                 {
00604                         if (s.y > s.x)
00605                         {
00606                                 cameras[0]->set_view(0, s.y / 2, s.x, s.y / 2);
00607                                 cameras[1]->set_view(0, 0,     s.x, s.y / 2);
00608                         }
00609                         else
00610                         {
00611                                 cameras[0]->set_view(0,     0, s.x / 2, s.y);
00612                                 cameras[1]->set_view(s.x / 2, 0, s.x / 2, s.y);
00613                         }
00614                 }
00615                 break;
00616                 case 3:
00617                 {
00618                         std::vector< Kukac* > k;
00619                         for (size_t i = 0; i < players.size(); ++i)
00620                         {
00621                                 k.push_back(players[i]->kukac_ptr);
00622                         }
00623                         
00624                         cameras.push_back(new OverviewCamera(k));
00625                         guis.push_back(new SummaryGUI(players));
00626                 } // no break!
00627                 case 4:
00628                 {
00629                         cameras[0]->set_view(0,     s.y / 2, s.x / 2, s.y / 2);
00630                         cameras[1]->set_view(s.x / 2, s.y / 2, s.x / 2, s.y / 2);
00631                         cameras[2]->set_view(0,     0,     s.x / 2, s.y / 2);
00632                         cameras[3]->set_view(s.x / 2, 0,     s.x / 2, s.y / 2);
00633                 }
00634                 break;
00635                 case 5:
00636                 {
00637                         std::vector< Kukac* > k;
00638                         for (size_t i = 0; i < players.size(); ++i)
00639                         {
00640                                 k.push_back(players[i]->kukac_ptr);
00641                         }
00642                         
00643                         cameras.push_back(new OverviewCamera(k));
00644                         guis.push_back(new SummaryGUI(players));
00645                 } // no break!
00646                 case 6:
00647                 {
00648                         if (s.y > s.x)
00649                         {
00650                                 cameras[0]->set_view(0,     s.y / 3 * 2, s.x / 2, s.y / 3);
00651                                 cameras[1]->set_view(s.x / 2, s.y / 3 * 2, s.x / 2, s.y / 3);
00652                                 cameras[2]->set_view(0,     s.y / 3,     s.x / 2, s.y / 3);
00653                                 cameras[3]->set_view(s.x / 2, s.y / 3,     s.x / 2, s.y / 3);
00654                                 cameras[4]->set_view(0,     0,         s.x / 2, s.y / 3);
00655                                 cameras[5]->set_view(s.x / 2, 0,         s.x / 2, s.y / 3);
00656                         }
00657                         else
00658                         {
00659                                 cameras[0]->set_view(0,         s.y / 2, s.x / 3, s.y / 2);
00660                                 cameras[1]->set_view(s.x / 3,     s.y / 2, s.x / 3, s.y / 2);
00661                                 cameras[2]->set_view(s.x / 3 * 2, s.y / 2, s.x / 3, s.y / 2);
00662                                 cameras[3]->set_view(0,         0,     s.x / 3, s.y / 2);
00663                                 cameras[4]->set_view(s.x / 3,     0,     s.x / 3, s.y / 2);
00664                                 cameras[5]->set_view(s.x / 3 * 2, 0,     s.x / 3, s.y / 2);
00665                         }
00666                 }
00667                 break;
00668                 default:
00669                 {
00670                         
00671                 }
00672                 break;
00673         }
00674         
00675         for (size_t i = 0; i < cameras.size(); ++i)
00676         {
00677                 guis[i]->size = cameras[i]->size;
00678         }
00679 }
00680 
00681 void Game::render_scene()
00682 {
00683         /* // DEBUG
00684         for (unsigned int j = 0; j < cameras.size(); ++j) // DEBUG
00685         {
00686                 cameras[j]->render();
00687         }
00688         */
00689         
00690         
00691         for (unsigned int j = 0; j < players.size(); ++j)
00692         {
00693                 players[j]->kukac_ptr->render();
00694         }
00695         for (unsigned int j = 0; j < obstacles.size(); ++j)
00696         {
00697                 obstacles[j]->render();
00698         }
00699         for (unsigned int j = 0; j < edibles.size(); ++j)
00700         {
00701                 edibles[j]->render();
00702         }
00703         
00704         earthcube->render();
00705         
00706         if (ConfigManager::instance().get_bool("show_player_names"))
00707         {
00708                 FollowerCamera* cam_ptr = dynamic_cast< FollowerCamera* >(&Camera::get_current());
00709                 if (cam_ptr)
00710                 {
00711                         for (size_t i = 0; i < players.size(); ++i)
00712                         {
00713                                 if (players[i]->kukac_ptr != cam_ptr->kukac_ptr)
00714                                 {
00715                                         glPushMatrix();
00716                                         
00717                                         Kukac* k = players[i]->kukac_ptr;
00718                                         
00719                                         glTranslatef(
00720                                                 k->head->pos.x + k->get_ratio() * k->direction.x + cam_ptr->get_up().x,
00721                                                 k->head->pos.y + k->get_ratio() * k->direction.y + cam_ptr->get_up().y,
00722                                                 k->head->pos.z + k->get_ratio() * k->direction.z + cam_ptr->get_up().z
00723                                         );
00724                                         
00725                                         player_names[i]->render();
00726                                         glPopMatrix();
00727                                 }
00728                         }
00729                 }
00730                 else
00731                 {
00732                         for (size_t i = 0; i < players.size(); ++i)
00733                         {
00734                                 glPushMatrix();
00735                                 
00736                                 Kukac* k = players[i]->kukac_ptr;
00737                                 glTranslatef(
00738                                                 k->head->pos.x + k->get_ratio() * k->direction.x + Camera::get_current().get_up().x,
00739                                                 k->head->pos.y + k->get_ratio() * k->direction.y + Camera::get_current().get_up().y,
00740                                                 k->head->pos.z + k->get_ratio() * k->direction.z + Camera::get_current().get_up().z
00741                                         );
00742                                 
00743                                 
00744                                 player_names[i]->render();
00745                                 glPopMatrix();
00746                         }
00747                 }
00748         }
00749 }
00750 
00751 sf::Vector3i Game::get_random_empty_pos()
00752 {
00753         sf::Vector3i tmp;
00754         bool OK = false;
00755         
00756         while (!OK)
00757         {
00758                 OK = true;
00759                 
00760                 tmp.x = sf::Randomizer::Random(-20, 20);
00761                 tmp.y = sf::Randomizer::Random(-20, 20);
00762                 tmp.z = sf::Randomizer::Random(-20, 20);
00763                 
00764                 OK = (grid(tmp.x+20,tmp.y+20,tmp.z+20).type == GridCell::FREE);
00765                 
00766                 for (size_t i = 0; i < edibles.size(); ++i)
00767                 {
00768                         if (edibles[i]->pos == tmp)
00769                         {
00770                                 OK = false;
00771                         }
00772                 }
00773                 
00774                 for (unsigned int i = 0; i < obstacles.size(); ++i)
00775                 {
00776                         if ( (tmp.x >= obstacles[i]->pos.x) && (tmp.x < obstacles[i]->pos.x + obstacles[i]->size.x) &&
00777                                          (tmp.y >= obstacles[i]->pos.y) && (tmp.y < obstacles[i]->pos.y + obstacles[i]->size.y) &&
00778                                          (tmp.z >= obstacles[i]->pos.z) && (tmp.z < obstacles[i]->pos.z + obstacles[i]->size.z) )
00779                         {
00780                                 OK = false;
00781                         }
00782                 }
00783         }
00784         
00785         return tmp;
00786 }
00787 
00788 Game::~Game()
00789 {
00790         std::string render_3D = ConfigManager::instance().get_string("3D");
00791         
00792         if ((render_3D != "off") && (render_3D != ""))
00793         {
00794                 glDeleteFramebuffersEXT(1, &fbo);
00795                 glDeleteRenderbuffersEXT(1, &depth_buffer);
00796                 glDeleteTextures(1, &left_texture);
00797                 glDeleteTextures(1, &right_texture);
00798         }
00799         
00800         delete earthcube;
00801         
00802         size_t i;
00803         for (i = 0; i < players.size(); ++i)
00804         {
00805                 delete players[i];
00806         }
00807         for (i = 0; i < obstacles.size(); ++i)
00808         {
00809                 delete obstacles[i];
00810         }
00811         for (i = 0; i < edibles.size(); ++i)
00812         {
00813                 delete edibles[i];
00814         }
00815         for (i = 0; i < cameras.size(); ++i)
00816         {
00817                 delete cameras[i];
00818         }
00819         for (i = 0; i < guis.size(); ++i)
00820         {
00821                 delete guis[i];
00822         }
00823         for (i = 0; i < player_names.size(); ++i)
00824         {
00825                 delete player_names[i];
00826         }
00827         
00828         reset_material();
00829 }
 Összes Osztályok