ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/c_range.C
(Generate patch)

Comparing deliantra/server/server/c_range.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:04 2006 UTC vs.
Revision 1.25 by root, Sat May 12 16:06:42 2007 UTC

1/* 1/*
2 * static char *rcsid_c_range_c = 2 * CrossFire, A Multiplayer game
3 * "$Id: c_range.C,v 1.1 2006/08/13 17:16:04 elmex Exp $";
4 */ 3 *
5 4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
6/*
7 CrossFire, A Multiplayer game for X-windows
8
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
11 7 *
12 This program is free software; you can redistribute it and/or modify 8 * This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version. 11 * (at your option) any later version.
16 12 *
17 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details. 16 * GNU General Public License for more details.
21 17 *
22 You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 19 * along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 21 *
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 23 */
28 24
29/* This file deals with range related commands (casting, shooting, 25/* This file deals with range related commands (casting, shooting,
30 * throwing, etc. 26 * throwing, etc.
31 */ 27 */
32 28
33#include <global.h> 29#include <global.h>
34#ifndef __CEXTRACT__
35#include <sproto.h> 30#include <sproto.h>
36#endif
37#include <spells.h> 31#include <spells.h>
38#include <skills.h> 32#include <skills.h>
39#include <newclient.h>
40#include <commands.h> 33#include <commands.h>
41 34
42 35int
43int command_invoke(object *op, char *params) 36command_invoke (object *op, char *params)
44{ 37{
45 return command_cast_spell(op, params, 'i'); 38 return command_cast_spell (op, params, 'i');
46} 39}
47 40
41int
48int command_cast(object *op, char *params) 42command_cast (object *op, char *params)
49{ 43{
50 return command_cast_spell(op, params, 'c'); 44 return command_cast_spell (op, params, 'c');
51} 45}
52 46
47int
53int command_prepare(object *op, char *params) 48command_prepare (object *op, char *params)
54{ 49{
55 return command_cast_spell(op, params, 'p'); 50 return command_cast_spell (op, params, 'p');
56} 51}
57 52
58/* Shows all spells that op knows. If params is supplied, the must match 53/* Shows all spells that op knows. If params is supplied, the must match
59 * that. Given there is more than one skill, we can't supply break 54 * that. Given there is more than one skill, we can't supply break
60 * them down to cleric/wizardry. 55 * them down to cleric/wizardry.
61 */ 56 */
57static void
62static void show_matching_spells(object *op, char *params) 58show_matching_spells (object *op, char *params)
63{ 59{
64 object *spell; 60 object *spell;
65 char spell_sort[NROFREALSPELLS][MAX_BUF], tmp[MAX_BUF], *cp; 61 char spell_sort[NROFREALSPELLS][MAX_BUF], tmp[MAX_BUF], *cp;
66 int num_found=0, i; 62 int num_found = 0, i;
67 63
68 /* 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
69 * into the spell_sort array so that we can sort them - 65 * into the spell_sort array so that we can sort them -
70 * we prefix the skill in the name so that the sorting 66 * we prefix the skill in the name so that the sorting
71 * works better. 67 * works better.
72 */ 68 */
73 for (spell=op->inv; spell!=NULL; spell=spell->below) { 69 for (spell = op->inv; spell; spell = spell->below)
70 {
74 /* 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
75 * match the name, process this spell. 72 * match the name, process this spell.
76 */ 73 */
77 if (spell->type == SPELL && 74 if (spell->type == SPELL && (!params || !strncmp (params, spell->name, strlen (params))))
78 (!params || !strncmp(params, spell->name, strlen(params)))) { 75 {
79 if (spell->path_attuned & op->path_denied) { 76 if (spell->path_attuned & op->path_denied)
77 {
78 sprintf (spell_sort[num_found++], "%s:%-22s %3s %3s", spell->skill ? &spell->skill : "generic", &spell->name, "den", "den");
79 }
80 else
81 {
80 sprintf(spell_sort[num_found++], 82 sprintf (spell_sort[num_found++],
81 "%s:%-22s %3s %3s", spell->skill?spell->skill:"generic",
82 spell->name, "den", "den");
83 } else {
84 sprintf(spell_sort[num_found++],
85 "%s:%-22s %3d %3d", spell->skill?spell->skill:"generic", 83 "%s:%-22s %3d %3d", spell->skill ? &spell->skill : "generic",
86 spell->name, spell->level, 84 &spell->name, spell->level, SP_level_spellpoint_cost (op, spell, SPELL_HIGHEST));
87 SP_level_spellpoint_cost(op,spell, SPELL_HIGHEST)); 85 }
86 }
88 } 87 }
89 } 88
90 }
91 if (!num_found) { 89 if (!num_found)
90 {
92 /* 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
93 * string. It is odd to do something like 'cast trans', 92 * string. It is odd to do something like 'cast trans',
94 * 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
95 * nothing that matches. 94 * nothing that matches.
96 */ 95 */
97 if (params) 96 if (params)
98 show_matching_spells(op, NULL); 97 show_matching_spells (op, NULL);
99 else 98 else
100 new_draw_info(NDI_UNIQUE, 0, op, "You know no spells"); 99 new_draw_info (NDI_UNIQUE, 0, op, "You know no spells");
101 } else { 100 }
101 else
102 {
102 /* Note in the code below that we make some 103 /* Note in the code below that we make some
103 * presumptions that there will be a colon in the 104 * presumptions that there will be a colon in the
104 * string. given the code above, this is always 105 * string. given the code above, this is always
105 * the case. 106 * the case.
106 */ 107 */
107 qsort(spell_sort, num_found, MAX_BUF, (int (*)(const void*, const void*))strcmp); 108 qsort (spell_sort, num_found, MAX_BUF, (int (*)(const void *, const void *)) std::strcmp);
108 strcpy(tmp,"asdfg"); /* Dummy string so initial compare fails */ 109 strcpy (tmp, "asdfg"); /* Dummy string so initial compare fails */
109 for (i=0; i<num_found; i++) { 110 for (i = 0; i < num_found; i++)
111 {
110 /* Different skill name, so print banner */ 112 /* Different skill name, so print banner */
111 if (strncmp(tmp, spell_sort[i], strlen(tmp))) { 113 if (strncmp (tmp, spell_sort[i], strlen (tmp)))
114 {
112 strcpy(tmp, spell_sort[i]); 115 strcpy (tmp, spell_sort[i]);
113 cp = strchr(tmp, ':'); 116 cp = strchr (tmp, ':');
114 *cp = '\0'; 117 *cp = '\0';
115 new_draw_info(NDI_UNIQUE, 0, op, ""); 118 new_draw_info (NDI_UNIQUE, 0, op, "");
116 new_draw_info_format(NDI_UNIQUE, 0,op,"%s spells %.*s [lvl] [sp]", 119 new_draw_info_format (NDI_UNIQUE, 0, op, "%s spells %.*s [lvl] [sp]", tmp, 12 - strlen (tmp), " ");
117 tmp, 12-strlen(tmp), " "); 120 }
118 }
119 new_draw_info(NDI_UNIQUE, 0, op, strchr(spell_sort[i], ':') + 1); 121 new_draw_info (NDI_UNIQUE, 0, op, strchr (spell_sort[i], ':') + 1);
120 } 122 }
121 } 123 }
122} 124}
123
124
125 125
126/* sets up to cast a spell. op is the caster, params is the spell name, 126/* sets up to cast a spell. op is the caster, params is the spell name,
127 * and command is the first letter of the spell type (c=cast, i=invoke, 127 * and command is the first letter of the spell type (c=cast, i=invoke,
128 * p=prepare). Invoke casts a spell immediately, where as cast (and I believe 128 * p=prepare). Invoke casts a spell immediately, where as cast (and I believe
129 * prepare) just set up the range type. 129 * prepare) just set up the range type.
130 */ 130 */
131 131int
132int command_cast_spell (object *op, char *params, char command) 132command_cast_spell (object *op, char *params, char command)
133{ 133{
134 int castnow=0; 134 int castnow = 0;
135 char *cp; 135 char *cp;
136 object *spob; 136 object *spob;
137 137
138 if (command=='i') castnow = 1; 138 if (command == 'i')
139 castnow = 1;
139 140
140 /* Remove control of the golem */ 141 /* Remove control of the golem */
141 if(op->contr->ranges[range_golem]!=NULL) { 142 if (object *golem = op->contr->golem)
142 if (op->contr->golem_count == op->contr->ranges[range_golem]->count) { 143 golem->destroy ();
143 remove_friendly_object(op->contr->ranges[range_golem]); 144
144 remove_ob(op->contr->ranges[range_golem]); 145 if (params)
145 free_object(op->contr->ranges[range_golem]);
146 }
147 op->contr->ranges[range_golem]=NULL;
148 op->contr->golem_count = 0;
149 } 146 {
150
151 if(params!=NULL) {
152 int spellnumber = 0; 147 int spellnumber = 0;
148
153 if (spellnumber = atoi(params)) 149 if ((spellnumber = atoi (params)))
154 for (spob = op->inv; spob && spob->count != spellnumber; spob=spob->below); 150 for (spob = op->inv; spob && spob->count != spellnumber; spob = spob->below)
151 /* nop */;
152 else
155 else spob = lookup_spell_by_name(op, params); 153 spob = lookup_spell_by_name (op, params);
156 154
157 if (spob && spob->type == SPELL) { 155 if (spob && spob->type == SPELL)
156 {
158 /* Now grab any extra data, if there is any. Forward pass 157 /* Now grab any extra data, if there is any. Forward pass
159 * any 'of' delimiter 158 * any 'of' delimiter
160 */ 159 */
161 if (spellnumber) { 160 if (spellnumber)
161 {
162 /* if we passed a number, the options start at the second word */ 162 /* if we passed a number, the options start at the second word */
163 cp = strchr(params, ' '); 163 cp = strchr (params, ' ');
164 if (cp) { 164 if (cp)
165 cp++; 165 {
166 if (!strncmp(cp, "of ", 3)) cp+=3; 166 cp++;
167 } 167 if (!strncmp (cp, "of ", 3))
168 } 168 cp += 3;
169 }
170 }
169 else if (strlen(params) > strlen(spob->name)) { 171 else if (strlen (params) > strlen (spob->name))
172 {
170 cp = params + strlen(spob->name); 173 cp = params + strlen (spob->name);
171 *cp = 0; 174 *cp = 0;
172 cp++; 175 cp++;
173 if (!strncmp(cp, "of ", 3)) cp+=3; 176 if (!strncmp (cp, "of ", 3))
174 } else 177 cp += 3;
175 cp = NULL; 178 }
179 else
180 cp = NULL;
176 181
177 if (spob->skill && !find_skill_by_name(op, spob->skill)) { 182 if (!spob->skill)
178 new_draw_info_format(NDI_UNIQUE, 0, op, 183 {
179 "You need the skill %s to cast %s!", 184 new_draw_info_format (NDI_UNIQUE, 0, op, "%s is a weird spell, please report it to the dungeon master!", &spob->name);
180 spob->skill, spob->name); 185 LOG (llevError, "spell without skill found: %s", spob->debug_desc ());
181 return 1; 186 return 1;
182 } 187 }
183 188
189 object *skill = find_skill_by_name (op, spob->skill);
190
191 if (!skill)
192 {
193 new_draw_info_format (NDI_UNIQUE, 0, op, "You need the skill %s to cast %s!", &spob->skill, &spob->name);
194 return 1;
195 }
196
184 if (castnow) { 197 if (castnow)
185 cast_spell(op,op,op->facing,spob,cp); 198 cast_spell (op, op, op->facing, spob, cp);
186 } else { 199 else
187 op->contr->ranges[range_magic] = spob; 200 {
188 op->contr->shoottype = range_magic; 201 op->contr->ranged_ob = spob;
189 if(cp != NULL) { 202
190 strncpy(op->contr->spellparam, cp, MAX_BUF); 203 assign (op->contr->spellparam, cp ? cp : "");
191 op->contr->spellparam[MAX_BUF-1] = '\0'; 204 new_draw_info_format (NDI_UNIQUE, 0, op, "You ready the spell %s", &spob->name);
192 } else { 205 }
193 op->contr->spellparam[0] = '\0'; 206
194 }
195 new_draw_info_format(NDI_UNIQUE, 0, op,
196 "You ready the spell %s", spob->name);
197 }
198 return 0; 207 return 0;
199 } /* else fall through to below and print spells */ 208 } /* else fall through to below and print spells */
200 } /* params supplied */ 209 } /* params supplied */
201 210
202 /* We get here if cast was given without options or we could not find 211 /* We get here if cast was given without options or we could not find
203 * the requested spell. List all the spells the player knows. 212 * the requested spell. List all the spells the player knows.
204 */ 213 */
205 new_draw_info(NDI_UNIQUE, 0,op,"Cast what spell? Choose one of:"); 214 new_draw_info (NDI_UNIQUE, 0, op, "Cast what spell? Choose one of:");
206 show_matching_spells(op, params); 215 show_matching_spells (op, params);
216
207 return 1; 217 return 1;
208} 218}
209 219
210/**************************************************************************/ 220/**************************************************************************/
211 221
212/* Returns TRUE if the range specified (int r) is legal - that is, 222void
213 * the character has an item that is equipped for that range type.
214 * return 0 if there is no item of that range type that is usable.
215 * This function could probably be simplified, eg, everything
216 * should index into the ranges[] array.
217 */
218
219int legal_range(object *op,int r) {
220
221 switch(r) {
222 case range_none: /* "Nothing" is always legal */
223 return 1;
224 case range_bow:
225 case range_misc:
226 case range_magic: /* cast spells */
227 if (op->contr->ranges[r]) return 1;
228 else return 0;
229
230 case range_golem: /* Use scrolls */
231 if (op->contr->ranges[range_golem] &&
232 op->contr->ranges[range_golem]->count == op->contr->golem_count)
233 return 1;
234 else
235 return 0;
236
237 case range_skill:
238 if (op->chosen_skill)
239 return 1;
240 else
241 return 0;
242 }
243 /* No match above, must not be valid */
244 return 0;
245}
246
247void change_spell(object *op,char k) { 223change_spell (object *op, char k)
248 224{
249 do { 225 if (op->contr->combat_ob == op->current_weapon)
250 op->contr->shoottype = (rangetype) (op->contr->shoottype + ((k == '+') ? 1 : -1));
251 if(op->contr->shoottype >= range_size)
252 op->contr->shoottype = range_none;
253 else if (op->contr->shoottype <= range_bottom)
254 op->contr->shoottype = (rangetype)(range_size-1);
255 } while (!legal_range(op,op->contr->shoottype));
256
257 /* Legal range has already checked that we have an appropriate item
258 * that uses the slot, so we don't need to be too careful about
259 * checking the status of the object.
260 */
261 switch(op->contr->shoottype) {
262 case range_none:
263 new_draw_info(NDI_UNIQUE, 0,op, "No ranged attack chosen.");
264 break;
265
266 case range_golem:
267 new_draw_info(NDI_UNIQUE, 0,op, "You regain control of your golem.");
268 break;
269
270 case range_bow:
271 new_draw_info_format(NDI_UNIQUE, 0,op, "Switched to %s and %s.", query_name(op->contr->ranges[range_bow]),
272 op->contr->ranges[range_bow]->race ? op->contr->ranges[range_bow]->race : "nothing");
273 break;
274
275 case range_magic:
276 new_draw_info_format(NDI_UNIQUE, 0,op,"Switched to spells (%s).",
277 op->contr->ranges[range_magic]->name);
278 break;
279
280 case range_misc:
281 new_draw_info_format(NDI_UNIQUE, 0,op, "Switched to %s.", query_base_name(op->contr->ranges[range_misc], 0));
282 break;
283
284 case range_skill:
285 new_draw_info_format(NDI_UNIQUE, 0,op, "Switched to skill: %s", op->chosen_skill ?
286 op->chosen_skill->name : "none");
287 break;
288
289 default:
290 break;
291 } 226 {
292} 227 if (op->contr->ranged_ob)
228 op->change_weapon (op->contr->ranged_ob);
229 }
230 else if (op->contr->ranged_ob == op->current_weapon)
231 {
232 if (op->contr->combat_ob)
233 op->change_weapon (op->contr->combat_ob);
234 }
293 235
236 //TODO: maybe switch to golem, if any?
237}
294 238
239int
295int command_rotateshoottype (object *op, char *params) 240command_rotateshoottype (object *op, char *params)
296{ 241{
297 if (!params) 242 if (!params)
298 change_spell(op,'+'); 243 change_spell (op, '+');
299 else 244 else
300 change_spell(op, params[0]); 245 change_spell (op, params[0]);
246
301 return 0; 247 return 0;
302} 248}
303

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines