server/server/c_range.C

/*
    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@schmorp.de>
*/

/* 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])
    {
      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] = 0;
    }

  if (params != NULL)
    {
      int spellnumber = 0;

      if ((spellnumber = atoi (params)))
        for (spob = op->inv; spob && spob->count != spellnumber; spob = spob->below)
          /* nop */;
      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;
              assign (op->contr->spellparam, cp ? cp : "");
              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 */
          return !!op->contr->ranges[r];

        case range_golem:      /* Use scrolls */
          return !!op->contr->ranges[range_golem];

        case range_skill:
          return !!op->chosen_skill;
    }

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