src/weapons.cpp

   1 /*
   2 Copyright (C) 2004 Parallel Realities
   3 Copyright (C) 2007 Kővágó Zoltán
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13
  14 See the GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19
  20 */
  21
  22 #include "weapons.h"
  23 #include "gettext.hpp"
  24 #include "console/console.hpp"
  25
  26 /**
  27 * Loads all the predefined weapons for the game
  28 */
  29 void loadDefWeapons()
  30 {
  31         if (!engine.loadData("data/weapons"))
  32         {
  33                 graphics.showErrorAndExit(_("Couldn't load weapon definitions file (%s)"), "data/weapons");
  34         }
  35
  36         char *token = strtok((char*)engine.dataBuffer, "\n");
  37
  38         char name[50];
  39         char sprite[2][100];
  40         char flags[100];
  41         int param[8];
  42         int id;
  43
  44         while (true)
  45         {
  46                 if (strcmp(token, "@EOF@") == 0)
  47                         break;
  48
  49                 sscanf(token, "%d %*c %[^\"] %*c %d %d %d %d %d %d %s %s %d %s", &id, name, &param[0], &param[1], &param[2], &param[3], &param[4], &param[5], sprite[0], sprite[1], &param[6], flags);
  50
  51                 weapon[id].setName(name);
  52                 weapon[id].id = param[0];
  53                 weapon[id].damage = param[1];
  54                 weapon[id].health = param[2];
  55                 weapon[id].dx = param[3];
  56                 weapon[id].dy = param[4];
  57                 weapon[id].reload = param[5];
  58                 weapon[id].sprite[0] = graphics.getSprite(sprite[0], true);
  59                 weapon[id].sprite[1] = graphics.getSprite(sprite[1], true);
  60                 weapon[id].fireSound = param[6];
  61                 weapon[id].flags = engine.getValueOfFlagTokens(flags);
  62
  63                 token = strtok(NULL, "\n");
  64         }
  65 }
  66
  67 /**
  68 * Chooses a random non aimed weapon. Selected either WP_MACHINEGUN, WP_ALIENLASER
  69 * WP_PLASMARIFLE or WP_ALIENGRENADE
  70 * @return The randomly selected Weapon
  71 */
  72 Weapon *getRandomStraightWeapon()
  73 {
  74         switch (rand() % 4)
  75         {
  76                 case 0:
  77                         return &weapon[WP_MACHINEGUN];
  78                         break;
  79                 case 1:
  80                         return &weapon[WP_ALIENLASER];
  81                         break;
  82                 case 2:
  83                         return &weapon[WP_PLASMARIFLE];
  84                         break;
  85                 case 3:
  86                         return &weapon[WP_ALIENGRENADE];
  87                         break;
  88         }
  89
  90         return &weapon[WP_PISTOL];
  91 }
  92
  93 /**
  94 * Chooses a random aimed weapon. Selected either WP_AIMEDPISTOL, WP_ALIENSPREAD
  95 * or WP_ALIENGRENADE
  96 * @return The randomly selected Weapon
  97 */
  98 Weapon *getRandomAimedWeapon()
  99 {
 100         switch (rand() % 3)
 101         {
 102                 case 0:
 103                         return &weapon[WP_AIMEDPISTOL];
 104                         break;
 105                 case 1:
 106                         return &weapon[WP_ALIENSPREAD];
 107                         break;
 108                 case 2:
 109                         return &weapon[WP_ALIENGRENADE];
 110                         break;
 111         }
 112
 113         return &weapon[WP_AIMEDPISTOL];
 114 }
 115
 116 /**
 117 * Chooses a random weapon for use by Galdov. Selects either WP_AIMEDPISTOL, WP_ALIENSPREAD
 118 * WP_ALIENGRENADE or WP_PLASMARIFLE
 119 * @return The randomly selected Weapon
 120 */
 121 Weapon *getRandomGaldovWeapon()
 122 {
 123         switch (rand() % 4)
 124         {
 125                 case 0:
 126                         return &weapon[WP_AIMEDPISTOL];
 127                         break;
 128                 case 1:
 129                         return &weapon[WP_ALIENSPREAD];
 130                         break;
 131                 case 2:
 132                         return &weapon[WP_ALIENGRENADE];
 133                         break;
 134                 case 3:
 135                         return &weapon[WP_PLASMARIFLE];
 136                         break;
 137         }
 138
 139         return &weapon[WP_AIMEDPISTOL];
 140 }
 141
 142 /**
 143 * Searches the Weapon array for the named Weapon. Once it is found
 144 * it is returned. If it is not found WP_PISTOL is returned
 145 * @param name
 146 * @return The randomly selected Weapon
 147 */
 148 Weapon *getWeaponByName(char *name)
 149 {
 150         if (strcmp("randomStraight", name) == 0)
 151         {
 152                 return getRandomStraightWeapon();
 153         }
 154
 155         if (strcmp("randomAimed", name) == 0)
 156         {
 157                 return getRandomAimedWeapon();
 158         }
 159
 160         for (int i = 0 ; i < MAX_WEAPONS ; i++)
 161         {
 162                 if (strcmp(weapon[i].name, name) == 0)
 163                 {
 164                         return &weapon[i];
 165                 }
 166         }
 167
 168         debug << "WARNING - COULD NOT FIND WEAPON '" << name << "'" << std::endl;
 169
 170         return &weapon[WP_PISTOL];
 171 }