src/weapons.cpp

   1 /*
   2 Copyright (C) 2004-2011 Parallel Realities
   3 Copyright (C) 2011-2015 Perpendicular Dimensions
   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
  24 /**
  25 * Loads all the predefined weapons for the game
  26 */
  27 void loadDefWeapons()
  28 {
  29         if (!engine.loadData("data/weapons"))
  30         {
  31                 graphics.showErrorAndExit("Couldn't load weapon definitions file (%s)", "data/weapons");
  32         }
  33
  34         char *token = strtok((char*)engine.dataBuffer, "\n");
  35
  36         char name[50];
  37         char sprite[2][100];
  38         char flags[100];
  39         int param[8];
  40         int id;
  41
  42         while (true)
  43         {
  44                 if (strcmp(token, "@EOF@") == 0)
  45                         break;
  46
  47                 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);
  48
  49                 weapon[id].setName(name);
  50                 weapon[id].id = param[0];
  51                 weapon[id].damage = param[1];
  52                 weapon[id].health = param[2];
  53                 weapon[id].dx = param[3];
  54                 weapon[id].dy = param[4];
  55                 weapon[id].reload = param[5];
  56                 weapon[id].sprite[0] = graphics.getSprite(sprite[0], true);
  57                 weapon[id].sprite[1] = graphics.getSprite(sprite[1], true);
  58                 weapon[id].fireSound = param[6];
  59                 weapon[id].flags = engine.getValueOfFlagTokens(flags);
  60
  61                 token = strtok(NULL, "\n");
  62         }
  63 }
  64
  65 /**
  66 * Chooses a random non aimed weapon. Selected either WP_MACHINEGUN, WP_ALIENLASER
  67 * WP_PLASMARIFLE or WP_ALIENGRENADE
  68 * @return The randomly selected Weapon
  69 */
  70 Weapon *getRandomStraightWeapon()
  71 {
  72         switch (Math::prand() % 4)
  73         {
  74                 case 0:
  75                         return &weapon[WP_MACHINEGUN];
  76                         break;
  77                 case 1:
  78                         return &weapon[WP_ALIENLASER];
  79                         break;
  80                 case 2:
  81                         return &weapon[WP_PLASMARIFLE];
  82                         break;
  83                 case 3:
  84                         return &weapon[WP_ALIENGRENADE];
  85                         break;
  86         }
  87
  88         return &weapon[WP_PISTOL];
  89 }
  90
  91 /**
  92 * Chooses a random aimed weapon. Selected either WP_AIMEDPISTOL, WP_ALIENSPREAD
  93 * or WP_ALIENGRENADE
  94 * @return The randomly selected Weapon
  95 */
  96 Weapon *getRandomAimedWeapon()
  97 {
  98         switch (Math::prand() % 3)
  99         {
 100                 case 0:
 101                         return &weapon[WP_AIMEDPISTOL];
 102                         break;
 103                 case 1:
 104                         return &weapon[WP_ALIENSPREAD];
 105                         break;
 106                 case 2:
 107                         return &weapon[WP_ALIENGRENADE];
 108                         break;
 109         }
 110
 111         return &weapon[WP_AIMEDPISTOL];
 112 }
 113
 114 /**
 115 * Chooses a random weapon for use by Galdov. Selects either WP_AIMEDPISTOL, WP_ALIENSPREAD
 116 * WP_ALIENGRENADE or WP_PLASMARIFLE
 117 * @return The randomly selected Weapon
 118 */
 119 Weapon *getRandomGaldovWeapon()
 120 {
 121         switch (Math::prand() % 4)
 122         {
 123                 case 0:
 124                         return &weapon[WP_AIMEDPISTOL];
 125                         break;
 126                 case 1:
 127                         return &weapon[WP_ALIENSPREAD];
 128                         break;
 129                 case 2:
 130                         return &weapon[WP_ALIENGRENADE];
 131                         break;
 132                 case 3:
 133                         return &weapon[WP_PLASMARIFLE];
 134                         break;
 135         }
 136
 137         return &weapon[WP_AIMEDPISTOL];
 138 }
 139
 140 /**
 141 * Searches the Weapon array for the named Weapon. Once it is found
 142 * it is returned. If it is not found WP_PISTOL is returned
 143 * @param name
 144 * @return The randomly selected Weapon
 145 */
 146 Weapon *getWeaponByName(const char *name)
 147 {
 148         if (strcmp("randomStraight", name) == 0)
 149         {
 150                 return getRandomStraightWeapon();
 151         }
 152
 153         if (strcmp("randomAimed", name) == 0)
 154         {
 155                 return getRandomAimedWeapon();
 156         }
 157
 158         for (int i = 0 ; i < MAX_WEAPONS ; i++)
 159         {
 160                 if (strcmp(weapon[i].name, name) == 0)
 161                 {
 162                         return &weapon[i];
 163                 }
 164         }
 165
 166         debug(("WARNING - COULD NOT FIND WEAPON '%s'\n", name));
 167
 168         return &weapon[WP_PISTOL];
 169 }