server/server/c_range.c

/*
 * static char *rcsid_c_range_c =
 *   "$Id$";
 */

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2002 Mark Wedel & Crossfire Development Team
    Copyright (C) 1992 Frank Tore Johansen

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    The authors can be reached via e-mail at crossfire-devel@real-time.com
*/

/* This file deals with range related commands (casting, shooting,
 * throwing, etc.
 */

#include <global.h>
#ifndef __CEXTRACT__
#include <sproto.h>
#endif
#include <spells.h>
#include <skills.h>
#include <newclient.h>
#include <commands.h>


int command_invoke(object *op, char *params)
{
        return command_cast_spell(op, params, 'i');
}

int command_cast(object *op, char *params)
{
        return command_cast_spell(op, params, 'c');
}

int command_prepare(object *op, char *params)
{
        return command_cast_spell(op, params, 'p');
}

/* Shows all spells that op knows.  If params is supplied, the must match
 * that.  Given there is more than one skill, we can't supply break
 * them down to cleric/wizardry.
 */
static void show_matching_spells(object *op, char *params)
{
    object *spell;
    char    spell_sort[NROFREALSPELLS][MAX_BUF], tmp[MAX_BUF], *cp;
    int     num_found=0, i;

    /* We go and see what spells the player has.  We put them
     * into the spell_sort array so that we can sort them -
     * we prefix the skill in the name so that the sorting
     * works better.
     */
    for (spell=op->inv; spell!=NULL; spell=spell->below) {
        /* If it is a spell, and no params are passed, or they
         * match the name, process this spell.
         */
        if (spell->type == SPELL && 
            (!params || !strncmp(params, spell->name, strlen(params)))) {
            if (spell->path_attuned & op->path_denied) {
                sprintf(spell_sort[num_found++],
                        "%s:%-22s %3s %3s", spell->skill?spell->skill:"generic",
                        spell->name, "den", "den");
            } else {
                sprintf(spell_sort[num_found++],
                        "%s:%-22s %3d %3d", spell->skill?spell->skill:"generic",
                        spell->name, spell->level,
                        SP_level_spellpoint_cost(op,spell, SPELL_HIGHEST));
            }
        }
    }
    if (!num_found) {
        /* If a matching string was passed along, now try it without that
         * string.  It is odd to do something like 'cast trans',
         * and it say you have no spells, when really, you do, but just
         * nothing that matches.
         */
        if (params)
            show_matching_spells(op, NULL);
        else
            new_draw_info(NDI_UNIQUE, 0, op, "You know no spells");
    } else {
        /* Note in the code below that we make some
         * presumptions that there will be a colon in the
         * string.  given the code above, this is always
         * the case.
         */
        qsort(spell_sort, num_found, MAX_BUF, (int (*)(const void*, const void*))strcmp);
        strcpy(tmp,"asdfg");    /* Dummy string so initial compare fails */
        for (i=0; i<num_found; i++) {
            /* Different skill name, so print banner */
            if (strncmp(tmp, spell_sort[i], strlen(tmp))) {
                strcpy(tmp, spell_sort[i]);
                cp = strchr(tmp, ':');
                *cp = '\0';
                new_draw_info(NDI_UNIQUE, 0, op, "");
                new_draw_info_format(NDI_UNIQUE, 0,op,"%s spells %.*s [lvl] [sp]",
                              tmp, 12-strlen(tmp), "              ");
            }
            new_draw_info(NDI_UNIQUE, 0, op, strchr(spell_sort[i], ':') + 1);
        }
    }
}


/* sets up to cast a spell.  op is the caster, params is the spell name,
 * and command is the first letter of the spell type (c=cast, i=invoke, 
 * p=prepare).  Invoke casts a spell immediately, where as cast (and I believe
 * prepare) just set up the range type.
 */

