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