Kukatz 3D  0.1
Török Attila szakdolgozata
projects/Kukatz 3D/src/newgamemenu.cpp
00001 /*
00002  * newgamemenu.cpp - Kukatz 3D
00003  * Copyright (c) 2011 - 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 "newgamemenu.hpp"
00026 
00027 #include <sstream>
00028 
00029 #include "statemanager.hpp"
00030 #include "game.hpp"
00031 #include "guiimage.hpp"
00032 #include "profilemanager.hpp"
00033 #include "configmanager.hpp"
00034 
00035 NewGameMenu::NewGameMenu(unsigned int w, unsigned int h):
00036         StateBase(w, h), selected(0), prev_selected(selected), viewport(w, h),
00037         left_start(0), right_side(false), prev_right_side(right_side)
00038 {
00039         resize(sf::Vector2i(w, h));
00040         
00041         gui.attach(new GUIImage("GROUND_2", 0.5f), 1, GUIElement::SCALE_MODE_BIGGER, 0.5f, 0.5f);
00042         
00043         GUIElementContainer* square = new GUIElementContainer(4.0f / 3.0f);
00044         gui.attach(square, 1.0f, GUIElement::SCALE_MODE_SMALLER, 0.5f, 0.5f);
00045         
00046         GUIString* str = new GUIString(L"Új játék", "#44");
00047         square->attach(str, 0.2, GUIString::SCALE_MODE_VERTICAL, 0.5, 1);
00048         
00049         
00050         std::vector< sf::Unicode::Text > opt;
00051         std::stringstream ss;
00052         
00053         for(unsigned int i = 1; i <= 10; ++i)
00054         {
00055                 ss.clear();
00056                 ss.str("");
00057                 ss << i * 50;
00058                 opt.push_back(ss.str());
00059         }
00060         
00061         edible_selector = new Selector(L"Csemegék száma:", opt,
00062                 ConfigManager::instance().get_unsigned_int("num_edibles"), false, 16.0f, 0.75f);
00063         square->attach(edible_selector, 0.8f, GUIElement::SCALE_MODE_HORIZONTAL, 0.5, 0.8);
00064         
00065         opt.clear();
00066         
00067         opt.push_back("Nincs");
00068         opt.push_back("Folytonos");
00069         opt.push_back("Dupla");
00070         opt.push_back("Tripla");
00071         
00072         supplies_selector = new Selector(L"Utánpótlás:", opt,
00073                 ConfigManager::instance().get_unsigned_int("supply_rate"), false, 16.0f, 0.75f);
00074         square->attach(supplies_selector, 0.8f, GUIElement::SCALE_MODE_HORIZONTAL, 0.5, 0.73);
00075         
00076         square->attach(new GUIString(L"Játékosok:", "#44"), 0.08f, GUIElement::SCALE_MODE_VERTICAL, 0.5f, 0.63f);
00077         
00078         const std::vector< Profile* > profiles = ProfileManager::instance().get_profiles();
00079         for (unsigned int i = 0; i < profiles.size(); ++i)
00080         {
00081                 available.push_back(profiles[i]);
00082         }
00083         
00084         left_list = new GUIElementContainer(1.0f);
00085         square->attach(left_list, 0.4f, GUIElement::SCALE_MODE_VERTICAL, 0.2f, 0.25);
00086         
00087         right_list = new GUIElementContainer(1.0f);
00088         square->attach(right_list, 0.4f, GUIElement::SCALE_MODE_VERTICAL, 0.8f, 0.25f);
00089         
00090         
00091         up_arrow = new GUIImage("UP_ARROW", 1.0f);
00092         down_arrow = new GUIImage("DOWN_ARROW", 1.0f);
00093         
00094         left_list->attach(up_arrow, 1.0f / 6.0f, GUIElement::SCALE_MODE_VERTICAL, -1.0f / 3.0f, 1.0f);
00095         left_list->attach(down_arrow, 1.0f / 6.0f, GUIElement::SCALE_MODE_VERTICAL, -1.0f / 3.0f, 0.0f);
00096         
00097         start_label = new GUIString(L"Játék indítása", "#44");
00098         square->attach(start_label, 0.1f, GUIElement::SCALE_MODE_VERTICAL, 0.5f, 0.04f);
00099         
00100         if (available.empty())
00101         {
00102                 GUIString* str = new GUIString(L"Nincsenek játékosok", "#44");
00103                 str->set_color(255, 0, 0);
00104                 square->attach(str, 0.1f,
00105                         GUIElement::SCALE_MODE_VERTICAL, 0.5, 0.4);
00106         }
00107         
00108         square->attach(new GUIString(L"Elérhetőek:", "#44"), 0.05f,
00109                 GUIElement::SCALE_MODE_VERTICAL, 0.25f, 0.57f);
00110         square->attach(new GUIString(L"Kiválasztottak:", "#44"), 0.05f,
00111                 GUIElement::SCALE_MODE_VERTICAL, 0.8f, 0.57f);
00112         
00113         set_arrays();
00114         set_color();
00115 }
00116 
00117 void NewGameMenu::set_color()
00118 {
00119         switch (prev_selected)
00120         {
00121                 case 0:
00122                 {
00123                         edible_selector->set_color(255, 255, 255);
00124                 }
00125                 break;
00126                 case 1:
00127                 {
00128                         supplies_selector->set_color(255, 255, 255);
00129                 }
00130                 break;
00131                 case 8:
00132                 {
00133                         start_label->set_color(255, 255, 255);
00134                 }
00135                 break;
00136                 default:
00137                 {
00138                         if (prev_right_side)
00139                         {
00140                                 if (right_list->children.size() > ((prev_selected - 2) * 2))
00141                                 {
00142                                         GUIString* str_ptr = dynamic_cast< GUIString* >(right_list->children[(prev_selected - 2) * 2]);
00143                                         if (str_ptr)
00144                                         {
00145                                                 str_ptr->set_color(255, 255, 255);
00146                                         }
00147                                 }
00148                         }
00149                         else
00150                         {
00151                                 if ((left_list->children.size() - 2) > ((prev_selected - 2) * 2))
00152                                 {
00153                                         GUIString* str_ptr = dynamic_cast< GUIString* >(left_list->children[2 + (prev_selected - 2) * 2]);
00154                                         if (str_ptr)
00155                                         {
00156                                                 str_ptr->set_color(255, 255, 255);
00157                                         }
00158                                 }
00159                         }
00160                 }
00161                 break;
00162         }
00163         
00164         switch (selected)
00165         {
00166                 case 0:
00167                 {
00168                         edible_selector->set_color(255, 0, 0);
00169                 }
00170                 break;
00171                 case 1:
00172                 {
00173                         supplies_selector->set_color(255, 0, 0);
00174                 }
00175                 break;
00176                 case 8:
00177                 {
00178                         start_label->set_color(255, 0, 0);
00179                 }
00180                 break;
00181                 default:
00182                 {
00183                         if (right_side)
00184                         {
00185                                 {
00186                                         GUIString* str_ptr = dynamic_cast< GUIString* >(right_list->children[(selected - 2) * 2]);
00187                                         if (str_ptr)
00188                                         {
00189                                                 str_ptr->set_color(255, 0, 0);
00190                                         }
00191                                 }
00192                         }
00193                         else
00194                         {
00195                                 if (left_list->children.size() > (2 + (selected - 2) * 2))
00196                                 {
00197                                         GUIString* str_ptr = dynamic_cast< GUIString* >(left_list->children[2 + (selected - 2) * 2]);
00198                                         if (str_ptr)
00199                                         {
00200                                                 str_ptr->set_color(255, 0, 0);
00201                                         }
00202                                 }
00203                         }
00204                 }
00205                 break;
00206         }
00207         
00208         prev_selected = selected;
00209         prev_right_side = right_side;
00210 }
00211 
00212 void NewGameMenu::set_arrays()
00213 {
00214         for (unsigned int i = 2; i < left_list->children.size(); ++i)
00215         {
00216                 delete left_list->children[i];
00217         }
00218         left_list->children.resize(2);
00219         
00220         for (unsigned int i = 0; i < right_list->children.size(); ++i)
00221         {
00222                 delete right_list->children[i];
00223         }
00224         right_list->children.clear();
00225         
00226         for (unsigned int i = left_start; (i < available.size()) && (i < left_start + 6); ++i)
00227         {
00228                 left_list->attach(new GUIString(available[i]->name, "#44"),
00229                         1.0f / 6.0f, GUIElement::SCALE_MODE_VERTICAL, 0.0f, 1.0f - (float)(i - left_start) / 5.0f);
00230                 
00231                 left_list->attach(new GUIImage(available[i]->is_human?"PERSON":"CIRCUIT"),
00232                         1.0f / 6.0f, GUIElement::SCALE_MODE_VERTICAL, -0.18f /* HACK xD */, 1.0f - (float)(i - left_start) / 5.0f);
00233         }
00234         
00235         up_arrow->visible = (left_start > 0);
00236         down_arrow->visible = ((available.size() > 6) && (left_start < (available.size() - 6)));
00237         
00238         for (unsigned int i = 0; i < added.size(); ++i)
00239         {
00240                 right_list->attach(new GUIString(added[i]->name, "#44"),
00241                         1.0f / 6.0f, GUIElement::SCALE_MODE_VERTICAL, 0.0f, 1.0f - (float)i / 5.0f);
00242                 
00243                 right_list->attach(new GUIImage(added[i]->is_human?"PERSON":"CIRCUIT"),
00244                         1.0f / 6.0f, GUIElement::SCALE_MODE_VERTICAL, -0.18 /* HACK xD */, 1.0f - (float)i / 5.0f);
00245         }
00246 }
00247 
00248 void NewGameMenu::set_selected(bool up)
00249 {
00250         if (selected > 8)
00251         {
00252                 selected = 0;
00253         }
00254         
00255         if (added.empty())
00256         {
00257                 right_side = false;
00258         }
00259         
00260         if (available.empty())
00261         {
00262                 right_side = true;
00263         }
00264         
00265         while ((selected >= 2) && (selected <= 7) &&
00266                 (((right_side?right_list->children.size():(left_list->children.size() - 3))) <= ((selected - 2) * 2)))
00267         {
00268                 selected += (up?1:-1);
00269         }
00270         
00271         while (left_start > (available.size() - 6))
00272         {
00273                 --left_start;
00274         }
00275         
00276         if ((selected >= 2) && (selected <= 7))
00277         {
00278                 if (right_side)
00279                 {
00280                         if ((selected - 2) >= added.size())
00281                         {
00282                                 selected = added.size() + 1;
00283                         }
00284                 }
00285                 else
00286                 {
00287                         if ((selected - 2) >= available.size())
00288                         {
00289                                 selected = available.size() + 1;
00290                         }
00291                 }
00292         }
00293 }
00294 
00295 void NewGameMenu::process_events(std::vector< sf::Event >& e)
00296 {
00297         for(size_t i = 0; i < e.size(); ++i)
00298         {
00299                 switch (e[i].Type)
00300                 {
00301                         case sf::Event::KeyPressed:
00302                         {
00303                                 switch(e[i].Key.Code)
00304                                 {
00305                                         case sf::Key::Escape:
00306                                         {
00307                                                 pop();
00308                                         }
00309                                         break;
00310                                         case sf::Key::Down:
00311                                         {
00312                                                 if (right_side)
00313                                                 {
00314                                                         ++selected;
00315                                                 }
00316                                                 else
00317                                                 {
00318                                                         if ((selected == 7) && (left_start < available.size() - 6))
00319                                                         {
00320                                                                 ++left_start;
00321                                                         }
00322                                                         else
00323                                                         {
00324                                                                 ++selected;
00325                                                         }
00326                                                 }
00327                                                 
00328                                                 set_selected(true);
00329                                                 set_arrays();
00330                                                 set_color();
00331                                         }
00332                                         break;
00333                                         case sf::Key::Up:
00334                                         {
00335                                                 if (selected == 0)
00336                                                 {
00337                                                         selected = 8;
00338                                                 }
00339                                                 else
00340                                                 {
00341                                                         if (right_side)
00342                                                         {
00343                                                                 --selected;
00344                                                         }
00345                                                         else
00346                                                         {
00347                                                                 if ((selected == 2) && (left_start > 0))
00348                                                                 {
00349                                                                         --left_start;
00350                                                                 }
00351                                                                 else
00352                                                                 {
00353                                                                         --selected;
00354                                                                 }
00355                                                         }
00356                                                 }
00357                                                 
00358                                                 set_selected(false);
00359                                                 set_arrays();
00360                                                 set_color();
00361                                         }
00362                                         break;
00363                                         case sf::Key::Left:
00364                                         {
00365                                                 switch (selected)
00366                                                 {
00367                                                         case 0:
00368                                                         {
00369                                                                 edible_selector->prev();
00370                                                         }
00371                                                         break;
00372                                                         case 1:
00373                                                         {
00374                                                                 supplies_selector->prev();
00375                                                         }
00376                                                         break;
00377                                                         default:
00378                                                         {
00379                                                                 right_side = false;
00380                                                                 set_selected(true);
00381                                                                 set_color();
00382                                                         }
00383                                                         break;
00384                                                 }
00385                                         }
00386                                         break;
00387                                         case sf::Key::Right:
00388                                         {
00389                                                 switch (selected)
00390                                                 {
00391                                                         case 0:
00392                                                         {
00393                                                                 edible_selector->next();
00394                                                         }
00395                                                         break;
00396                                                         case 1:
00397                                                         {
00398                                                                 supplies_selector->next();
00399                                                         }
00400                                                         break;
00401                                                         default:
00402                                                         {
00403                                                                 right_side = true;
00404                                                                 set_selected(true);
00405                                                                 set_color();
00406                                                         }
00407                                                         break;
00408                                                 }
00409                                         }
00410                                         break;
00411                                         case sf::Key::Return:
00412                                         {
00413                                                 switch (selected)
00414                                                 {
00415                                                         case 8:
00416                                                         {
00417                                                                 if (!added.empty())
00418                                                                 {
00419                                                                         StateManager::instance().push_state(new Game(size.x, size.y,
00420                                                                                 added,
00421                                                                                 edible_selector->get_option() * 50 + 50,
00422                                                                                 supplies_selector->get_option()));
00423                                                                         
00424                                                                         ConfigManager::instance().set("num_edibles", edible_selector->get_option());
00425                                                                         ConfigManager::instance().set("supply_rate", supplies_selector->get_option());
00426                                                                         ConfigManager::instance().save();
00427                                                                         
00428                                                                         pop();
00429                                                                 }
00430                                                         }
00431                                                         break;
00432                                                         default:
00433                                                         {
00434                                                                 if ((selected >= 2) && (selected <= 7))
00435                                                                 {
00436                                                                         set_selected(true);
00437                                                                         
00438                                                                         if (right_side)
00439                                                                         {
00440                                                                                 Profile* add_this_back = added[selected - 2];
00441                                                                                 if (available.empty())
00442                                                                                 {
00443                                                                                         available.push_back(add_this_back);
00444                                                                                 }
00445                                                                                 else
00446                                                                                 {
00447                                                                                         int index_will_be = 0;
00448                                                                                         while (available[index_will_be]->id < add_this_back->id)
00449                                                                                         {
00450                                                                                                 ++index_will_be;
00451                                                                                         }
00452                                                                                         available.push_back(0);
00453                                                                                         for (int i = available.size() - 1; i > index_will_be; --i)
00454                                                                                         {
00455                                                                                                 available[i] = available[i - 1];
00456                                                                                         }
00457                                                                                         available[index_will_be] = add_this_back;
00458                                                                                 }
00459                                                                                 
00460                                                                                 for (unsigned int i = selected - 2; i < added.size() - 1; ++i)
00461                                                                                 {
00462                                                                                         added[i] = added[i + 1];
00463                                                                                 }
00464                                                                                 added.pop_back();
00465                                                                         }
00466                                                                         else
00467                                                                         {
00468                                                                                 if (added.size() < 6)
00469                                                                                 {
00470                                                                                         added.push_back(available[selected - 2 + left_start]);
00471                                                                                         for (unsigned int i = selected - 2 + left_start; i < available.size() - 1; ++i)
00472                                                                                         {
00473                                                                                                 available[i] = available[i + 1];
00474                                                                                         }
00475                                                                                         available.pop_back();
00476                                                                                 }
00477                                                                         }
00478                                                                         
00479                                                                         set_selected(true);
00480                                                                         set_arrays();
00481                                                                         set_color();
00482                                                                 }
00483                                                         }
00484                                                         break;
00485                                                 }
00486                                         }
00487                                         break;
00488                                         default:
00489                                         {
00490                                                 
00491                                         }
00492                                         break;
00493                                 }
00494                         }
00495                         break;
00496                         default:
00497                         {
00498                                 
00499                         }
00500                         break;
00501                 }
00502         }
00503 }
00504 
00505 void NewGameMenu::update(float)
00506 {
00507         
00508 }
00509 
00510 void NewGameMenu::resize(const sf::Vector2i& s)
00511 {
00512         viewport.size = s;
00513         gui.size = s;
00514         size = s;
00515 }
00516 
00517 void NewGameMenu::render()
00518 {
00519         viewport.look_2d();
00520         gui.render();
00521 }
00522 
00523 NewGameMenu::~NewGameMenu()
00524 {
00525         
00526 }
 Összes Osztályok