int command_cast_spell (object *op, char *params, char command)
{
    int castnow=0;
    char *cp;
    object *spob;

    if (command=='i') castnow = 1;

    /* Remove control of the golem */
    if(op->contr->ranges[range_golem]!=NULL) {
        if (op->contr->golem_count == op->contr->ranges[range_golem]->count) {
            remove_friendly_object(op->contr->ranges[range_golem]);
            remove_ob(op->contr->ranges[range_golem]);
            free_object(op->contr->ranges[range_golem]);
        }
        op->contr->ranges[range_golem]=NULL;
        op->contr->golem_count = 0;
    }

    if(params!=NULL) {
        int spellnumber = 0;
        if (spellnumber = atoi(params)) 
            for (spob = op->inv; spob && spob->count != spellnumber; spob=spob->below);
        else spob = lookup_spell_by_name(op, params);

        if (spob && spob->type == SPELL) {
            /* Now grab any extra data, if there is any.  Forward pass
             * any 'of' delimiter
             */
            if (spellnumber) {
                /* if we passed a number, the options start at the second word */
                cp = strchr(params, ' ');
                if (cp) {
                    cp++;
                    if (!strncmp(cp, "of ", 3)) cp+=3;
                }
            }
            else if (strlen(params) > strlen(spob->name)) {
                cp = params + strlen(spob->name);
                *cp = 0;
                cp++;
                if (!strncmp(cp, "of ", 3)) cp+=3;
            } else
                cp = NULL;

            if (spob->skill && !find_skill_by_name(op, spob->skill)) {
                new_draw_info_format(NDI_UNIQUE, 0, op,
                    "You need the skill %s to cast %s!",
                    spob->skill, spob->name);
                return 1;
            }
                
            if (castnow) {
                cast_spell(op,op,op->facing,spob,cp);
            } else {
                op->contr->ranges[range_magic] = spob;
                op->contr->shoottype = range_magic;
                if(cp != NULL) {
                  strncpy(op->contr->spellparam, cp, MAX_BUF);
                  op->contr->spellparam[MAX_BUF-1] = '\0';
                } else {
                  op->contr->spellparam[0] = '\0';
                }
                new_draw_info_format(NDI_UNIQUE, 0, op,
                        "You ready the spell %s", spob->name);
            }
            return 0;
        } /* else fall through to below and print spells */
    } /* params supplied */

    /* We get here if cast was given without options or we could not find
     * the requested spell.  List all the spells the player knows.
     */
    new_draw_info(NDI_UNIQUE, 0,op,"Cast what spell?  Choose one of:");
    show_matching_spells(op, params);
    return 1;
}

/**************************************************************************/

/* Returns TRUE if the range specified (int r) is legal - that is,
 * the character has an item that is equipped for that range type.
 * return 0 if there is no item of that range type that is usable.
 * This function could probably be simplified, eg, everything
 * should index into the ranges[] array.
 */

int legal_range(object *op,int r) {

    switch(r) {
        case range_none: /* "Nothing" is always legal */
            return 1;
        case range_bow:
        case range_misc:
        case range_magic: /* cast spells */
            if (op->contr->ranges[r]) return 1;
            else return 0;

        case range_golem: /* Use scrolls */
            if (op->contr->ranges[range_golem] && 
                op->contr->ranges[range_golem]->count == op->contr->golem_count)
                    return 1;
            else 
                return 0;

        case range_skill:
            if (op->chosen_skill)
                return 1;
            else
                return 0;
    }
    /* No match above, must not be valid */
    return 0;
}

void change_spell(object *op,char k) {

    do {
        op->contr->shoottype += ((k == '+') ? 1 : -1);
        if(op->contr->shoottype >= range_size)
            op->contr->shoottype = range_none;
        else if (op->contr->shoottype <= range_bottom)
            op->contr->shoottype = (rangetype)(range_size-1);
    } while (!legal_range(op,op->contr->shoottype));

    /* Legal range has already checked that we have an appropriate item
     * that uses the slot, so we don't need to be too careful about 
     * checking the status of the object.
     */
    switch(op->contr->shoottype) {
        case range_none:
            new_draw_info(NDI_UNIQUE, 0,op, "No ranged attack chosen.");
            break;

        case range_golem:
            new_draw_info(NDI_UNIQUE, 0,op, "You regain control of your golem.");
            break;

        case range_bow:
            new_draw_info_format(NDI_UNIQUE, 0,op, "Switched to %s and %s.", query_name(op->contr->ranges[range_bow]),
                     op->contr->ranges[range_bow]->race ? op->contr->ranges[range_bow]->race : "nothing");
            break;

        case range_magic:
            new_draw_info_format(NDI_UNIQUE, 0,op,"Switched to spells (%s).",
                        op->contr->ranges[range_magic]->name);
            break;

        case range_misc:
            new_draw_info_format(NDI_UNIQUE, 0,op, "Switched to %s.", query_base_name(op->contr->ranges[range_misc], 0));
            break;

        case range_skill: 
            new_draw_info_format(NDI_UNIQUE, 0,op, "Switched to skill: %s", op->chosen_skill ?  
                 op->chosen_skill->name : "none");
            break;

        default:
            break;
    }
}


int command_rotateshoottype (object *op, char *params)
{
  if (!params)
      change_spell(op,'+');
  else
    change_spell(op, params[0]);
  return 0;
}

