server/common/friend.C

/*
 * CrossFire, A Multiplayer game for X-windows
 * 
 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
 * 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>
 */

#include <global.h>

/*
 * Add a new friendly object to the linked list of friendly objects.
 * No checking to see if the object is already in the linked list is done.
 */
void
add_friendly_object (object *op)
{
  op->flag [FLAG_FRIENDLY] = 1;

  objectlink *ol;

  /* Add some error checking.  This shouldn't happen, but the friendly
   * object list usually isn't very long, and remove_friendly_object
   * won't remove it either.  Plus, it is easier to put a breakpoint in
   * the debugger here and see where the problem is happening. 
   */
  for (ol = first_friendly_object; ol; ol = ol->next)
    {
      if (ol->ob == op)
        {
          LOG (llevError, "add_friendly_object: Trying to add object already on list (%s)\n", &op->name);
          return;
        }
    }

  ol = first_friendly_object;
  first_friendly_object = get_objectlink ();
  first_friendly_object->ob = op;
  first_friendly_object->next = ol;
}

/*
 * Removes the specified object from the linked list of friendly objects.
 */
void
remove_friendly_object (object *op)
{
  objectlink *obj;

  CLEAR_FLAG (op, FLAG_FRIENDLY);

  if (op->type == GOLEM
      && op->owner
      && op->owner->contr
      && op->owner->contr->golem == op)
    op->owner->contr->golem = 0;

  if (!first_friendly_object)
    {
      LOG (llevError, "remove_friendly_object called with empty friendly list, remove ob=%s\n", &op->name);
      return;
    }

  /* if the first object happens to be the one, processing is pretty
   * easy.
   */
  if (first_friendly_object->ob == op)
    {
      obj = first_friendly_object;
      first_friendly_object = obj->next;
      delete obj;
    }
  else
    {
      objectlink *prev = first_friendly_object;

      for (obj = first_friendly_object->next; obj; obj = obj->next)
        {
          if (obj->ob == op)
            break;

          prev = obj;
        }

      if (obj)
        {
          prev->next = obj->next;
          delete obj;
        }
    }
}

/*
 * Dumps all friendly objects.
 */
void
dump_friendly_objects (void)
{
  objectlink *ol;

  for (ol = first_friendly_object; ol; ol = ol->next)
    LOG (llevError, "%s (%d)\n", &ol->ob->name, ol->ob->count);
}

/* New function, MSW 2000-1-14
 * It traverses the friendly list removing objects that should not be here
 * (ie, do not have friendly flag set, freed, etc)
 */
void
clean_friendly_list (void)
{
  objectlink *obj, *prev = NULL, *next;
  int count = 0;

  for (obj = first_friendly_object; obj; obj = next)
    {
      next = obj->next;
      if (QUERY_FLAG (obj->ob, FLAG_FREED) || !QUERY_FLAG (obj->ob, FLAG_FRIENDLY))
        {
          if (prev)
            prev->next = obj->next;
          else
            first_friendly_object = obj->next;

          count++;
          delete obj;
        }
      else
        /* If we removed the object, then prev is still valid.  */
        prev = obj;
    }

  if (count)
    LOG (llevDebug, "clean_friendly_list: Removed %d bogus links\n", count);
}

/* Checks if the given object is already in the friendly list or not
 * Lauwenmark - 31/07/05
 */
int
is_friendly (const object *op)
{
  objectlink *ol;

  for (ol = first_friendly_object; ol; ol = ol->next)
    if (ol->ob == op)
      return 1;

  return 0;
}

