server/server/c_range.C


/*
 * static char *rcsid_c_range_c =
 *   "$Id: c_range.C,v 1.4 2006-09-07 10:01:57 pippijn Exp $";
 */

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