Revision:	1.2
Committed:	Sun Aug 13 17:16:04 2006 UTC (17 years, 9 months ago) by elmex
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+1 -1 lines
State:	*FILE REMOVED*
Log Message:	Made server compile with C++. Removed cfanim plugin and crossedit. C++ here we come.
#	Content
1	/*
2	* static char *rcsid_c_range_c =
3	* "$Id$";
4	*/
5
6	/*
7	CrossFire, A Multiplayer game for X-windows
8
9	Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10	Copyright (C) 1992 Frank Tore Johansen
11
12	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
14	the Free Software Foundation; either version 2 of the License, or
15	(at your option) any later version.
16
17	This program is distributed in the hope that it will be useful,
18	but WITHOUT ANY WARRANTY; without even the implied warranty of
19	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20	GNU General Public License for more details.
21
22	You should have received a copy of the GNU General Public License
23	along with this program; if not, write to the Free Software
24	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25
26	The authors can be reached via e-mail at crossfire-devel@real-time.com
27	*/
28
29	/* This file deals with range related commands (casting, shooting,
30	* throwing, etc.
31	*/
32
33	#include <global.h>
34	#ifndef __CEXTRACT__
35	#include <sproto.h>
36	#endif
37	#include <spells.h>
38	#include <skills.h>
39	#include <newclient.h>
40	#include <commands.h>
41
42
43	int command_invoke(object op, char params)
44	{
45	return command_cast_spell(op, params, 'i');
46	}
47
48	int command_cast(object op, char params)
49	{
50	return command_cast_spell(op, params, 'c');
51	}
52
53	int command_prepare(object op, char params)
54	{
55	return command_cast_spell(op, params, 'p');
56	}
57
58	/* 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
60	* them down to cleric/wizardry.
61	*/
62	static void show_matching_spells(object op, char params)
63	{
64	object *spell;
65	char spell_sort[NROFREALSPELLS][MAX_BUF], tmp[MAX_BUF], *cp;
66	int num_found=0, i;
67
68	/* We go and see what spells the player has. We put them
69	* into the spell_sort array so that we can sort them -
70	* we prefix the skill in the name so that the sorting
71	* works better.
72	*/
73	for (spell=op->inv; spell!=NULL; spell=spell->below) {
74	/* If it is a spell, and no params are passed, or they
75	* match the name, process this spell.
76	*/
77	if (spell->type == SPELL &&
78	(!params \|\| !strncmp(params, spell->name, strlen(params)))) {
79	if (spell->path_attuned & op->path_denied) {
80	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",
86	spell->name, spell->level,
87	SP_level_spellpoint_cost(op,spell, SPELL_HIGHEST));
88	}
89	}
90	}
91	if (!num_found) {
92	/* If a matching string was passed along, now try it without that
93	* string. It is odd to do something like 'cast trans',
94	* and it say you have no spells, when really, you do, but just
95	* nothing that matches.
96	*/
97	if (params)
98	show_matching_spells(op, NULL);
99	else
100	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	}
122	}
123
124
125
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,
128	* p=prepare). Invoke casts a spell immediately, where as cast (and I believe
129	* prepare) just set up the range type.
130	*/
131
132	int command_cast_spell (object op, char params, char command)
133	{
134	int castnow=0;
135	char *cp;
136	object *spob;
137
138	if (command=='i') castnow = 1;
139
140	/* Remove control of the golem */
141	if(op->contr->ranges[range_golem]!=NULL) {
142	if (op->contr->golem_count == op->contr->ranges[range_golem]->count) {
143	remove_friendly_object(op->contr->ranges[range_golem]);
144	remove_ob(op->contr->ranges[range_golem]);
145	free_object(op->contr->ranges[range_golem]);
146	}
147	op->contr->ranges[range_golem]=NULL;
148	op->contr->golem_count = 0;
149	}
150
151	if(params!=NULL) {
152	int spellnumber = 0;
153	if (spellnumber = atoi(params))
154	for (spob = op->inv; spob && spob->count != spellnumber; spob=spob->below);
155	else spob = lookup_spell_by_name(op, params);
156
157	if (spob && spob->type == SPELL) {
158	/* Now grab any extra data, if there is any. Forward pass
159	* any 'of' delimiter
160	*/
161	if (spellnumber) {
162	/* if we passed a number, the options start at the second word */
163	cp = strchr(params, ' ');
164	if (cp) {
165	cp++;
166	if (!strncmp(cp, "of ", 3)) cp+=3;
167	}
168	}
169	else if (strlen(params) > strlen(spob->name)) {
170	cp = params + strlen(spob->name);
171	*cp = 0;
172	cp++;
173	if (!strncmp(cp, "of ", 3)) cp+=3;
174	} else
175	cp = NULL;
176
177	if (spob->skill && !find_skill_by_name(op, spob->skill)) {
178	new_draw_info_format(NDI_UNIQUE, 0, op,
179	"You need the skill %s to cast %s!",
180	spob->skill, spob->name);
181	return 1;
182	}
183
184	if (castnow) {
185	cast_spell(op,op,op->facing,spob,cp);
186	} else {
187	op->contr->ranges[range_magic] = spob;
188	op->contr->shoottype = range_magic;
189	if(cp != NULL) {
190	strncpy(op->contr->spellparam, cp, MAX_BUF);
191	op->contr->spellparam[MAX_BUF-1] = '\0';
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;
199	} /* else fall through to below and print spells */
200	} /* params supplied */
201
202	/* 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.
204	*/
205	new_draw_info(NDI_UNIQUE, 0,op,"Cast what spell? Choose one of:");
206	show_matching_spells(op, params);
207	return 1;
208	}
209
210	/**************************************************************************/
211
212	/* Returns TRUE if the range specified (int r) is legal - that is,
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
219	int 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
247	void change_spell(object *op,char k) {
248
249	do {
250	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	}
293
294
295	int command_rotateshoottype (object op, char params)
296	{
297	if (!params)
298	change_spell(op,'+');
299	else
300	change_spell(op, params[0]);
301	return 0;
302	}
303