server/server/c_party.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>
#include <sproto.h>
#include <spells.h>

#ifdef COZY_SERVER
// used for pet monster logic etc.
int
same_party (partylist *a, partylist *b)
{
  return a == b && a;
}
#endif

static partylist *firstparty = NULL;    /* Keeps track of first party in list */
static partylist *lastparty = NULL;     /*Keeps track of last party in list */

partylist *
get_firstparty (void)
{
  return firstparty;
}

void remove_party (partylist *target_party);

/* Forms the party struct for a party called 'params'. it is the responsibility
 * of the caller to ensure that the name is unique, and that it is placed in the 
 * main party list correctly */
static partylist *
form_party (object *op, const char *params)
{
  partylist *newparty;

  newparty = (partylist *) malloc (sizeof (partylist));
  newparty->partyname = strdup (params);
  newparty->total_exp = 0;
  newparty->kills = 0;
  newparty->passwd[0] = '\0';
  newparty->next = NULL;
  newparty->partyleader = strdup (op->name);
  new_draw_info_format (NDI_UNIQUE, 0, op, "You have formed party: %s", newparty->partyname);
  op->contr->party = newparty;

  return newparty;
}

void
remove_party (partylist *target_party)
{
  partylist *tmpparty;
  partylist *previousparty;
  partylist *nextparty;

  if (firstparty == NULL)
    {
      LOG (llevError, "remove_party(): I was asked to remove party %s, but no parties are defined", target_party->partyname);
      return;
    }

  for_all_players (pl)
    if (pl->party == target_party)
      pl->party = NULL;

  /* special case-ism for parties at the beginning and end of the list */
  if (target_party == firstparty)
    {
      firstparty = firstparty->next;

      if (target_party->partyleader)
        free (target_party->partyleader);

      if (target_party->partyname)
        free (target_party->partyname);

      free (target_party);
      return;
    }
  else if (target_party == lastparty)
    {
      for (tmpparty = firstparty; tmpparty->next != NULL; tmpparty = tmpparty->next)
        {
          if (tmpparty->next == target_party)
            {
              lastparty = tmpparty;

              if (target_party->partyleader)
                free (target_party->partyleader);

              if (target_party->partyname)
                free (target_party->partyname);

              free (target_party);
              lastparty->next = NULL;
              return;
            }
        }
    }
  for (tmpparty = firstparty; tmpparty->next != NULL; tmpparty = tmpparty->next)
    if (tmpparty->next == target_party)
      {
        previousparty = tmpparty;
        nextparty = tmpparty->next->next;
        /* this should be safe, because we already dealt with the lastparty case */

        previousparty->next = nextparty;
        if (target_party->partyleader)
          free (target_party->partyleader);
        if (target_party->partyname)
          free (target_party->partyname);
        free (target_party);
        return;
      }
}

/* Remove unused parties, this could be made to scale a lot better. */
void
obsolete_parties (void)
{
  int player_count;
  partylist *party;
  partylist *next = NULL;

  if (!firstparty)
    return;                     /* we can't obsolete parties if there aren't any */
  for (party = firstparty; party != NULL; party = next)
    {
      next = party->next;
      player_count = 0;
      for_all_players (pl)
        if (pl->party == party)
          player_count++;
      if (player_count == 0)
        remove_party (party);
    }
}

void
add_kill_to_party (partylist *party, char *killer, char *dead, long exp)
{
  int i, pos;

  if (party == NULL)
    return;

  if (party->kills >= PARTY_KILL_LOG)
    {
      pos = PARTY_KILL_LOG - 1;
      for (i = 0; i < PARTY_KILL_LOG - 1; i++)
        party->party_kills[i] = party->party_kills[i + 1];
    }
  else
    pos = party->kills;

  party->kills++;
  party->total_exp += exp;
  party->party_kills[pos].exp = exp;
  assign (party->party_kills[pos].killer, killer);
  assign (party->party_kills[pos].dead, dead);
  party->party_kills[pos].killer[MAX_NAME] = 0;
  party->party_kills[pos].dead[MAX_NAME] = 0;
}

int
confirm_party_password (object *op)
{
  partylist *tmppartylist;

  for (tmppartylist = firstparty; tmppartylist != NULL; tmppartylist = tmppartylist->next)
    {
      if (!strcmp (op->contr->party_to_join->partyname, tmppartylist->partyname))
        {
          if (strcmp (op->contr->write_buf + 1, tmppartylist->passwd) == 0)
            return 0;
          else
            return 1;
        }
    }
  return 1;
}

