src/core/Level.cpp

   1 // Copyright 2008 Brian Caine
   2
   3 // This file is part of Potpourri.
   4
   5 // Potpourri is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9
  10 // Potpourri is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTIBILITY of FITNESS FOR A PARTICULAR PURPOSE. See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with Potpourri. If not, see <http://www.gnu.org/licenses/>.
  17
  18
  19 // NOTES:
  20
  21 // The source for the level class.
  22
  23 #include <iostream>
  24 #include <string>
  25 #include <stdexcept>
  26 #include <algorithm>
  27
  28 #include "../../include/core/Level.h"
  29 #include "../../include/core/parselevel.h"
  30 #include "../../include/core/common.h"
  31
  32 using namespace fragrant;
  33
  34 LevelSlice LevelData::getSlice(std::string presentation)
  35 {
  36   LevelSlice results;
  37
  38   if (!presentation.size() ||
  39       (presentations.size() == 1 && !presentations.at(0).size()))
  40     results = slices[presentations.at(0)];
  41
  42   else
  43     {
  44       if (slices.find(presentation) == slices.end())
  45         throw std::runtime_error(
  46           ("LevelData::getSlice(): Level does not support "
  47            "presentation, \"" + presentation + "\"").c_str());
  48       results = slices[presentation];
  49     }
  50
  51   results.presentation = presentation;
  52   return results;
  53 }
  54
  55 std::string LevelData::toString()
  56 {
  57   std::string results;
  58
  59   results += "\tName: " + name + "\n";
  60   results += "\tPresentations: ";
  61
  62   int cur;
  63   for (cur = 0; cur < presentations.size(); cur++)
  64     if (presentations.at(cur).size())
  65       results += "\"" + presentations.at(cur) +
  66         std::string((cur < presentations.size() - 1) ? ("\", ") : ("\""));
  67
  68   if (presentations.size() == 1)
  69     results += "All";
  70
  71   results += "\n";
  72
  73   std::map<std::string, LevelSlice>::iterator iter;
  74   for (iter = slices.begin(); iter != slices.end(); iter++)
  75     {
  76       results += std::string("\tLevelSlice for \"") + iter->first +
  77         std::string("\"\n");
  78       results += std::string("\t* Startup: ") +
  79         std::string(iter->second.startup ? "True" : "False") +
  80         "\n";
  81       results += "\t* Rest of data truncated...\n";
  82     }
  83
  84   return results;
  85 }
  86
  87 Level::Level(LevelSlice data, Game& dgame)
  88   : level_data(data), presentation(data.presentation), game(dgame)
  89 {
  90   simulation = new PhysicsSimulation;
  91 }
  92
  93 Level::Level(LevelSlice data, Level& old_level, Game& dgame) : game(dgame)
  94 {
  95   throw std::runtime_error(std::string("Level::Level(LevelData, Level&): ")
  96                            + std::string("Not implemented yet"));
  97 }
  98
  99 Level::~Level()
 100 {
 101   int cur;
 102   for (cur = 0; cur < actors.size(); cur++)
 103     {
 104       delete actors.at(cur).actor;
 105
 106       std::vector<EventReceiver*>& target_vector =
 107         pipeline->getTargetVector();
 108       target_vector.erase(find(target_vector.begin(),
 109         target_vector.end(), actors.at(cur).actor));
 110     }
 111
 112   delete simulation;
 113
 114   actors.clear();
 115   static_graphics.clear();
 116 }
 117
 118 void Level::init(std::vector<ActorData> nactor_defs,
 119   EventPipeline* npipeline, Audio& naudio, ScriptVM* nscript_vm)
 120 {
 121   this->actor_defs = nactor_defs;
 122   this->pipeline = npipeline;
 123   this->audio = naudio;
 124   this->script_vm = nscript_vm;
 125
 126   viewport = level_data.viewport;
 127
 128   int cur;
 129   std::vector<LevelActor> actor_pos = level_data.actors;
 130   for (cur = 0; cur < actor_pos.size(); cur++)
 131     {
 132       int ncur;
 133       LevelActor temp_level_actor = actor_pos.at(cur);
 134       for (ncur = 0; ncur < actor_defs.size(); ncur++)
 135         if (actor_defs.at(ncur).name == temp_level_actor.source)
 136           {
 137             ActorData cur_data = actor_defs.at(ncur);
 138             cur_data.position = temp_level_actor.position;
 139             cur_data.simulation = simulation;
 140
 141             LActor ngraphic;
 142             ngraphic.zindex = temp_level_actor.zindex;
 143             ngraphic.actor = new Actor(cur_data);
 144             ngraphic.actor->setAngle(temp_level_actor.angle);
 145             npipeline->getTargetVector().push_back(
 146               dynamic_cast<EventReceiver*>(ngraphic.actor));
 147
 148             actors.push_back(ngraphic);
 149           }
 150     }
 151
 152   std::vector<LevelGraphic> level_graphics =
 153     level_data.static_graphics;
 154
 155   for (cur = 0; cur < level_graphics.size(); cur++)
 156     {
 157       std::map<std::string, Variant*> params;
 158       Drawable* drawable = game.getGraphics(
 159         level_graphics.at(cur).source, params);
 160
 161       StaticGraphic graphic;
 162       graphic.position = level_graphics.at(cur).position;
 163       graphic.drawable = drawable;
 164       graphic.zindex = level_graphics.at(cur).zindex;
 165       graphic.angle = level_graphics.at(cur).angle;
 166
 167       static_graphics.push_back(graphic);
 168     }
 169
 170   return;
 171 }
 172
 173 struct drawable_item  // throwaway struct for drawing
 174 {
 175   LActor actor;
 176   StaticGraphic graphic;
 177   float depth;
 178
 179   bool is_actor;
 180 };
 181
 182 void Level::cycle(Display* dest)
 183 {
 184   // do physics stuff
 185
 186   int cur = getticks();
 187   simulation->process(PROCESS_TIME, PROCESS_PIECE);
 188   int tickcount = PROCESS_TIME - (getticks() - cur);
 189   dosleep(tickcount > 0 ? tickcount : 0);
 190
 191   // do drawing stuff
 192
 193   std::multimap<float, drawable_item> drawable_items;
 194
 195   for (cur = 0; cur < static_graphics.size(); cur++)
 196     {
 197       drawable_item item;
 198       item.graphic = static_graphics.at(cur);
 199       item.is_actor = false;
 200       item.depth = item.graphic.zindex;
 201
 202       drawable_items.insert(
 203         std::pair<float, drawable_item>(item.depth, item));
 204     }
 205
 206   for (cur = 0; cur < actors.size(); cur++)
 207     {
 208       drawable_item item;
 209       item.actor = actors.at(cur);
 210       item.is_actor = true;
 211       item.depth = actors.at(cur).zindex;
 212
 213       drawable_items.insert(
 214         std::pair<float, drawable_item>(item.depth, item));
 215     }
 216
 217   std::multimap<float, drawable_item>::iterator iter;
 218   for (iter = drawable_items.begin(); iter != drawable_items.end(); iter++)
 219     {
 220       if (iter->second.is_actor)
 221         iter->second.actor.actor->draw(dest, viewport);
 222
 223       else
 224         {
 225           GraphicsRect src;
 226           src.xy.x = iter->second.graphic.position.x - viewport.x;
 227           src.xy.y = iter->second.graphic.position.y - viewport.y;
 228
 229           iter->second.graphic.drawable->draw(dest, &src,
 230             static_cast<GraphicsPair*>(0), iter->second.graphic.angle);
 231         }
 232     }
 233
 234   return;
 235 }
 236
 237 func Level::getConstructor() { return 0; }
 238 void Level::destroy() { return; }
 239
 240 std::string Level::getClassName() { return "Level"; }
 241
 242 std::vector<std::string> Level::getClassFunctions()
 243 {
 244   std::vector<std::string> results;
 245
 246   results.push_back("getViewport");
 247   results.push_back("setViewport");
 248
 249   results.push_back("getActorIndicesByName");
 250   results.push_back("getActor");
 251
 252   results.push_back("getActorZIndex");
 253   results.push_back("setActorZIndex");
 254
 255   results.push_back("deleteActor");
 256   results.push_back("makeActor");
 257
 258 //  results.push_back("");
 259
 260   return results;
 261 }
 262
 263 template<class TYPE>
 264 struct find_actordata : public std::unary_function<TYPE, void>
 265 {
 266   void operator() (TYPE& x)
 267     {
 268       if (x.name == to_find)
 269         *data = x;
 270     }
 271
 272   std::string to_find;
 273   ActorData* data;
 274   bool found;
 275 };
 276
 277 Variant* Level::callFunction(std::string funcname,
 278   std::vector<Variant*> params, ScriptVM* script_vm)
 279 {
 280   Variant* results = new Variant;
 281
 282   if (funcname == "getViewport")
 283     {
 284       std::vector<Variant*> viewport_data;
 285
 286       Variant* value = new Variant;
 287       *value = viewport.x;
 288       viewport_data.push_back(value);
 289
 290       value = new Variant;
 291       *value = viewport.x;
 292       viewport_data.push_back(value);
 293
 294       *results = viewport_data;
 295     }
 296
 297   if (funcname == "setViewport")
 298     {
 299       LevelPair nviewport = viewport;
 300
 301       try
 302         {
 303           nviewport.x = (params.at(0)->verifyType<float>() ?
 304                          params.at(0)->get<float>() :
 305                          params.at(0)->get<int>());
 306           nviewport.y = (params.at(1)->verifyType<float>() ?
 307                          params.at(1)->get<float>() :
 308                          params.at(1)->get<int>());
 309         }
 310
 311       catch (...)
 312         {
 313           std::cout
 314             << "Level::callFunction(funcname=\"setViewport\"): wrong params"
 315             << std::endl;
 316           return results;
 317         }
 318
 319       viewport = nviewport;
 320     }
 321
 322   if (funcname == "getActorIndicesByName")
 323     {
 324       if (params.size() < 1 || !params.at(0)->verifyType<std::string>())
 325         {
 326           std::cout
 327             << "Level::callFunction(funcname=\"getActorIndicesByName\"):"
 328                " wrong params"
 329             << std::endl;
 330           return results;
 331         }
 332
 333       std::vector<Variant*> nresults;
 334       std::string name = params.at(0)->get<std::string>();
 335
 336       int cur;
 337       for (cur = 0; cur < actors.size(); cur++)
 338         if (actors.at(cur).actor->getName() == name)
 339           {
 340             nresults.push_back(new Variant);
 341             *(nresults.at(nresults.size() - 1)) = cur;
 342           }
 343
 344       *results = nresults;
 345     }
 346
 347   if (funcname == "getActor")
 348     {
 349       if (params.size() < 1 || !params.at(0)->verifyType<int>())
 350         {
 351           std::cout
 352             << "Level::callFunction(funcname=\"getActor\"):"
 353                " wrong params"
 354             << std::endl;
 355           return results;
 356         }
 357
 358       int idx = params.at(0)->get<int>();
 359
 360       if (idx < 0 || idx >= actors.size())
 361         {
 362           std::cout
 363             << "Level::callFunction(funcname=\"getActor\"):"
 364                " invalid index"
 365             << std::endl;
 366           return results;
 367         }
 368
 369       *results = dynamic_cast<ScriptedClass*>(actors.at(idx).actor);
 370     }
 371
 372   if (funcname == "getActorZIndex")
 373     {
 374       if (params.size() < 1 || !params.at(0)->verifyType<int>())
 375         {
 376           std::cout
 377             << "Level::callFunction(funcname=\"getActorZIndex\"):"
 378                " wrong params"
 379             << std::endl;
 380           return results;
 381         }
 382
 383       int idx = params.at(0)->get<int>();
 384
 385       if (idx < 0 || idx >= actors.size())
 386         {
 387           std::cout
 388             << "Level::callFunction(funcname=\"getActorZIndex\"):"
 389                " invalid index"
 390             << std::endl;
 391           return results;
 392         }
 393
 394       *results = actors.at(idx).zindex;
 395     }
 396
 397   if (funcname == "setActorZIndex")
 398     {
 399       if (params.size() < 2 || !params.at(0)->verifyType<int>())
 400         {
 401           std::cout
 402             << "Level::callFunction(funcname=\"setActorZIndex\"):"
 403                " wrong params"
 404             << std::endl;
 405           return results;
 406         }
 407
 408       int idx = params.at(0)->get<int>();
 409       float nzindex;
 410
 411       try
 412         {
 413           nzindex = params.at(1)->verifyType<int>() ?
 414                     params.at(1)->get<int>():
 415                     params.at(1)->get<float>();
 416         }
 417
 418       catch(...)
 419         {
 420           std::cout
 421             << "Level::callFunction(funcname=\"setActorZIndex\"):"
 422                " wrong params"
 423             << std::endl;
 424           return results;
 425         }
 426
 427       if (idx < 0 || idx >= actors.size())
 428         {
 429           std::cout
 430             << "Level::callFunction(funcname=\"setActorZIndex\"):"
 431                " invalid index"
 432             << std::endl;
 433           return results;
 434         }
 435
 436       actors.at(idx).zindex = nzindex;
 437     }
 438
 439   if (funcname == "deleteActor")
 440     {
 441       if (params.size() < 1 || !params.at(0)->verifyType<int>())
 442         {
 443           std::cout
 444             << "Level::callFunction(funcname=\"deleteActor\"):"
 445                " wrong params"
 446             << std::endl;
 447           return results;
 448         }
 449
 450       int idx = params.at(0)->get<int>();
 451
 452       if (idx < 0 || idx >= actors.size())
 453         {
 454           std::cout
 455             << "Level::callFunction(funcname=\"deleteActor\"):"
 456                " invalid index"
 457             << std::endl;
 458           return results;
 459         }
 460
 461       delete actors.at(idx).actor;
 462       actors.erase(actors.begin() + idx);
 463     }
 464
 465   if (funcname == "makeActor")
 466     {
 467       if (params.size() < 2 ||
 468           !params.at(0)->verifyType<std::string>() ||
 469           !params.at(1)->verifyType<std::string>())
 470         {
 471           std::cout
 472             << "Level::callFunction(funcname=\"makeActor\"):"
 473                " wrong params"
 474             << std::endl;
 475           return results;
 476         }
 477
 478       std::string name = params.at(0)->get<std::string>();
 479       std::string source = params.at(0)->get<std::string>();
 480
 481       ActorData data;
 482
 483       find_actordata<ActorData> search;
 484       search.data = &data;
 485       search.to_find = source;
 486       search.found = false;
 487
 488       std::for_each(actor_defs.begin(), actor_defs.end(), search);
 489
 490       if (!search.found)
 491         {
 492           std::cout
 493             << "Level::callFunction(funcname=\"makeActor\"):"
 494                " failed to find source"
 495             << std::endl;
 496           *results = -1;
 497           return results;
 498         }
 499
 500       Actor* nactor = new Actor(data);
 501
 502       LActor ngraphic;
 503       ngraphic.actor = nactor;
 504       ngraphic.zindex = 0.0;
 505
 506       pipeline->getTargetVector().push_back(
 507         dynamic_cast<EventReceiver*>(ngraphic.actor));
 508       actors.push_back(ngraphic);
 509
 510       *results = actors.size() - 1;
 511     }
 512
 513   return results;
 514 }
 515
 516 LevelData Level::parseXML(std::string source, MediaLoader& media_loader)
 517 {
 518   return XMLParser::parselevel::parselevelFromBuffer(
 519     media_loader.loadMedia(source));
 520
 521   // lolwut
 522 }