| … | |
… | |
| 64 | /* We go and see what spells the player has. We put them |
64 | /* We go and see what spells the player has. We put them |
| 65 | * into the spell_sort array so that we can sort them - |
65 | * into the spell_sort array so that we can sort them - |
| 66 | * we prefix the skill in the name so that the sorting |
66 | * we prefix the skill in the name so that the sorting |
| 67 | * works better. |
67 | * works better. |
| 68 | */ |
68 | */ |
| 69 | for (spell = op->inv; spell != NULL; spell = spell->below) |
69 | for (spell = op->inv; spell; spell = spell->below) |
| 70 | { |
70 | { |
| 71 | /* If it is a spell, and no params are passed, or they |
71 | /* If it is a spell, and no params are passed, or they |
| 72 | * match the name, process this spell. |
72 | * match the name, process this spell. |
| 73 | */ |
73 | */ |
| 74 | if (spell->type == SPELL && (!params || !strncmp (params, spell->name, strlen (params)))) |
74 | if (spell->type == SPELL && (!params || !strncmp (params, spell->name, strlen (params)))) |
| … | |
… | |
| 83 | "%s:%-22s %3d %3d", spell->skill ? &spell->skill : "generic", |
83 | "%s:%-22s %3d %3d", spell->skill ? &spell->skill : "generic", |
| 84 | &spell->name, spell->level, SP_level_spellpoint_cost (op, spell, SPELL_HIGHEST)); |
84 | &spell->name, spell->level, SP_level_spellpoint_cost (op, spell, SPELL_HIGHEST)); |
| 85 | } |
85 | } |
| 86 | } |
86 | } |
| 87 | } |
87 | } |
|
|
88 | |
| 88 | if (!num_found) |
89 | if (!num_found) |
| 89 | { |
90 | { |
| 90 | /* If a matching string was passed along, now try it without that |
91 | /* If a matching string was passed along, now try it without that |
| 91 | * string. It is odd to do something like 'cast trans', |
92 | * string. It is odd to do something like 'cast trans', |
| 92 | * and it say you have no spells, when really, you do, but just |
93 | * and it say you have no spells, when really, you do, but just |
| … | |
… | |
| 136 | |
137 | |
| 137 | if (command == 'i') |
138 | if (command == 'i') |
| 138 | castnow = 1; |
139 | castnow = 1; |
| 139 | |
140 | |
| 140 | /* Remove control of the golem */ |
141 | /* Remove control of the golem */ |
| 141 | if (object *golem = op->contr->ranges[range_golem]) |
142 | if (object *golem = op->contr->golem) |
| 142 | golem->destroy (); |
143 | golem->destroy (); |
| 143 | |
144 | |
| 144 | if (params) |
145 | if (params) |
| 145 | { |
146 | { |
| 146 | int spellnumber = 0; |
147 | int spellnumber = 0; |
| … | |
… | |
| 165 | cp++; |
166 | cp++; |
| 166 | if (!strncmp (cp, "of ", 3)) |
167 | if (!strncmp (cp, "of ", 3)) |
| 167 | cp += 3; |
168 | cp += 3; |
| 168 | } |
169 | } |
| 169 | } |
170 | } |
| 170 | else if (strlen (params) > (size_t) strlen (spob->name)) |
171 | else if (strlen (params) > strlen (spob->name)) |
| 171 | { |
172 | { |
| 172 | cp = params + strlen (spob->name); |
173 | cp = params + strlen (spob->name); |
| 173 | *cp = 0; |
174 | *cp = 0; |
| 174 | cp++; |
175 | cp++; |
| 175 | if (!strncmp (cp, "of ", 3)) |
176 | if (!strncmp (cp, "of ", 3)) |
| 176 | cp += 3; |
177 | cp += 3; |
| 177 | } |
178 | } |
| 178 | else |
179 | else |
| 179 | cp = NULL; |
180 | cp = NULL; |
| 180 | |
181 | |
|
|
182 | if (!spob->skill) |
|
|
183 | { |
|
|
184 | new_draw_info_format (NDI_UNIQUE, 0, op, "%s is a weird spell, please report it to the dungeon master!", &spob->name); |
|
|
185 | LOG (llevError, "spell without skill found: %s", spob->debug_desc ()); |
|
|
186 | return 1; |
|
|
187 | } |
|
|
188 | |
| 181 | if (spob->skill && !find_skill_by_name (op, spob->skill)) |
189 | object *skill = find_skill_by_name (op, spob->skill); |
|
|
190 | |
|
|
191 | if (!skill) |
| 182 | { |
192 | { |
| 183 | new_draw_info_format (NDI_UNIQUE, 0, op, "You need the skill %s to cast %s!", &spob->skill, &spob->name); |
193 | new_draw_info_format (NDI_UNIQUE, 0, op, "You need the skill %s to cast %s!", &spob->skill, &spob->name); |
| 184 | return 1; |
194 | return 1; |
| 185 | } |
195 | } |
| 186 | |
196 | |
| 187 | if (castnow) |
197 | if (castnow) |
| 188 | cast_spell (op, op, op->facing, spob, cp); |
198 | cast_spell (op, op, op->facing, spob, cp); |
| 189 | else |
199 | else |
| 190 | { |
200 | { |
| 191 | op->contr->ranges[range_magic] = spob; |
201 | op->contr->ranged_ob = spob; |
| 192 | op->contr->shoottype = range_magic; |
202 | |
| 193 | assign (op->contr->spellparam, cp ? cp : ""); |
203 | assign (op->contr->spellparam, cp ? cp : ""); |
| 194 | new_draw_info_format (NDI_UNIQUE, 0, op, "You ready the spell %s", &spob->name); |
204 | new_draw_info_format (NDI_UNIQUE, 0, op, "You ready the spell %s", &spob->name); |
| 195 | } |
205 | } |
| 196 | |
206 | |
| 197 | return 0; |
207 | return 0; |
| … | |
… | |
| 206 | return 1; |
216 | return 1; |
| 207 | } |
217 | } |
| 208 | |
218 | |
| 209 | /**************************************************************************/ |
219 | /**************************************************************************/ |
| 210 | |
220 | |
| 211 | /* Returns TRUE if the range specified (int r) is legal - that is, |
|
|
| 212 | * the character has an item that is equipped for that range type. |
|
|
| 213 | * return 0 if there is no item of that range type that is usable. |
|
|
| 214 | * This function could probably be simplified, eg, everything |
|
|
| 215 | * should index into the ranges[] array. |
|
|
| 216 | */ |
|
|
| 217 | |
|
|
| 218 | int |
|
|
| 219 | legal_range (object *op, int r) |
|
|
| 220 | { |
|
|
| 221 | switch (r) |
|
|
| 222 | { |
|
|
| 223 | case range_none: /* "Nothing" is always legal */ |
|
|
| 224 | return 1; |
|
|
| 225 | |
|
|
| 226 | case range_bow: |
|
|
| 227 | case range_misc: |
|
|
| 228 | case range_magic: /* cast spells */ |
|
|
| 229 | return !!op->contr->ranges[r]; |
|
|
| 230 | |
|
|
| 231 | case range_golem: /* Use scrolls */ |
|
|
| 232 | return !!op->contr->ranges[range_golem]; |
|
|
| 233 | |
|
|
| 234 | case range_skill: |
|
|
| 235 | return !!op->chosen_skill; |
|
|
| 236 | } |
|
|
| 237 | |
|
|
| 238 | /* No match above, must not be valid */ |
|
|
| 239 | return 0; |
|
|
| 240 | } |
|
|
| 241 | |
|
|
| 242 | void |
221 | void |
| 243 | change_spell (object *op, char k) |
222 | change_spell (object *op, char k) |
| 244 | { |
223 | { |
| 245 | do |
224 | //TODO: maybe switch to golem, if any? |
| 246 | { |
225 | // does nothing |
| 247 | op->contr->shoottype = (rangetype) (op->contr->shoottype + ((k == '+') ? 1 : -1)); |
|
|
| 248 | if (op->contr->shoottype >= range_size) |
|
|
| 249 | op->contr->shoottype = range_none; |
|
|
| 250 | else if (op->contr->shoottype <= range_bottom) |
|
|
| 251 | op->contr->shoottype = (rangetype) (range_size - 1); |
|
|
| 252 | } |
|
|
| 253 | while (!legal_range (op, op->contr->shoottype)); |
|
|
| 254 | |
|
|
| 255 | /* Legal range has already checked that we have an appropriate item |
|
|
| 256 | * that uses the slot, so we don't need to be too careful about |
|
|
| 257 | * checking the status of the object. |
|
|
| 258 | */ |
|
|
| 259 | switch (op->contr->shoottype) |
|
|
| 260 | { |
|
|
| 261 | case range_none: |
|
|
| 262 | new_draw_info (NDI_UNIQUE, 0, op, "No ranged attack chosen."); |
|
|
| 263 | break; |
|
|
| 264 | |
|
|
| 265 | case range_golem: |
|
|
| 266 | new_draw_info (NDI_UNIQUE, 0, op, "You regain control of your golem."); |
|
|
| 267 | break; |
|
|
| 268 | |
|
|
| 269 | case range_bow: |
|
|
| 270 | new_draw_info_format (NDI_UNIQUE, 0, op, "Switched to %s and %s.", query_name (op->contr->ranges[range_bow]), |
|
|
| 271 | op->contr->ranges[range_bow]->race ? &op->contr->ranges[range_bow]->race : "nothing"); |
|
|
| 272 | break; |
|
|
| 273 | |
|
|
| 274 | case range_magic: |
|
|
| 275 | new_draw_info_format (NDI_UNIQUE, 0, op, "Switched to spells (%s).", &op->contr->ranges[range_magic]->name); |
|
|
| 276 | break; |
|
|
| 277 | |
|
|
| 278 | case range_misc: |
|
|
| 279 | new_draw_info_format (NDI_UNIQUE, 0, op, "Switched to %s.", query_base_name (op->contr->ranges[range_misc], 0)); |
|
|
| 280 | break; |
|
|
| 281 | |
|
|
| 282 | case range_skill: |
|
|
| 283 | new_draw_info_format (NDI_UNIQUE, 0, op, "Switched to skill: %s", op->chosen_skill ? &op->chosen_skill->name : "none"); |
|
|
| 284 | break; |
|
|
| 285 | |
|
|
| 286 | default: |
|
|
| 287 | break; |
|
|
| 288 | } |
|
|
| 289 | } |
226 | } |
| 290 | |
|
|
| 291 | |
227 | |
| 292 | int |
228 | int |
| 293 | command_rotateshoottype (object *op, char *params) |
229 | command_rotateshoottype (object *op, char *params) |
| 294 | { |
230 | { |
| 295 | if (!params) |
231 | if (!params) |
| 296 | change_spell (op, '+'); |
232 | change_spell (op, '+'); |
| 297 | else |
233 | else |
| 298 | change_spell (op, params[0]); |
234 | change_spell (op, params[0]); |
|
|
235 | |
| 299 | return 0; |
236 | return 0; |
| 300 | } |
237 | } |