void
receive_party_password (object *op, char k)
{

  if (confirm_party_password (op) == 0)
    {
      partylist *joined_party = op->contr->party_to_join;
      char buf[MAX_BUF];

      op->contr->party = op->contr->party_to_join;
      op->contr->party_to_join = NULL;
      new_draw_info_format (NDI_UNIQUE, 0, op, "You have joined party: %s\n", joined_party->partyname);
      snprintf (buf, MAX_BUF, "%s joins party %s", &op->name, joined_party->partyname);
      send_party_message (op, buf);
      op->contr->ns->state = ST_PLAYING;
      return;
    }
  else
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You entered the wrong password");
      op->contr->party_to_join = NULL;
      op->contr->ns->state = ST_PLAYING;
      return;
    }
}

void
send_party_message (object *op, char *msg)
{
  for_all_players (pl)
    if (pl->ob->contr->party == op->contr->party && pl->ob != op)
      new_draw_info (NDI_WHITE, 0, pl->ob, msg);
}

int
command_gsay (object *op, char *params)
{
  char party_params[MAX_BUF];

  if (!params)
    return 0;

  strcpy (party_params, "say ");
  strcat (party_params, params);
  command_party (op, party_params);
  return 0;
}

int
command_party (object *op, char *params)
{
  char buf[MAX_BUF];
  partylist *tmpparty, *oldparty;       /* For iterating over linked list */
  char *currentparty;           /* For iterating over linked list */

  if (params == NULL)
    {
      if (op->contr->party == NULL)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "You are not a member of any party.");
          new_draw_info (NDI_UNIQUE, 0, op, "For help try: party help");
        }
      else
        {
          currentparty = op->contr->party->partyname;
          new_draw_info_format (NDI_UNIQUE, 0, op, "You are a member of party %s.", currentparty);
        }
      return 1;
    }

  if (strcmp (params, "help") == 0)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "To form a party type: party form <partyname>");
      new_draw_info (NDI_UNIQUE, 0, op, "To join a party type: party join <partyname>");
      new_draw_info (NDI_UNIQUE, 0, op, "If the party has a passwd, it will you prompt you for it.");
      new_draw_info (NDI_UNIQUE, 0, op, "For a list of current parties type: party list");
      new_draw_info (NDI_UNIQUE, 0, op, "To leave a party type: party leave");
      new_draw_info (NDI_UNIQUE, 0, op, "To change a passwd for a party type: party passwd <password>");
      new_draw_info (NDI_UNIQUE, 0, op, "There is an 8 character max");
      new_draw_info (NDI_UNIQUE, 0, op, "To talk to party members type: party say <msg>");
      new_draw_info (NDI_UNIQUE, 0, op, "To see who is in your party: party who");
      new_draw_info (NDI_UNIQUE, 0, op, "To see what you've killed, type: party kills");
      return 1;
    }

  if (!strncmp (params, "kills", 5))
    {
      int i, max;
      char chr;
      char buffer[80];
      float exp;

      if (op->contr->party == NULL)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "You are not a member of any party.");
          return 1;
        }
      tmpparty = op->contr->party;
      if (!tmpparty->kills)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "You haven't killed anything yet.");
          return 1;
        }
      max = tmpparty->kills - 1;
      if (max > PARTY_KILL_LOG - 1)
        max = PARTY_KILL_LOG - 1;
      new_draw_info (NDI_UNIQUE, 0, op, "Killed          |          Killer|     Exp");
      new_draw_info (NDI_UNIQUE, 0, op, "----------------+----------------+--------");
      for (i = 0; i <= max; i++)
        {
          exp = tmpparty->party_kills[i].exp;
          chr = ' ';
          if (exp > 1000000)
            {
              exp /= 1000000;
              chr = 'M';
            }
          else if (exp > 1000)
            {
              exp /= 1000;
              chr = 'k';
            }
          sprintf (buffer, "%16s|%16s|%6.1f%c", tmpparty->party_kills[i].dead, tmpparty->party_kills[i].killer, exp, chr);
          new_draw_info (NDI_UNIQUE, 0, op, buffer);
        }
      exp = tmpparty->total_exp;
      chr = ' ';
      if (exp > 1000000)
        {
          exp /= 1000000;
          chr = 'M';
        }
      else if (exp > 1000)
        {
          exp /= 1000;
          chr = 'k';
        }
      new_draw_info (NDI_UNIQUE, 0, op, "----------------+----------------+--------");
      sprintf (buffer, "Totals: %d kills, %.1f%c exp", tmpparty->kills, exp, chr);
      new_draw_info (NDI_UNIQUE, 0, op, buffer);
      return 1;
    }

  if (strncmp (params, "say ", 4) == 0)
    {
      if (op->contr->party == NULL)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "You are not a member of any party.");
          return 1;
        }
      params += 4;
      currentparty = op->contr->party->partyname;
      snprintf (buf, MAX_BUF - 1, "[%s] %s says: %s", currentparty, &op->name, params);
      send_party_message (op, buf);
      new_draw_info_format (NDI_LT_GREEN | NDI_UNIQUE, 0, op, "[%s] You say: %s", currentparty, params);
      return 1;
    }

  if (strncmp (params, "form ", 5) == 0)
    {
      int player_count;

      params += 5;
      if (op->contr->party)
        oldparty = op->contr->party;
      else
        oldparty = NULL;

      if (firstparty)
        {
          for (tmpparty = firstparty; tmpparty != NULL; tmpparty = tmpparty->next)
            {
              if (!strcmp (tmpparty->partyname, params))
                {
                  new_draw_info_format (NDI_UNIQUE, 0, op, "The party %s already exists, pick another name", params);
                  return 1;
                }
            }
          lastparty->next = form_party (op, params);
          lastparty = lastparty->next;
        }
      else
        {
          firstparty = form_party (op, params);
          lastparty = firstparty;
        }
      /* 
       * The player might have previously been a member of a party, if so, he will be leaving
       * it, so check if there are any other members and if not, delete the party
       */
      player_count = 0;
      if (oldparty)
        {
          for_all_players (pl)
            if (pl->party == oldparty)
              player_count++;

          if (player_count == 0)
            remove_party (oldparty);
        }

      return 0;
    }                           /* form */

  if (strcmp (params, "leave") == 0)
    {
      if (op->contr->party == NULL)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "You are not a member of any party.");
          return 1;
        }
      currentparty = op->contr->party->partyname;
      new_draw_info_format (NDI_UNIQUE, 0, op, "You leave party %s.", currentparty);
      sprintf (buf, "%s leaves party %s.", &op->name, currentparty);
      send_party_message (op, buf);
      op->contr->party = NULL;
      return 1;
    }

  if (strcmp (params, "who") == 0)
    {
      tmpparty = op->contr->party;
      if (op->contr->party == NULL)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "You are not a member of any party.");
          return 1;
        }
      new_draw_info_format (NDI_UNIQUE, 0, op, "Members of party: %s.", op->contr->party->partyname);
      for_all_players (pl)
        if (pl->ob->contr->party == op->contr->party)
          {
            if (settings.set_title == TRUE)
              {
                if (pl->ob->contr->own_title[0] != '\0')
                  sprintf (buf, "%3d %s the %s", pl->ob->level, &pl->ob->name, pl->ob->contr->own_title);
                else
                  sprintf (buf, "%3d %s the %s", pl->ob->level, &pl->ob->name, pl->ob->contr->title);
              }
            else
              sprintf (buf, "%3d %s the %s", pl->ob->level, &pl->ob->name, pl->ob->contr->title);
            new_draw_info (NDI_UNIQUE, 0, op, buf);
          }
      return 1;
    }                           /* leave */

  if (strncmp (params, "passwd ", 7) == 0)
    {
      partylist *tmplist;

      params += 7;

      if (op->contr->party == NULL)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "You are not a member of a party");
          return 1;
        }

      if (strlen (params) > 8)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "The password must not exceed 8 characters");
          return 1;
        }

      tmplist = firstparty;
      while (tmplist != NULL)
        {
          if (tmplist == op->contr->party)
            {
              strcpy (tmplist->passwd, params);
              new_draw_info_format (NDI_UNIQUE, 0, op, "The password for party %s is %s", tmplist->partyname, tmplist->passwd);
              snprintf (buf, MAX_BUF, "Password for party %s is now %s, changed by %s", tmplist->partyname, tmplist->passwd, &op->name);
              send_party_message (op, buf);
              return 0;
            }
          tmplist = tmplist->next;
        }
      return 0;
    }                           /* passwd */

  if (strcmp (params, "list") == 0)
    {
      partylist *tmplist;

      tmplist = firstparty;

      if (firstparty == NULL)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "There are no parties active right now");
          return 1;
        }

      new_draw_info (NDI_UNIQUE, 0, op, "Party name                       Leader");
      new_draw_info (NDI_UNIQUE, 0, op, "----------                       ------");

      while (tmplist != NULL)
        {
          new_draw_info_format (NDI_UNIQUE, 0, op, "%-32s %s", tmplist->partyname, tmplist->partyleader);
          tmplist = tmplist->next;
        }
      return 0;
    }                           /* list */

  if (strncmp (params, "join ", 5) == 0)
    {

      params += 5;

      /* Can't join a party cause non exist */
      if (firstparty == NULL)
        {
          new_draw_info_format (NDI_UNIQUE, 0, op, "Party: %s does not exist.  You must form it first", params);
          return 1;
        }

      /* Special case if thier is only one party */
      if (firstparty->next == NULL)
        {
          if (strcmp (firstparty->partyname, params) != 0)
            {
              new_draw_info_format (NDI_UNIQUE, 0, op, "Party: %s does not exist. You must form it first", params);
              return 1;
            }
          else
            {
              if (op->contr->party == firstparty)
                {
                  new_draw_info_format (NDI_UNIQUE, 0, op, "You are already in party: %s", firstparty->partyname);
                  return 1;
                }
              /* found party player wants to join */
              if (firstparty->passwd[0] == '\0')
                {
                  op->contr->party = firstparty;
                  new_draw_info_format (NDI_UNIQUE, 0, op, "You have joined party: %s", firstparty->partyname);
                  snprintf (buf, MAX_BUF, "%s joins party %s", &op->name, firstparty->partyname);
                  send_party_message (op, buf);
                  return 0;
                }
              else
                {
                  get_party_password (op, firstparty);
                  return 0;
                }
            }
        }

      tmpparty = firstparty;
      while (tmpparty != NULL)
        {
          if (strcmp (tmpparty->partyname, params) == 0)
            {
              if (op->contr->party == tmpparty)
                {
                  new_draw_info_format (NDI_UNIQUE, 0, op, "You are already a member of party: %s", tmpparty->partyname);
                  return 1;
                }
              else
                {
                  if (tmpparty->passwd[0] == '\0')
                    {
                      new_draw_info_format (NDI_UNIQUE, 0, op, "You have joined party: %s", tmpparty->partyname);
                      op->contr->party = tmpparty;
                      snprintf (buf, MAX_BUF, "%s joins party %s", &op->name, tmpparty->partyname);
                      send_party_message (op, buf);
                      return 0;
                    }
                  else
                    {
                      get_party_password (op, tmpparty);
                      return 0;
                    }
                }
            }
          else
            tmpparty = tmpparty->next;
        }

      new_draw_info_format (NDI_UNIQUE, 0, op, "Party %s does not exist.  You must form it first.", params);
      return 1;
    }                           /* join */

  new_draw_info (NDI_UNIQUE, 0, op, "To form a party type: party form <partyname>");
  new_draw_info (NDI_UNIQUE, 0, op, "To join a party type: party join <partyname>");
  new_draw_info (NDI_UNIQUE, 0, op, "If the party has a passwd, it will you prompt you for it.");
  new_draw_info (NDI_UNIQUE, 0, op, "For a list of current parties type: party list");
  new_draw_info (NDI_UNIQUE, 0, op, "To leave a party type: party leave");
  new_draw_info (NDI_UNIQUE, 0, op, "To change a passwd for a party type: party passwd <password>");
  new_draw_info (NDI_UNIQUE, 0, op, "There is an 8 character max");
  new_draw_info (NDI_UNIQUE, 0, op, "To talk to party members type: party say <msg>");
  new_draw_info (NDI_UNIQUE, 0, op, "To see who is in your party: party who");
  new_draw_info (NDI_UNIQUE, 0, op, "To see what you've killed, type: party kills");
  return 1;
}
Revision:	1.16
Committed:	Thu Mar 1 12:28:16 2007 UTC (17 years, 2 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_0
Changes since 1.15:	+0 -7 lines
Log Message:	nano-cleanups
#	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	#include <sproto.h>
27	#include <spells.h>
28
29	#ifdef COZY_SERVER
30	// used for pet monster logic etc.
31	int
32	same_party (partylist a, partylist b)
33	{
34	return a == b && a;
35	}
36	#endif
37
38	static partylist firstparty = NULL; / Keeps track of first party in list */
39	static partylist lastparty = NULL; /Keeps track of last party in list */
40
41	partylist *
42	get_firstparty (void)
43	{
44	return firstparty;
45	}
46
47	void remove_party (partylist *target_party);
48
49	/* Forms the party struct for a party called 'params'. it is the responsibility
50	* of the caller to ensure that the name is unique, and that it is placed in the
51	* main party list correctly */
52	static partylist *
53	form_party (object op, const char params)
54	{
55	partylist *newparty;
56
57	newparty = (partylist *) malloc (sizeof (partylist));
58	newparty->partyname = strdup (params);
59	newparty->total_exp = 0;
60	newparty->kills = 0;
61	newparty->passwd[0] = '\0';
62	newparty->next = NULL;
63	newparty->partyleader = strdup (op->name);
64	new_draw_info_format (NDI_UNIQUE, 0, op, "You have formed party: %s", newparty->partyname);
65	op->contr->party = newparty;
66
67	return newparty;
68	}
69
70	void
71	remove_party (partylist *target_party)
72	{
73	partylist *tmpparty;
74	partylist *previousparty;
75	partylist *nextparty;
76
77	if (firstparty == NULL)
78	{
79	LOG (llevError, "remove_party(): I was asked to remove party %s, but no parties are defined", target_party->partyname);
80	return;
81	}
82
83	for_all_players (pl)
84	if (pl->party == target_party)
85	pl->party = NULL;
86
87	/* special case-ism for parties at the beginning and end of the list */
88	if (target_party == firstparty)
89	{
90	firstparty = firstparty->next;
91
92	if (target_party->partyleader)
93	free (target_party->partyleader);
94
95	if (target_party->partyname)
96	free (target_party->partyname);
97
98	free (target_party);
99	return;
100	}
101	else if (target_party == lastparty)
102	{
103	for (tmpparty = firstparty; tmpparty->next != NULL; tmpparty = tmpparty->next)
104	{
105	if (tmpparty->next == target_party)
106	{
107	lastparty = tmpparty;
108
109	if (target_party->partyleader)
110	free (target_party->partyleader);
111
112	if (target_party->partyname)
113	free (target_party->partyname);
114
115	free (target_party);
116	lastparty->next = NULL;
117	return;
118	}
119	}
120	}
121	for (tmpparty = firstparty; tmpparty->next != NULL; tmpparty = tmpparty->next)
122	if (tmpparty->next == target_party)
123	{
124	previousparty = tmpparty;
125	nextparty = tmpparty->next->next;
126	/* this should be safe, because we already dealt with the lastparty case */
127
128	previousparty->next = nextparty;
129	if (target_party->partyleader)
130	free (target_party->partyleader);
131	if (target_party->partyname)
132	free (target_party->partyname);
133	free (target_party);
134	return;
135	}
136	}
137
138	/* Remove unused parties, this could be made to scale a lot better. */
139	void
140	obsolete_parties (void)
141	{
142	int player_count;
143	partylist *party;
144	partylist *next = NULL;
145
146	if (!firstparty)
147	return; /* we can't obsolete parties if there aren't any */
148	for (party = firstparty; party != NULL; party = next)
149	{
150	next = party->next;
151	player_count = 0;
152	for_all_players (pl)
153	if (pl->party == party)
154	player_count++;
155	if (player_count == 0)
156	remove_party (party);
157	}
158	}
159
160	void
161	add_kill_to_party (partylist party, char killer, char *dead, long exp)
162	{
163	int i, pos;
164
165	if (party == NULL)
166	return;
167
168	if (party->kills >= PARTY_KILL_LOG)
169	{
170	pos = PARTY_KILL_LOG - 1;
171	for (i = 0; i < PARTY_KILL_LOG - 1; i++)
172	party->party_kills[i] = party->party_kills[i + 1];
173	}
174	else
175	pos = party->kills;
176
177	party->kills++;
178	party->total_exp += exp;
179	party->party_kills[pos].exp = exp;
180	assign (party->party_kills[pos].killer, killer);
181	assign (party->party_kills[pos].dead, dead);
182	party->party_kills[pos].killer[MAX_NAME] = 0;
183	party->party_kills[pos].dead[MAX_NAME] = 0;
184	}
185
186	int
187	confirm_party_password (object *op)
188	{
189	partylist *tmppartylist;
190
191	for (tmppartylist = firstparty; tmppartylist != NULL; tmppartylist = tmppartylist->next)
192	{
193	if (!strcmp (op->contr->party_to_join->partyname, tmppartylist->partyname))
194	{
195	if (strcmp (op->contr->write_buf + 1, tmppartylist->passwd) == 0)
196	return 0;
197	else
198	return 1;
199	}
200	}
201	return 1;
202	}
203
204	void
205	receive_party_password (object *op, char k)
206	{
207
208	if (confirm_party_password (op) == 0)
209	{
210	partylist *joined_party = op->contr->party_to_join;
211	char buf[MAX_BUF];
212
213	op->contr->party = op->contr->party_to_join;
214	op->contr->party_to_join = NULL;
215	new_draw_info_format (NDI_UNIQUE, 0, op, "You have joined party: %s\n", joined_party->partyname);
216	snprintf (buf, MAX_BUF, "%s joins party %s", &op->name, joined_party->partyname);
217	send_party_message (op, buf);
218	op->contr->ns->state = ST_PLAYING;
219	return;
220	}
221	else
222	{
223	new_draw_info (NDI_UNIQUE, 0, op, "You entered the wrong password");
224	op->contr->party_to_join = NULL;
225	op->contr->ns->state = ST_PLAYING;
226	return;
227	}
228	}
229
230	void
231	send_party_message (object op, char msg)
232	{
233	for_all_players (pl)
234	if (pl->ob->contr->party == op->contr->party && pl->ob != op)
235	new_draw_info (NDI_WHITE, 0, pl->ob, msg);
236	}
237
238	int
239	command_gsay (object op, char params)
240	{
241	char party_params[MAX_BUF];
242
243	if (!params)
244	return 0;
245
246	strcpy (party_params, "say ");
247	strcat (party_params, params);
248	command_party (op, party_params);
249	return 0;
250	}
251
252	int
253	command_party (object op, char params)
254	{
255	char buf[MAX_BUF];
256	partylist tmpparty, oldparty; /* For iterating over linked list */
257	char currentparty; / For iterating over linked list */
258
259	if (params == NULL)
260	{
261	if (op->contr->party == NULL)
262	{
263	new_draw_info (NDI_UNIQUE, 0, op, "You are not a member of any party.");
264	new_draw_info (NDI_UNIQUE, 0, op, "For help try: party help");
265	}
266	else
267	{
268	currentparty = op->contr->party->partyname;
269	new_draw_info_format (NDI_UNIQUE, 0, op, "You are a member of party %s.", currentparty);
270	}
271	return 1;
272	}
273
274	if (strcmp (params, "help") == 0)
275	{
276	new_draw_info (NDI_UNIQUE, 0, op, "To form a party type: party form <partyname>");
277	new_draw_info (NDI_UNIQUE, 0, op, "To join a party type: party join <partyname>");
278	new_draw_info (NDI_UNIQUE, 0, op, "If the party has a passwd, it will you prompt you for it.");
279	new_draw_info (NDI_UNIQUE, 0, op, "For a list of current parties type: party list");
280	new_draw_info (NDI_UNIQUE, 0, op, "To leave a party type: party leave");
281	new_draw_info (NDI_UNIQUE, 0, op, "To change a passwd for a party type: party passwd <password>");
282	new_draw_info (NDI_UNIQUE, 0, op, "There is an 8 character max");
283	new_draw_info (NDI_UNIQUE, 0, op, "To talk to party members type: party say <msg>");
284	new_draw_info (NDI_UNIQUE, 0, op, "To see who is in your party: party who");
285	new_draw_info (NDI_UNIQUE, 0, op, "To see what you've killed, type: party kills");
286	return 1;
287	}
288
289	if (!strncmp (params, "kills", 5))
290	{
291	int i, max;
292	char chr;
293	char buffer[80];
294	float exp;
295
296	if (op->contr->party == NULL)
297	{
298	new_draw_info (NDI_UNIQUE, 0, op, "You are not a member of any party.");
299	return 1;
300	}
301	tmpparty = op->contr->party;
302	if (!tmpparty->kills)
303	{
304	new_draw_info (NDI_UNIQUE, 0, op, "You haven't killed anything yet.");
305	return 1;
306	}
307	max = tmpparty->kills - 1;
308	if (max > PARTY_KILL_LOG - 1)
309	max = PARTY_KILL_LOG - 1;
310	new_draw_info (NDI_UNIQUE, 0, op, "Killed \| Killer\| Exp");
311	new_draw_info (NDI_UNIQUE, 0, op, "----------------+----------------+--------");
312	for (i = 0; i <= max; i++)
313	{
314	exp = tmpparty->party_kills[i].exp;
315	chr = ' ';
316	if (exp > 1000000)
317	{
318	exp /= 1000000;
319	chr = 'M';
320	}
321	else if (exp > 1000)
322	{
323	exp /= 1000;
324	chr = 'k';
325	}
326	sprintf (buffer, "%16s\|%16s\|%6.1f%c", tmpparty->party_kills[i].dead, tmpparty->party_kills[i].killer, exp, chr);
327	new_draw_info (NDI_UNIQUE, 0, op, buffer);
328	}
329	exp = tmpparty->total_exp;
330	chr = ' ';
331	if (exp > 1000000)
332	{
333	exp /= 1000000;
334	chr = 'M';
335	}
336	else if (exp > 1000)
337	{
338	exp /= 1000;
339	chr = 'k';
340	}
341	new_draw_info (NDI_UNIQUE, 0, op, "----------------+----------------+--------");
342	sprintf (buffer, "Totals: %d kills, %.1f%c exp", tmpparty->kills, exp, chr);
343	new_draw_info (NDI_UNIQUE, 0, op, buffer);
344	return 1;
345	}
346
347	if (strncmp (params, "say ", 4) == 0)
348	{
349	if (op->contr->party == NULL)
350	{
351	new_draw_info (NDI_UNIQUE, 0, op, "You are not a member of any party.");
352	return 1;
353	}
354	params += 4;
355	currentparty = op->contr->party->partyname;
356	snprintf (buf, MAX_BUF - 1, "[%s] %s says: %s", currentparty, &op->name, params);
357	send_party_message (op, buf);
358	new_draw_info_format (NDI_LT_GREEN \| NDI_UNIQUE, 0, op, "[%s] You say: %s", currentparty, params);
359	return 1;
360	}
361
362	if (strncmp (params, "form ", 5) == 0)
363	{
364	int player_count;
365
366	params += 5;
367	if (op->contr->party)
368	oldparty = op->contr->party;
369	else
370	oldparty = NULL;
371
372	if (firstparty)
373	{
374	for (tmpparty = firstparty; tmpparty != NULL; tmpparty = tmpparty->next)
375	{
376	if (!strcmp (tmpparty->partyname, params))
377	{
378	new_draw_info_format (NDI_UNIQUE, 0, op, "The party %s already exists, pick another name", params);
379	return 1;
380	}
381	}
382	lastparty->next = form_party (op, params);
383	lastparty = lastparty->next;
384	}
385	else
386	{
387	firstparty = form_party (op, params);
388	lastparty = firstparty;
389	}
390	/*
391	* The player might have previously been a member of a party, if so, he will be leaving
392	* it, so check if there are any other members and if not, delete the party
393	*/
394	player_count = 0;
395	if (oldparty)
396	{
397	for_all_players (pl)
398	if (pl->party == oldparty)
399	player_count++;
400
401	if (player_count == 0)
402	remove_party (oldparty);
403	}
404
405	return 0;
406	} /* form */
407
408	if (strcmp (params, "leave") == 0)
409	{
410	if (op->contr->party == NULL)
411	{
412	new_draw_info (NDI_UNIQUE, 0, op, "You are not a member of any party.");
413	return 1;
414	}
415	currentparty = op->contr->party->partyname;
416	new_draw_info_format (NDI_UNIQUE, 0, op, "You leave party %s.", currentparty);
417	sprintf (buf, "%s leaves party %s.", &op->name, currentparty);
418	send_party_message (op, buf);
419	op->contr->party = NULL;
420	return 1;
421	}
422
423	if (strcmp (params, "who") == 0)
424	{
425	tmpparty = op->contr->party;
426	if (op->contr->party == NULL)
427	{
428	new_draw_info (NDI_UNIQUE, 0, op, "You are not a member of any party.");
429	return 1;
430	}
431	new_draw_info_format (NDI_UNIQUE, 0, op, "Members of party: %s.", op->contr->party->partyname);
432	for_all_players (pl)
433	if (pl->ob->contr->party == op->contr->party)
434	{
435	if (settings.set_title == TRUE)
436	{
437	if (pl->ob->contr->own_title[0] != '\0')
438	sprintf (buf, "%3d %s the %s", pl->ob->level, &pl->ob->name, pl->ob->contr->own_title);
439	else
440	sprintf (buf, "%3d %s the %s", pl->ob->level, &pl->ob->name, pl->ob->contr->title);
441	}
442	else
443	sprintf (buf, "%3d %s the %s", pl->ob->level, &pl->ob->name, pl->ob->contr->title);
444	new_draw_info (NDI_UNIQUE, 0, op, buf);
445	}
446	return 1;
447	} /* leave */
448
449	if (strncmp (params, "passwd ", 7) == 0)
450	{
451	partylist *tmplist;
452
453	params += 7;
454
455	if (op->contr->party == NULL)
456	{
457	new_draw_info (NDI_UNIQUE, 0, op, "You are not a member of a party");
458	return 1;
459	}
460
461	if (strlen (params) > 8)
462	{
463	new_draw_info (NDI_UNIQUE, 0, op, "The password must not exceed 8 characters");
464	return 1;
465	}
466
467	tmplist = firstparty;
468	while (tmplist != NULL)
469	{
470	if (tmplist == op->contr->party)
471	{
472	strcpy (tmplist->passwd, params);
473	new_draw_info_format (NDI_UNIQUE, 0, op, "The password for party %s is %s", tmplist->partyname, tmplist->passwd);
474	snprintf (buf, MAX_BUF, "Password for party %s is now %s, changed by %s", tmplist->partyname, tmplist->passwd, &op->name);
475	send_party_message (op, buf);
476	return 0;
477	}
478	tmplist = tmplist->next;
479	}
480	return 0;
481	} /* passwd */
482
483	if (strcmp (params, "list") == 0)
484	{
485	partylist *tmplist;
486
487	tmplist = firstparty;
488
489	if (firstparty == NULL)
490	{
491	new_draw_info (NDI_UNIQUE, 0, op, "There are no parties active right now");
492	return 1;
493	}
494
495	new_draw_info (NDI_UNIQUE, 0, op, "Party name Leader");
496	new_draw_info (NDI_UNIQUE, 0, op, "---------- ------");
497
498	while (tmplist != NULL)
499	{
500	new_draw_info_format (NDI_UNIQUE, 0, op, "%-32s %s", tmplist->partyname, tmplist->partyleader);
501	tmplist = tmplist->next;
502	}
503	return 0;
504	} /* list */
505
506	if (strncmp (params, "join ", 5) == 0)
507	{
508
509	params += 5;
510
511	/* Can't join a party cause non exist */
512	if (firstparty == NULL)
513	{
514	new_draw_info_format (NDI_UNIQUE, 0, op, "Party: %s does not exist. You must form it first", params);
515	return 1;
516	}
517
518	/* Special case if thier is only one party */
519	if (firstparty->next == NULL)
520	{
521	if (strcmp (firstparty->partyname, params) != 0)
522	{
523	new_draw_info_format (NDI_UNIQUE, 0, op, "Party: %s does not exist. You must form it first", params);
524	return 1;
525	}
526	else
527	{
528	if (op->contr->party == firstparty)
529	{
530	new_draw_info_format (NDI_UNIQUE, 0, op, "You are already in party: %s", firstparty->partyname);
531	return 1;
532	}
533	/* found party player wants to join */
534	if (firstparty->passwd[0] == '\0')
535	{
536	op->contr->party = firstparty;
537	new_draw_info_format (NDI_UNIQUE, 0, op, "You have joined party: %s", firstparty->partyname);
538	snprintf (buf, MAX_BUF, "%s joins party %s", &op->name, firstparty->partyname);
539	send_party_message (op, buf);
540	return 0;
541	}
542	else
543	{
544	get_party_password (op, firstparty);
545	return 0;
546	}
547	}
548	}
549
550	tmpparty = firstparty;
551	while (tmpparty != NULL)
552	{
553	if (strcmp (tmpparty->partyname, params) == 0)
554	{
555	if (op->contr->party == tmpparty)
556	{
557	new_draw_info_format (NDI_UNIQUE, 0, op, "You are already a member of party: %s", tmpparty->partyname);
558	return 1;
559	}
560	else
561	{
562	if (tmpparty->passwd[0] == '\0')
563	{
564	new_draw_info_format (NDI_UNIQUE, 0, op, "You have joined party: %s", tmpparty->partyname);
565	op->contr->party = tmpparty;
566	snprintf (buf, MAX_BUF, "%s joins party %s", &op->name, tmpparty->partyname);
567	send_party_message (op, buf);
568	return 0;
569	}
570	else
571	{
572	get_party_password (op, tmpparty);
573	return 0;
574	}
575	}
576	}
577	else
578	tmpparty = tmpparty->next;
579	}
580
581	new_draw_info_format (NDI_UNIQUE, 0, op, "Party %s does not exist. You must form it first.", params);
582	return 1;
583	} /* join */
584
585	new_draw_info (NDI_UNIQUE, 0, op, "To form a party type: party form <partyname>");
586	new_draw_info (NDI_UNIQUE, 0, op, "To join a party type: party join <partyname>");
587	new_draw_info (NDI_UNIQUE, 0, op, "If the party has a passwd, it will you prompt you for it.");
588	new_draw_info (NDI_UNIQUE, 0, op, "For a list of current parties type: party list");
589	new_draw_info (NDI_UNIQUE, 0, op, "To leave a party type: party leave");
590	new_draw_info (NDI_UNIQUE, 0, op, "To change a passwd for a party type: party passwd <password>");
591	new_draw_info (NDI_UNIQUE, 0, op, "There is an 8 character max");
592	new_draw_info (NDI_UNIQUE, 0, op, "To talk to party members type: party say <msg>");
593	new_draw_info (NDI_UNIQUE, 0, op, "To see who is in your party: party who");
594	new_draw_info (NDI_UNIQUE, 0, op, "To see what you've killed, type: party kills");
595	return 1;
596	}