server/common/friend.C

/*
 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Crossfire TRT 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 3 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, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <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 | logBacktrace, "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.16
Committed:	Sun Jul 1 05:00:17 2007 UTC (16 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_2, rel-2_3
Changes since 1.15:	+11 -12 lines
Log Message:	- upgrade crossfire trt to the GPL version 3 (hopefully correctly). - add a single file covered by the GNU Affero General Public License (which is not yet released, so I used the current draft, which is legally a bit wavy, but its likely better than nothing as it expresses direct intent by the authors, and we can upgrade as soon as it has been released). * this should ensure availability of source code for the server at least and hopefully also archetypes and maps even when modified versions are not being distributed, in accordance of section 13 of the agplv3.
#	Content
1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*
8	* Crossfire TRT 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 3 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, see <http://www.gnu.org/licenses/>.
20	*
21	* The authors can be reached via e-mail to <crossfire@schmorp.de>
22	*/
23
24	#include <global.h>
25
26	/*
27	* Add a new friendly object to the linked list of friendly objects.
28	* No checking to see if the object is already in the linked list is done.
29	*/
30	void
31	add_friendly_object (object *op)
32	{
33	op->flag [FLAG_FRIENDLY] = 1;
34
35	objectlink *ol;
36
37	/* Add some error checking. This shouldn't happen, but the friendly
38	* object list usually isn't very long, and remove_friendly_object
39	* won't remove it either. Plus, it is easier to put a breakpoint in
40	* the debugger here and see where the problem is happening.
41	*/
42	for (ol = first_friendly_object; ol; ol = ol->next)
43	{
44	if (ol->ob == op)
45	{
46	LOG (llevError \| logBacktrace, "add_friendly_object: Trying to add object already on list (%s)\n", &op->name);
47	return;
48	}
49	}
50
51	ol = first_friendly_object;
52	first_friendly_object = get_objectlink ();
53	first_friendly_object->ob = op;
54	first_friendly_object->next = ol;
55	}
56
57	/*
58	* Removes the specified object from the linked list of friendly objects.
59	*/
60	void
61	remove_friendly_object (object *op)
62	{
63	objectlink *obj;
64
65	CLEAR_FLAG (op, FLAG_FRIENDLY);
66
67	if (op->type == GOLEM
68	&& op->owner
69	&& op->owner->contr
70	&& op->owner->contr->golem == op)
71	op->owner->contr->golem = 0;
72
73	if (!first_friendly_object)
74	{
75	LOG (llevError, "remove_friendly_object called with empty friendly list, remove ob=%s\n", &op->name);
76	return;
77	}
78
79	/* if the first object happens to be the one, processing is pretty
80	* easy.
81	*/
82	if (first_friendly_object->ob == op)
83	{
84	obj = first_friendly_object;
85	first_friendly_object = obj->next;
86	delete obj;
87	}
88	else
89	{
90	objectlink *prev = first_friendly_object;
91
92	for (obj = first_friendly_object->next; obj; obj = obj->next)
93	{
94	if (obj->ob == op)
95	break;
96
97	prev = obj;
98	}
99
100	if (obj)
101	{
102	prev->next = obj->next;
103	delete obj;
104	}
105	}
106	}
107
108	/*
109	* Dumps all friendly objects.
110	*/
111	void
112	dump_friendly_objects (void)
113	{
114	objectlink *ol;
115
116	for (ol = first_friendly_object; ol; ol = ol->next)
117	LOG (llevError, "%s (%d)\n", &ol->ob->name, ol->ob->count);
118	}
119
120	/* New function, MSW 2000-1-14
121	* It traverses the friendly list removing objects that should not be here
122	* (ie, do not have friendly flag set, freed, etc)
123	*/
124	void
125	clean_friendly_list (void)
126	{
127	objectlink obj, prev = NULL, *next;
128	int count = 0;
129
130	for (obj = first_friendly_object; obj; obj = next)
131	{
132	next = obj->next;
133	if (QUERY_FLAG (obj->ob, FLAG_FREED) \|\| !QUERY_FLAG (obj->ob, FLAG_FRIENDLY))
134	{
135	if (prev)
136	prev->next = obj->next;
137	else
138	first_friendly_object = obj->next;
139
140	count++;
141	delete obj;
142	}
143	else
144	/* If we removed the object, then prev is still valid. */
145	prev = obj;
146	}
147
148	if (count)
149	LOG (llevDebug, "clean_friendly_list: Removed %d bogus links\n", count);
150	}
151
152	/* Checks if the given object is already in the friendly list or not
153	* Lauwenmark - 31/07/05
154	*/
155	int
156	is_friendly (const object *op)
157	{
158	objectlink *ol;
159
160	for (ol = first_friendly_object; ol; ol = ol->next)
161	if (ol->ob == op)
162	return 1;
163
164	return 0;
165	}
166