src/weapons.cpp

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