src/defparse/defaction.cc

   1 /*
   2 * This file implements general functions and classes
   3 * from the defaction.hh header
   4 *
   5 * Copyright (C) 2008 Hermann Walth
   6 *
   7 * This file is part of OpenStranded
   8 *
   9 * OpenStranded is free software; you can redistribute it and/or modify
  10 * it under the terms of the GNU General Public License as published by
  11 * the Free Software Foundation, either version 3 of the License, or
  12 * (at your option) any later version.
  13 *
  14 * OpenStranded is distributed in the hope that it will be useful,
  15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 * GNU General Public License for more details.
  18 *
  19 * You should have received a copy of the GNU General Public License
  20 * along with OpenStranded. If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include <iostream>
  24 #include <string>
  25 #include <sstream>
  26 #include <cstring>
  27 #include "../filesystem.hh"
  28 #include "../output.hh"
  29 #include "../s2string.hh"
  30 #include "../kingdom.hh"
  31 #include "../error.hh"
  32 #include "defaction.hh"
  33
  34 ID currentType = 0;
  35
  36 /*
  37  * Action List methods
  38  */
  39
  40 def::ActionList::ActionList ():
  41 std::map <std::string, def::Action*> () {}
  42
  43
  44 // Destructor, deletes all list's elements
  45 def::ActionList::~ActionList ()
  46 {
  47         std::map <std::string, def::Action*>::iterator iter;
  48         for (iter = this->begin (); iter != this->end (); iter++)
  49                 delete (iter->second);
  50 }
  51
  52 // Wrapper operator[] method for const char* strings
  53 def::Action*&
  54 def::ActionList::listItem (const char* index)
  55 {
  56         return (*this) [std::string (index)];
  57         //return (this->find (std::string (index)))->second;
  58 }
  59
  60
  61 /*
  62  * Action classes method definitions
  63  */
  64
  65 def::Action::Action (ID kingdom)
  66 {
  67         this->kingdomID = kingdom;
  68         this->lastType = 0;
  69 }
  70
  71
  72 def::IDAction::IDAction (ID kingdom):
  73 Action (kingdom) {}
  74
  75 def::NameAction::NameAction (ID kingdom):
  76 Action (kingdom) {}
  77
  78 def::ModelAction::ModelAction (ID kingdom):
  79 Action (kingdom) {}
  80
  81 def::IconAction::IconAction (ID kingdom):
  82 Action (kingdom) {}
  83
  84 def::XAction::XAction (ID kingdom):
  85 Action (kingdom) {}
  86
  87 def::YAction::YAction (ID kingdom):
  88 Action (kingdom) {}
  89
  90 def::ZAction::ZAction (ID kingdom):
  91 Action (kingdom) {}
  92
  93 def::ScaleAction::ScaleAction (ID kingdom):
  94 Action (kingdom) {}
  95
  96 def::RAction::RAction (ID kingdom):
  97 Action (kingdom) {}
  98
  99 def::GAction::GAction (ID kingdom):
 100 Action (kingdom) {}
 101
 102 def::BAction::BAction (ID kingdom):
 103 Action (kingdom) {}
 104
 105 def::ColorAction::ColorAction (ID kingdom):
 106 Action (kingdom) {}
 107
 108 def::AutofadeAction::AutofadeAction (ID kingdom):
 109 Action (kingdom) {}
 110
 111 def::AlphaAction::AlphaAction (ID kingdom):
 112 Action (kingdom) {}
 113
 114 def::ShineAction::ShineAction (ID kingdom):
 115 Action (kingdom) {}
 116
 117
 118
 119 void
 120 def::IDAction::operator() (std::string rtext)
 121 {
 122         ID newID;
 123         std::istringstream (rtext, std::ios::in) >> newID;
 124
 125         currentType = newID;
 126
 127         if (Kingdom::kingdomList.find (kingdomID) != Kingdom::kingdomList.end ())
 128         {
 129                 if (!Kingdom::kingdomList[kingdomID]->typeExists(newID))
 130                         Kingdom::kingdomList[kingdomID]->insertType (newID);
 131                 else
 132                 {
 133                         Out::fatal << "Type #" << newID << " has already been declared!" << Out::endl;
 134                 }
 135         }
 136         else
 137         {
 138                 Out::fatal << "Kingdom does not exist!" << Out::endl;
 139         }
 140 }
 141
 142
 143
 144 void
 145 def::NameAction::operator() (std::string rtext)
 146 {
 147         if (currentType == 0)
 148         {
 149                 Out::warning << "No type ID specified, assignment of value \"name\" not possible" << Out::endl;
 150                 return;
 151         }
 152
 153         if (this->lastType != currentType)
 154                 Kingdom::kingdomList[kingdomID]->getType (currentType) ->setName (rtext);
 155         else
 156                 Out::warning << "Double assignment of value \"name\" in object type #" << currentType << Out::endl;
 157 }
 158
 159
 160
 161 void
 162 def::ModelAction::operator() (std::string rtext)
 163 {
 164         if (currentType == 0)
 165         {
 166                 Out::warning << "No type ID specified, assignment of value \"model\" not possible" << Out::endl;
 167                 return;
 168         }
 169
 170         // Spot legacy file paths, transform and give a deprecation warning
 171         // Since Stranded II had all files given relative to the mod directory,
 172         // we use the "gfx\" piece to spot legacy file paths
 173         std::string::size_type pos;
 174         if((pos = rtext.find("gfx\\")) != std::string::npos)
 175         {
 176                 Out::warning << "Deprecated model file path format in type # " << currentType << Out::endl;
 177
 178                 // Remove old directory part
 179                 rtext = rtext.substr(pos+4);
 180
 181                 // Remove file extension
 182                 pos = rtext.find_last_of('.');
 183                 rtext = rtext.substr(0, pos);
 184         }
 185
 186         // Remove backslashes
 187         for (unsigned int i = 0; i < rtext.size(); i++)
 188                 if (rtext[i] == '\\') rtext[i] = '/';
 189
 190         if (this->lastType != currentType)
 191         {
 192                 FileInfo *modelInfo = FileSystem::getModelFileInfo(rtext);
 193                 Kingdom::kingdomList[kingdomID]->getType (currentType)->setModel (modelInfo->path);
 194                 delete modelInfo;
 195         }
 196         else
 197         {
 198                 Out::warning << "Double assignment of value \"model\" in type #" << currentType << Out::endl;
 199         }
 200
 201 }
 202
 203
 204
 205 void
 206 def::IconAction::operator() (std::string rtext)
 207 {
 208         if (currentType == 0)
 209                 Out::warning << "No type ID specified, assignment of value \"icon\" not possible" << Out::endl;
 210
 211         if (this->lastType != currentType)
 212                  Kingdom::kingdomList[kingdomID]->getType (currentType) ->setIconPath (rtext);
 213         else
 214                 Out::warning << "Double assignment of value \"icon\" in type #" << currentType << Out::endl;
 215 }
 216
 217
 218
 219 void
 220 def::XAction::operator() (std::string rtext)
 221 {
 222         float newScaleX;
 223         std::istringstream (rtext) >> newScaleX;
 224
 225         if (currentType == 0)
 226         {
 227                 Out::warning << "No type ID specified, assignment of value \"x\" not possible" << Out::endl;
 228                 return;
 229         }
 230
 231         if (newScaleX <= 0)
 232         {
 233                 Out::warning << "Invalid value \"x\"; fallback to 1.0 in type #" << currentType << Out::endl;
 234                 newScaleX = 1.0;
 235         }
 236
 237         if (this->lastType != currentType)
 238                  Kingdom::kingdomList[kingdomID]->getType (currentType) ->setScaleX (newScaleX);
 239         else
 240                 Out::warning << "Double assignment of value \"x\" in type #" << currentType << Out::endl;
 241 }
 242
 243
 244
 245 void
 246 def::YAction::operator() (std::string rtext)
 247 {
 248         float newScaleY;
 249         std::istringstream (rtext) >> newScaleY;
 250
 251         if (currentType == 0)
 252         {
 253                 Out::warning << "No type ID specified, assignment of value \"y\" not possible" << Out::endl;
 254                 return;
 255         }
 256
 257         if (newScaleY <= 0)
 258         {
 259                 Out::warning << "Invalid value \"y\"; fallback to 1.0 in  type #" << currentType << Out::endl;
 260                 newScaleY = 1.0;
 261         }
 262
 263         if (this->lastType != currentType)
 264                 Kingdom::kingdomList[kingdomID]->getType (currentType) ->setScaleY (newScaleY);
 265         else
 266                 Out::warning << "Double assignment of value \"y\" in Object type #" << currentType << Out::endl;
 267 }
 268
 269
 270
 271 void
 272 def::ZAction::operator() (std::string rtext)
 273 {
 274         float newScaleZ;
 275         std::istringstream (rtext) >> newScaleZ;
 276
 277         if (currentType == 0)
 278         {
 279                 Out::warning << "No type ID specified, assignment of value \"z\" not possible" << Out::endl;
 280                 return;
 281         }
 282
 283         if (newScaleZ <= 0)
 284         {
 285                 Out::warning << "Invalid value \"z\"; fallback to 1.0 in type #" << currentType << Out::endl;
 286                 newScaleZ = 1.0;
 287         }
 288
 289         if (this->lastType != currentType)
 290                  Kingdom::kingdomList[kingdomID]->getType (currentType) ->setScaleZ (newScaleZ);
 291         else
 292                 Out::warning << "Double assignment of value \"z\" in type #" << currentType << Out::endl;
 293 }
 294
 295
 296
 297 void
 298 def::ScaleAction::operator() (std::string rtext)
 299 {
 300         std::string scaleValues[3];
 301         int warnFlag;
 302         float endValue;
 303
 304
 305         if (currentType == 0)
 306         {
 307                 Out::warning << "No type ID specified, assignment of value \"scale\" not possible" << Out::endl;
 308                 return;
 309         }
 310
 311         warnFlag = s2str::explode (rtext, scaleValues, ",", 3);
 312
 313         // Display error message when number of arguments wasn't either 1 or 3
 314         if (warnFlag != EXPLODE_OK && !inFlag (warnFlag, EXPLODE_NO_TOKEN))
 315         {
 316                 Out::warning << "Warning: Wrong number of arguments for value \"scale\"" << Out::endl;
 317         }
 318
 319
 320         if (this->lastType != currentType)
 321         {
 322                 // Catch special case when only one value was given and needs to be applied
 323                 // to all x, y and z
 324                 if (inFlag (warnFlag, EXPLODE_NO_TOKEN))
 325                 {
 326                         if (!s2str::stof (scaleValues[0], endValue))
 327                         {
 328                                 Out::warning << "Invalid value in \"scale\"; fallback to 1.0 in type #" << currentType << Out::endl;
 329                                 endValue = 1.0;
 330                         }
 331                         Kingdom::kingdomList[kingdomID]->getType (currentType) ->setScaleX (endValue);
 332                         Kingdom::kingdomList[kingdomID]->getType (currentType) ->setScaleY (endValue);
 333                         Kingdom::kingdomList[kingdomID]->getType (currentType) ->setScaleZ (endValue);
 334                         return;
 335                 }
 336
 337                 // scaleX
 338                 if (!s2str::stof (scaleValues[0], endValue))
 339                 {
 340                         Out::warning << "Invalid x value in \"scale\"; fallback to 1.0 in type #" << currentType << Out::endl;
 341                         endValue = 1.0;
 342                 }
 343                 Kingdom::kingdomList[kingdomID]->getType (currentType) ->setScaleX (endValue);
 344
 345
 346                 // scaleY
 347                 if (!s2str::stof (scaleValues[1], endValue))
 348                 {
 349                         Out::warning << "Invalid y value in \"scale\"; fallback to 1.0 in type #" << currentType << Out::endl;
 350                         endValue = 1.0;
 351                 }
 352                 Kingdom::kingdomList[kingdomID]->getType (currentType) ->setScaleY (endValue);
 353
 354
 355
 356                 // scaleZ
 357                 if (!s2str::stof (scaleValues[2], endValue))
 358                 {
 359                         Out::warning << "Invalid z value in \"scale\"; fallback to 1.0 in type #" << currentType << Out::endl;
 360                         endValue = 1.0;
 361                 }
 362                 Kingdom::kingdomList[kingdomID]->getType (currentType) ->setScaleZ (endValue);
 363         }
 364         else
 365         {
 366                 Out::warning << "Double assignment of value \"scale\" in type #" << currentType << Out::endl;
 367         }
 368 }
 369
 370
 371
 372 void
 373 def::RAction::operator() (std::string rtext)
 374 {
 375         int newColorR;
 376         bool strValid;
 377
 378         if (currentType == 0)
 379         {
 380                 Out::warning << "No type ID specified, assignment of value \"r\" not possible" << Out::endl;
 381                 return;
 382         }
 383
 384         strValid = s2str::stoi (rtext, newColorR);
 385         if (!strValid || newColorR < 0 || newColorR > 255)
 386         {
 387                 Out::warning << "Invalid argument for \"r\" value in type #" << currentType << ", fallback to 0" << Out::endl;
 388                 newColorR = 0;
 389         }
 390
 391         if (this->lastType != currentType)
 392                  Kingdom::kingdomList[kingdomID]->getType (currentType) ->setColorR ( (uint8_t) newColorR);
 393         else
 394                 Out::warning << "Double assignment of value \"r\" in type #" << currentType << Out::endl;
 395 }
 396
 397
 398
 399 void
 400 def::GAction::operator() (std::string rtext)
 401 {
 402         int newColorG;
 403         bool strValid;
 404
 405         if (currentType == 0)
 406         {
 407                 Out::warning << "No type ID specified, assignment of value \"g\" not possible" << Out::endl;
 408                 return;
 409         }
 410
 411         strValid = s2str::stoi (rtext, newColorG);
 412         if (!strValid || newColorG < 0 || newColorG > 255)
 413         {
 414                 Out::warning << "Invalid argument for \"g\" value in type #" << currentType << ", fallback to 0" << Out::endl;
 415                 newColorG = 0;
 416         }
 417
 418         if (this->lastType != currentType)
 419                  Kingdom::kingdomList[kingdomID]->getType (currentType) ->setColorG ( (uint8_t) newColorG);
 420         else
 421                 Out::warning << "Double assignment of value \"g\" in type #" << currentType << Out::endl;
 422 }
 423
 424
 425
 426 void
 427 def::BAction::operator() (std::string rtext)
 428 {
 429         int newColorB;
 430         bool strValid;
 431
 432         if (currentType == 0)
 433         {
 434                 Out::warning << "No type ID specified, assignment of value \"b\" not possible" << Out::endl;
 435                 return;
 436         }
 437
 438         strValid = s2str::stoi (rtext, newColorB);
 439         if (!strValid || newColorB < 0 || newColorB > 255)
 440         {
 441                 Out::warning << "Invalid argument for \"b\" value in type #" << currentType << ", fallback to 0" << Out::endl;
 442                 newColorB = 0;
 443         }
 444
 445         if (this->lastType != currentType)
 446                  Kingdom::kingdomList[kingdomID]->getType (currentType) ->setColorB ( (uint8_t) newColorB);
 447         else
 448                 Out::warning << "Double assignment of value \"b\" in type #" << currentType << Out::endl;
 449 }
 450
 451
 452
 453 void
 454 def::ColorAction::operator() (std::string rtext)
 455 {
 456         std::string colorValues[3];
 457         int endValue;
 458         int warnFlag;
 459         bool strValid;
 460
 461         if (currentType == 0)
 462         {
 463                 Out::warning << "No type ID specified, assignment of value \"color\" not possible" << Out::endl;
 464                 return;
 465         }
 466
 467         warnFlag = s2str::explode (rtext, colorValues, ",", 3);
 468
 469         // Display error message when number of arguments wasn't either 1 or 3
 470         if (warnFlag != EXPLODE_OK && !inFlag (warnFlag, EXPLODE_NO_TOKEN))
 471         {
 472                 Out::warning << "Warning: Wrong number of arguments for value \"color\"" << Out::endl;
 473         }
 474
 475         if (this->lastType != currentType)
 476         {
 477                 // Catch special case when only one value was given and needs to be applied
 478                 // to all r, g and b
 479                 if (inFlag (warnFlag, EXPLODE_NO_TOKEN))
 480                 {
 481                         strValid = s2str::stoi (colorValues[0], endValue);
 482                         if (!strValid || endValue < 0 || endValue > 255)
 483                         {
 484                                 Out::warning << "Invalid value in \"color\"; fallback to 0.0 in type #" << currentType << Out::endl;
 485                                 endValue = 0;
 486                         }
 487                         Kingdom::kingdomList[kingdomID]->getType (currentType) ->setColorR (endValue);
 488                         Kingdom::kingdomList[kingdomID]->getType (currentType) ->setColorG (endValue);
 489                         Kingdom::kingdomList[kingdomID]->getType (currentType) ->setColorB (endValue);
 490                         return;
 491                 }
 492
 493                 // R
 494                 strValid = s2str::stoi (colorValues[0], endValue);
 495                 if (!strValid || endValue < 0 || endValue > 255)
 496                 {
 497                         Out::warning << "Invalid argument for \"r\" value in \"color\" in type #" << currentType << ", fallback to 0" << Out::endl;
 498                         endValue = 0;
 499                 }
 500
 501                 Kingdom::kingdomList[kingdomID]->getType (currentType) ->setColorR ( (uint8_t) endValue);
 502
 503
 504                 // G
 505                 strValid = s2str::stoi (colorValues[1], endValue);
 506                 if (!strValid || endValue < 0 || endValue > 255)
 507                 {
 508                         Out::warning << "Invalid argument for \"g\" value in \"color\" in type #" << currentType << ", fallback to 0" << Out::endl;
 509                         endValue = 0;
 510                 }
 511
 512                 Kingdom::kingdomList[kingdomID]->getType (currentType) ->setColorG ( (uint8_t) endValue);
 513
 514
 515                 // B
 516                 strValid = s2str::stoi (colorValues[2], endValue);
 517                 if (!strValid || endValue > 255)
 518                 {
 519                         Out::warning << "Invalid argument for \"b\" value in \"color\" in type #" << currentType << ", fallback to 0" << Out::endl;
 520                         endValue = 0;
 521                 }
 522
 523                 Kingdom::kingdomList[kingdomID]->getType (currentType) ->setColorB ( (uint8_t) endValue);
 524
 525         }
 526         else
 527         {
 528                 Out::warning << "Double assignment of value \"color\" in type #" << currentType << Out::endl;
 529         }
 530 }
 531
 532
 533
 534 void
 535 def::AutofadeAction::operator() (std::string rtext)
 536 {
 537         float endValue;
 538
 539         if (currentType == 0)
 540         {
 541                 Out::warning << "No type id specified, assignment of value \"autofade\" not possible" << Out::endl;
 542                 return;
 543         }
 544
 545         if (this->lastType != currentType)
 546         {
 547                 if (!s2str::stof (rtext, endValue))
 548                 {
 549                         Out::warning << "Invalid argument for value \"autofade\" in type #" << currentType << ", fallback to 500" << Out::endl;
 550                         endValue = 500.0;
 551                 }
 552
 553                 Kingdom::kingdomList[kingdomID]->getType (currentType) ->setFadingDistance (endValue);
 554         }
 555         else
 556         {
 557                 Out::warning << "Double assignment of value \"autofade\" in type #" << currentType << Out::endl;
 558         }
 559 }
 560
 561
 562
 563 void
 564 def::AlphaAction::operator() (std::string rtext)
 565 {
 566         float endValue;
 567
 568         if (currentType == 0)
 569         {
 570                 Out::warning << "No type id specified, assignment of value \"alpha\" not possible" << Out::endl;
 571                 return;
 572         }
 573
 574         if (this->lastType != currentType)
 575         {
 576                 if (!s2str::stof (rtext, endValue) || endValue < 0.0 || endValue > 1.0)
 577                 {
 578                         Out::warning << "Invalid argument for value \"alpha\" in type #" << currentType << ", fallback to 1.0" << Out::endl;
 579                         endValue = 1.0;
 580                 }
 581
 582                 Kingdom::kingdomList[kingdomID]->getType (currentType) ->setAlpha (endValue);
 583         }
 584         else
 585         {
 586                 Out::warning << "Double assignment of value \"alpha\" in type #" << currentType << Out::endl;
 587         }
 588 }
 589
 590
 591
 592 void
 593 def::ShineAction::operator() (std::string rtext)
 594 {
 595         float endValue;
 596
 597         if (currentType == 0)
 598         {
 599                 Out::warning << "No type id specified, assignment of value \"shine\" not possible" << Out::endl;
 600                 return;
 601         }
 602
 603         if (this->lastType != currentType)
 604         {
 605                 if (!s2str::stof (rtext, endValue) || endValue < 0.0 || endValue > 1.0)
 606                 {
 607                         Out::warning << "Invalid argument for value \"shine\" in type #" << currentType << ", fallback to 0.0" << Out::endl;
 608                         endValue = 0.0;
 609                 }
 610
 611                 Kingdom::kingdomList[kingdomID]->getType (currentType) ->setShine (endValue);
 612         }
 613         else
 614         {
 615                 Out::warning << "Double assignment of value \"shine\" in type #" << currentType << Out::endl;
 616         }
 617 }