Revision:	1.12
Committed:	Mon Apr 30 04:25:29 2007 UTC (17 years, 2 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.11:	+2 -5 lines
Log Message:	This is the first rough cut of the skill use system (use the STABLE tag). Details will likely change, and combat skills do not work very well, but it works quite well. Players no longer have a shoottype or range slots, instead, each player has these members: combat_skill/combat_ob the currently selected skill (and weapon) for direct attacks. ranged_skill/ranged_ob the currently selected ranged skill (and bow/spell/item) golem the currently-controlled golem, if any.
#	Content
1	/*
2	* CrossFire, A Multiplayer game for X-windows
3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen
7	*
8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or
11	* (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>
23	*/
24
25	#include <global.h>
26
27	/*
28	* Add a new friendly object to the linked list of friendly objects.
29	* No checking to see if the object is already in the linked list is done.
30	*/
31	void
32	add_friendly_object (object *op)
33	{
34	op->flag [FLAG_FRIENDLY] = 1;
35
36	objectlink *ol;
37
38	/* Add some error checking. This shouldn't happen, but the friendly
39	* object list usually isn't very long, and remove_friendly_object
40	* won't remove it either. Plus, it is easier to put a breakpoint in
41	* the debugger here and see where the problem is happening.
42	*/
43	for (ol = first_friendly_object; ol; ol = ol->next)
44	{
45	if (ol->ob == op)
46	{
47	LOG (llevError, "add_friendly_object: Trying to add object already on list (%s)\n", &op->name);
48	return;
49	}
50	}
51
52	ol = first_friendly_object;
53	first_friendly_object = get_objectlink ();
54	first_friendly_object->ob = op;
55	first_friendly_object->next = ol;
56	}
57
58	/*
59	* Removes the specified object from the linked list of friendly objects.
60	*/
61	void
62	remove_friendly_object (object *op)
63	{
64	objectlink *obj;
65
66	CLEAR_FLAG (op, FLAG_FRIENDLY);
67
68	if (op->type == GOLEM
69	&& op->owner
70	&& op->owner->contr
71	&& op->owner->contr->golem == op)
72	op->owner->contr->golem = 0;
73
74	if (!first_friendly_object)
75	{
76	LOG (llevError, "remove_friendly_object called with empty friendly list, remove ob=%s\n", &op->name);
77	return;
78	}
79
80	/* if the first object happens to be the one, processing is pretty
81	* easy.
82	*/
83	if (first_friendly_object->ob == op)
84	{
85	obj = first_friendly_object;
86	first_friendly_object = obj->next;
87	delete obj;
88	}
89	else
90	{
91	objectlink *prev = first_friendly_object;
92
93	for (obj = first_friendly_object->next; obj; obj = obj->next)
94	{
95	if (obj->ob == op)
96	break;
97
98	prev = obj;
99	}
100
101	if (obj)
102	{
103	prev->next = obj->next;
104	delete obj;
105	}
106	}
107	}
108
109	/*
110	* Dumps all friendly objects.
111	*/
112	void
113	dump_friendly_objects (void)
114	{
115	objectlink *ol;
116
117	for (ol = first_friendly_object; ol; ol = ol->next)
118	LOG (llevError, "%s (%d)\n", &ol->ob->name, ol->ob->count);
119	}
120
121	/* New function, MSW 2000-1-14
122	* It traverses the friendly list removing objects that should not be here
123	* (ie, do not have friendly flag set, freed, etc)
124	*/
125	void
126	clean_friendly_list (void)
127	{
128	objectlink obj, prev = NULL, *next;
129	int count = 0;
130
131	for (obj = first_friendly_object; obj; obj = next)
132	{
133	next = obj->next;
134	if (QUERY_FLAG (obj->ob, FLAG_FREED) \|\| !QUERY_FLAG (obj->ob, FLAG_FRIENDLY))
135	{
136	if (prev)
137	prev->next = obj->next;
138	else
139	first_friendly_object = obj->next;
140
141	count++;
142	delete obj;
143	}
144	else
145	/* If we removed the object, then prev is still valid. */
146	prev = obj;
147	}
148
149	if (count)
150	LOG (llevDebug, "clean_friendly_list: Removed %d bogus links\n", count);
151	}
152
153	/* Checks if the given object is already in the friendly list or not
154	* Lauwenmark - 31/07/05
155	*/
156	int
157	is_friendly (const object *op)
158	{
159	objectlink *ol;
160
161	for (ol = first_friendly_object; ol; ol = ol->next)
162	if (ol->ob == op)
163	return 1;
164
165	return 0;
166	}
167