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.44 by root, Fri Apr 2 03:41:24 2010 UTC

1/* 1/*
2 * static char *rcsid_c_range_c = 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * "$Id: c_range.C,v 1.1 2006/08/13 17:16:04 elmex Exp $"; 3 *
4 */ 4 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5
6/*
7 CrossFire, A Multiplayer game for X-windows
8
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
11 7 *
12 This program is free software; you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
13 it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
14 the Free Software Foundation; either version 2 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
15 (at your option) any later version. 11 * 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 Affero GNU General Public License
23 along with this program; if not, write to the Free Software 19 * and the GNU General Public License along with this program. If not, see
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * <http://www.gnu.org/licenses/>.
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 to <support@deliantra.net>
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
42
43int command_invoke(object *op, char *params)
44{
45 return command_cast_spell(op, params, 'i');
46}
47
48int command_cast(object *op, char *params)
49{
50 return command_cast_spell(op, params, 'c');
51}
52
53int command_prepare(object *op, char *params)
54{
55 return command_cast_spell(op, params, 'p');
56}
57 34
58/* Shows all spells that op knows. If params is supplied, the must match 35/* 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 36 * that. Given there is more than one skill, we can't supply break
60 * them down to cleric/wizardry. 37 * them down to cleric/wizardry.
61 */ 38 */
39static void
62static void show_matching_spells(object *op, char *params) 40show_matching_spells (object *op, char *params)
63{ 41{
64 object *spell; 42 object *spell;
65 char spell_sort[NROFREALSPELLS][MAX_BUF], tmp[MAX_BUF], *cp; 43 char spell_sort[NROFREALSPELLS][MAX_BUF], tmp[MAX_BUF], *cp;
66 int num_found=0, i; 44 int num_found = 0, i;
67 45
68 /* We go and see what spells the player has. We put them 46 /* We go and see what spells the player has. We put them
69 * into the spell_sort array so that we can sort them - 47 * into the spell_sort array so that we can sort them -
70 * we prefix the skill in the name so that the sorting 48 * we prefix the skill in the name so that the sorting
71 * works better. 49 * works better.
72 */ 50 */
73 for (spell=op->inv; spell!=NULL; spell=spell->below) { 51 for (spell = op->inv; spell; spell = spell->below)
52 {
74 /* If it is a spell, and no params are passed, or they 53 /* If it is a spell, and no params are passed, or they
75 * match the name, process this spell. 54 * match the name, process this spell.
76 */ 55 */
77 if (spell->type == SPELL && 56 if (spell->type == SPELL && (!params || !strncmp (params, spell->name, strlen (params))))
78 (!params || !strncmp(params, spell->name, strlen(params)))) { 57 {
79 if (spell->path_attuned & op->path_denied) { 58 if (spell->path_attuned & op->path_denied)
59 {
60 sprintf (spell_sort[num_found++], "%s:%-22s %3s %3s", spell->skill ? &spell->skill : "generic", &spell->name, "den", "den");
61 }
62 else
63 {
80 sprintf(spell_sort[num_found++], 64 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", 65 "%s:%-22s %3d %3d", spell->skill ? &spell->skill : "generic",
86 spell->name, spell->level, 66 &spell->name, spell->level, SP_level_spellpoint_cost (op, spell, SPELL_HIGHEST));
87 SP_level_spellpoint_cost(op,spell, SPELL_HIGHEST)); 67 }
88 } 68 }
89 }
90 } 69 }
70
91 if (!num_found) { 71 if (!num_found)
72 {
92 /* If a matching string was passed along, now try it without that 73 /* If a matching string was passed along, now try it without that
93 * string. It is odd to do something like 'cast trans', 74 * string. It is odd to do something like 'cast trans',
94 * and it say you have no spells, when really, you do, but just 75 * and it say you have no spells, when really, you do, but just
95 * nothing that matches. 76 * nothing that matches.
96 */ 77 */
97 if (params) 78 if (params)
98 show_matching_spells(op, NULL); 79 show_matching_spells (op, NULL);
99 else 80 else
100 new_draw_info(NDI_UNIQUE, 0, op, "You know no spells"); 81 new_draw_info (NDI_UNIQUE, 0, op, "You know no spells");
101 } else {
102 /* Note in the code below that we make some
103 * presumptions that there will be a colon in the
104 * string. given the code above, this is always
105 * the case.
106 */
107 qsort(spell_sort, num_found, MAX_BUF, (int (*)(const void*, const void*))strcmp);
108 strcpy(tmp,"asdfg"); /* Dummy string so initial compare fails */
109 for (i=0; i<num_found; i++) {
110 /* Different skill name, so print banner */
111 if (strncmp(tmp, spell_sort[i], strlen(tmp))) {
112 strcpy(tmp, spell_sort[i]);
113 cp = strchr(tmp, ':');
114 *cp = '\0';
115 new_draw_info(NDI_UNIQUE, 0, op, "");
116 new_draw_info_format(NDI_UNIQUE, 0,op,"%s spells %.*s [lvl] [sp]",
117 tmp, 12-strlen(tmp), " ");
118 }
119 new_draw_info(NDI_UNIQUE, 0, op, strchr(spell_sort[i], ':') + 1);
120 }
121 } 82 }
83 else
84 {
85 /* Note in the code below that we make some
86 * presumptions that there will be a colon in the
87 * string. given the code above, this is always
88 * the case.
89 */
90 qsort (spell_sort, num_found, MAX_BUF, (int (*)(const void *, const void *)) std::strcmp);
91 strcpy (tmp, "asdfg"); /* Dummy string so initial compare fails */
92 for (i = 0; i < num_found; i++)
93 {
94 /* Different skill name, so print banner */
95 if (strncmp (tmp, spell_sort[i], strlen (tmp)))
96 {
97 strcpy (tmp, spell_sort[i]);
98 cp = strchr (tmp, ':');
99 *cp = '\0';
100 new_draw_info (NDI_UNIQUE, 0, op, "");
101 new_draw_info_format (NDI_UNIQUE, 0, op, "%s spells %.*s [lvl] [sp]", tmp, 12 - strlen (tmp), " ");
102 }
103 new_draw_info (NDI_UNIQUE, 0, op, strchr (spell_sort[i], ':') + 1);
104 }
105 }
122} 106}
123
124
125 107
126/* sets up to cast a spell. op is the caster, params is the spell name, 108/* 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, 109 * 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 110 * p=prepare). Invoke casts a spell immediately, where as cast (and I believe
129 * prepare) just set up the range type. 111 * prepare) just set up the range type.
130 */ 112 */
131 113static int
132int command_cast_spell (object *op, char *params, char command) 114command_cast_spell (object *op, char *params, char command)
133{ 115{
134 int castnow=0; 116 int castnow = 0;
135 char *cp; 117 char *cp;
136 object *spob; 118 object *spob;
137 119
138 if (command=='i') castnow = 1; 120 if (command == 'i')
121 castnow = 1;
139 122
140 /* Remove control of the golem */ 123 /* Remove control of the golem */
141 if(op->contr->ranges[range_golem]!=NULL) { 124 if (object *golem = op->contr->golem)
142 if (op->contr->golem_count == op->contr->ranges[range_golem]->count) { 125 golem->drop_and_destroy ();
143 remove_friendly_object(op->contr->ranges[range_golem]); 126
144 remove_ob(op->contr->ranges[range_golem]); 127 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 } 128 {
150
151 if(params!=NULL) {
152 int spellnumber = 0; 129 int spellnumber = 0;
130
153 if (spellnumber = atoi(params)) 131 if ((spellnumber = atoi (params)))
154 for (spob = op->inv; spob && spob->count != spellnumber; spob=spob->below); 132 for (spob = op->inv; spob && spob->count != spellnumber; spob = spob->below)
133 /* nop */;
134 else
155 else spob = lookup_spell_by_name(op, params); 135 spob = lookup_spell_by_name (op, params);
156 136
157 if (spob && spob->type == SPELL) { 137 if (spob && spob->type == SPELL)
138 {
158 /* Now grab any extra data, if there is any. Forward pass 139 /* Now grab any extra data, if there is any. Forward pass
159 * any 'of' delimiter 140 * any 'of' delimiter
160 */ 141 */
161 if (spellnumber) { 142 if (spellnumber)
143 {
162 /* if we passed a number, the options start at the second word */ 144 /* if we passed a number, the options start at the second word */
163 cp = strchr(params, ' '); 145 cp = strchr (params, ' ');
164 if (cp) { 146 if (cp)
165 cp++; 147 {
166 if (!strncmp(cp, "of ", 3)) cp+=3; 148 cp++;
167 } 149 if (!strncmp (cp, "of ", 3))
168 } 150 cp += 3;
151 }
152 }
169 else if (strlen(params) > strlen(spob->name)) { 153 else if (strlen (params) > strlen (spob->name))
154 {
170 cp = params + strlen(spob->name); 155 cp = params + strlen (spob->name);
171 *cp = 0; 156 *cp = 0;
172 cp++; 157 cp++;
173 if (!strncmp(cp, "of ", 3)) cp+=3; 158 if (!strncmp (cp, "of ", 3))
174 } else 159 cp += 3;
175 cp = NULL; 160 }
161 else
162 cp = NULL;
176 163
177 if (spob->skill && !find_skill_by_name(op, spob->skill)) { 164 if (!spob->skill)
178 new_draw_info_format(NDI_UNIQUE, 0, op, 165 {
179 "You need the skill %s to cast %s!", 166 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); 167 LOG (llevError, "spell without skill found: %s", spob->debug_desc ());
181 return 1; 168 return 1;
182 } 169 }
183 170
184 if (castnow) { 171 if (castnow)
185 cast_spell(op,op,op->facing,spob,cp); 172 cast_spell (op, op, op->facing, spob, cp);
186 } else { 173 else if (op->apply (spob))
187 op->contr->ranges[range_magic] = spob; 174 {
188 op->contr->shoottype = range_magic; 175 splay (spob);
189 if(cp != NULL) { 176 assign (op->contr->spellparam, cp ? cp : "");
190 strncpy(op->contr->spellparam, cp, MAX_BUF); 177 }
191 op->contr->spellparam[MAX_BUF-1] = '\0'; 178
192 } else {
193 op->contr->spellparam[0] = '\0';
194 }
195 new_draw_info_format(NDI_UNIQUE, 0, op,
196 "You ready the spell %s", spob->name);
197 }
198 return 0; 179 return 0;
199 } /* else fall through to below and print spells */ 180 } /* else fall through to below and print spells */
200 } /* params supplied */ 181 } /* params supplied */
201 182
202 /* We get here if cast was given without options or we could not find 183 /* 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. 184 * the requested spell. List all the spells the player knows.
204 */ 185 */
205 new_draw_info(NDI_UNIQUE, 0,op,"Cast what spell? Choose one of:"); 186 new_draw_info (NDI_UNIQUE, 0, op, "Cast what spell? Choose one of:");
206 show_matching_spells(op, params); 187 show_matching_spells (op, params);
188
207 return 1; 189 return 1;
190}
191
192int
193command_invoke (object *op, char *params)
194{
195 return command_cast_spell (op, params, 'i');
196}
197
198int
199command_cast (object *op, char *params)
200{
201 return command_cast_spell (op, params, 'c');
202}
203
204int
205command_prepare (object *op, char *params)
206{
207 return command_cast_spell (op, params, 'p');
208} 208}
209 209
210/**************************************************************************/ 210/**************************************************************************/
211 211
212/* Returns TRUE if the range specified (int r) is legal - that is, 212static void
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) { 213change_spell (object *op, char k)
214{
215 if (op->contr->combat_ob && op->contr->ranged_ob)
216 op->change_weapon (
217 op->current_weapon == op->contr->combat_ob
218 ? op->contr->ranged_ob
219 : op->contr->combat_ob
220 );
248 221
249 do { 222 //TODO: maybe switch to golem, if any?
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 }
292} 223}
293 224
294 225int
295int command_rotateshoottype (object *op, char *params) 226command_rotateshoottype (object *op, char *params)
296{ 227{
297 if (!params) 228 if (!params)
298 change_spell(op,'+'); 229 change_spell (op, '+');
299 else 230 else
300 change_spell(op, params[0]); 231 change_spell (op, params[0]);
232
301 return 0; 233 return 0;
302} 234}
303

Diff Legend

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