710 lines
25 KiB
C
710 lines
25 KiB
C
/*
|
|
* static char *rcsid_c_party_c =
|
|
* "$Id: c_party.c 11876 2009-06-14 19:42:19Z akirschbaum $";
|
|
*/
|
|
|
|
/*
|
|
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
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* Party-related functions and variables.
|
|
*/
|
|
|
|
#include <global.h>
|
|
#ifndef __CEXTRACT__
|
|
#include <sproto.h>
|
|
#endif
|
|
#include <spells.h>
|
|
|
|
static partylist *firstparty = NULL; /**< Keeps track of first party in list */
|
|
static partylist *lastparty = NULL; /**< Keeps track of last party in list */
|
|
|
|
/**
|
|
* Simple wrapper to get ::firstparty.
|
|
* @return
|
|
* ::firstparty.
|
|
*/
|
|
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.
|
|
* New item is placed on the party list.
|
|
* @param op
|
|
* party creator.
|
|
* @param params
|
|
* party name.
|
|
* @return
|
|
* new party.
|
|
*/
|
|
partylist *form_party(object *op, const char *params) {
|
|
partylist *newparty;
|
|
|
|
if (op->contr->party != NULL) {
|
|
char buf[MAX_BUF];
|
|
|
|
snprintf(buf, sizeof(buf), "%s leaves party %s.", op->name, op->contr->party->partyname);
|
|
send_party_message(op, buf);
|
|
}
|
|
newparty = (partylist *)malloc(sizeof(partylist));
|
|
newparty->partyname = strdup_local(params);
|
|
replace_unprintable_chars(newparty->partyname);
|
|
newparty->total_exp = 0;
|
|
newparty->kills = 0;
|
|
newparty->passwd[0] = '\0';
|
|
newparty->next = NULL;
|
|
newparty->partyleader = strdup_local(op->name);
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"You have formed party: %s",
|
|
"You have formed party: %s",
|
|
newparty->partyname);
|
|
op->contr->party = newparty;
|
|
|
|
if (lastparty) {
|
|
lastparty->next = newparty;
|
|
lastparty = lastparty->next;
|
|
} else {
|
|
firstparty = newparty;
|
|
lastparty = firstparty;
|
|
}
|
|
|
|
return newparty;
|
|
}
|
|
|
|
/**
|
|
* Remove and free party.
|
|
*
|
|
* @param target_party
|
|
* party to remove.
|
|
* @todo clean/simplify the mess.
|
|
*/
|
|
void remove_party(partylist *target_party) {
|
|
partylist *tmpparty;
|
|
partylist *previousparty;
|
|
partylist *nextparty;
|
|
player *pl;
|
|
|
|
if (firstparty == NULL) {
|
|
LOG(llevError, "remove_party(): I was asked to remove party %s, but no parties are defined\n",
|
|
target_party->partyname);
|
|
return;
|
|
}
|
|
for (pl = first_player; pl != NULL; pl = pl->next)
|
|
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) {
|
|
if (lastparty == target_party)
|
|
lastparty = NULL;
|
|
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 (no players), this could be made to scale a lot better.
|
|
*/
|
|
void obsolete_parties(void) {
|
|
int player_count;
|
|
player *pl;
|
|
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 (pl = first_player; pl != NULL; pl = pl->next)
|
|
if (pl->party == party)
|
|
player_count++;
|
|
if (player_count == 0)
|
|
remove_party(party);
|
|
}
|
|
}
|
|
|
|
#ifdef PARTY_KILL_LOG
|
|
/**
|
|
* Logs a kill for a party.
|
|
*
|
|
* @param party
|
|
* party to log for.
|
|
* @param killer
|
|
* name of the killer.
|
|
* @param dead
|
|
* victim's name.
|
|
* @param exp
|
|
* how much experience was gained.
|
|
*/
|
|
void add_kill_to_party(partylist *party, const char *killer, const 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++)
|
|
memcpy(&(party->party_kills[i]), &(party->party_kills[i+1]), sizeof(party->party_kills[0]));
|
|
} else
|
|
pos = party->kills;
|
|
party->kills++;
|
|
party->total_exp += exp;
|
|
party->party_kills[pos].exp = exp;
|
|
strncpy(party->party_kills[pos].killer, killer, MAX_NAME);
|
|
strncpy(party->party_kills[pos].dead, dead, MAX_NAME);
|
|
party->party_kills[pos].killer[MAX_NAME] = 0;
|
|
party->party_kills[pos].dead[MAX_NAME] = 0;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* Is the password the player entered to join a party the right one?
|
|
*
|
|
* @param op
|
|
* player. Must have party_to_join correctly set.
|
|
* @retval 0
|
|
* password is correct.
|
|
* @retval 1
|
|
* invalid password or party not found.
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* Player entered a party password.
|
|
*
|
|
* @param op
|
|
* player.
|
|
*/
|
|
void receive_party_password(object *op) {
|
|
|
|
if (confirm_party_password(op) == 0) {
|
|
partylist *joined_party = op->contr->party_to_join;
|
|
char buf[MAX_BUF];
|
|
|
|
if (op->contr->party != NULL) {
|
|
snprintf(buf, sizeof(buf), "%s leaves party %s.", op->name, op->contr->party->partyname);
|
|
send_party_message(op, buf);
|
|
}
|
|
op->contr->party = op->contr->party_to_join;
|
|
op->contr->party_to_join = NULL;
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"You have joined party: %s\n",
|
|
"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->state = ST_PLAYING;
|
|
return;
|
|
} else {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"You entered the wrong password", NULL);
|
|
op->contr->party_to_join = NULL;
|
|
op->contr->state = ST_PLAYING;
|
|
return;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send a message to all party members except the speaker.
|
|
*
|
|
* @param op
|
|
* player talking.
|
|
* @param msg
|
|
* message to send.
|
|
*/
|
|
void send_party_message(object *op, char *msg) {
|
|
player *pl;
|
|
|
|
for (pl = first_player; pl != NULL; pl = pl->next)
|
|
if (pl->ob->contr->party == op->contr->party && pl->ob != op)
|
|
draw_ext_info(NDI_WHITE, 0, pl->ob, MSG_TYPE_COMMUNICATION, MSG_TYPE_COMMUNICATION_PARTY,
|
|
msg, NULL);
|
|
}
|
|
|
|
/**
|
|
* 'gsay' command, talks to party.
|
|
*
|
|
* @param op
|
|
* player.
|
|
* @param params
|
|
* message.
|
|
* @return
|
|
* 0.
|
|
*/
|
|
int command_gsay(object *op, char *params) {
|
|
char party_params[MAX_BUF];
|
|
|
|
if (!params) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR, "Say what?", NULL);
|
|
return 0;
|
|
}
|
|
strcpy(party_params, "say ");
|
|
strcat(party_params, params);
|
|
command_party(op, party_params);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Give help for party commands.
|
|
*
|
|
* @param op
|
|
* player.
|
|
*/
|
|
static void party_help(object *op) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_HELP,
|
|
"To form a party type: party form <partyname>. "
|
|
"To join a party type: party join <partyname> "
|
|
"If the party has a passwd, it will you prompt you for it. "
|
|
"For a list of current parties type: party list. "
|
|
"To leave a party type: party leave "
|
|
"To change a passwd for a party type: party passwd <password> "
|
|
"There is an 8 character maximum password length. "
|
|
"To talk to party members type: party say <msg> "
|
|
"To see who is in your party: party who "
|
|
#ifdef PARTY_KILL_LOG
|
|
"To see what you've killed, type: party kills"
|
|
#endif
|
|
, NULL);
|
|
}
|
|
|
|
/**
|
|
* 'party' command, subdivided in different sub commands.
|
|
*
|
|
* @param op
|
|
* player.
|
|
* @param params
|
|
* additional parameters.
|
|
* 1.
|
|
* @todo split in different functions. clean the 'form' mess.
|
|
*/
|
|
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) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"You are not a member of any party. "
|
|
"For help try: party help", NULL);
|
|
} else {
|
|
currentparty = op->contr->party->partyname;
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"You are a member of party %s.",
|
|
"You are a member of party %s.",
|
|
currentparty);
|
|
}
|
|
return 1;
|
|
}
|
|
if (strcmp(params, "help") == 0) {
|
|
party_help(op);
|
|
return 1;
|
|
}
|
|
#ifdef PARTY_KILL_LOG
|
|
if (!strncmp(params, "kills", 5)) {
|
|
int i, max;
|
|
char chr;
|
|
char buffer[80];
|
|
float exp;
|
|
|
|
if (op->contr->party == NULL) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"You are not a member of any party.", NULL);
|
|
return 1;
|
|
}
|
|
tmpparty = op->contr->party;
|
|
if (!tmpparty->kills) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"You haven't killed anything yet.", NULL);
|
|
return 1;
|
|
}
|
|
max = tmpparty->kills-1;
|
|
if (max > PARTY_KILL_LOG-1)
|
|
max = PARTY_KILL_LOG-1;
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"[fixed]Killed | Killer| Exp\n----------------+----------------+--------"
|
|
"Killed | Killer| Exp\n----------------+----------------+--------",
|
|
NULL);
|
|
|
|
|
|
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';
|
|
}
|
|
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"[fixed]%16s|%16s|%6.1f%c",
|
|
"%16s|%16s|%6.1f%c",
|
|
tmpparty->party_kills[i].dead,
|
|
tmpparty->party_kills[i].killer, exp, chr);
|
|
|
|
}
|
|
exp = tmpparty->total_exp;
|
|
chr = ' ';
|
|
if (exp > 1000000) {
|
|
exp /= 1000000;
|
|
chr = 'M';
|
|
} else if (exp > 1000) {
|
|
exp /= 1000;
|
|
chr = 'k';
|
|
}
|
|
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"[fixed]----------------+----------------+--------",
|
|
"----------------+----------------+--------");
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"Totals: %d kills, %.1f%c exp", tmpparty->kills,
|
|
"Totals: %d kills, %.1f%c exp", tmpparty->kills,
|
|
exp, chr);
|
|
return 1;
|
|
}
|
|
#endif /* PARTY_KILL_LOG */
|
|
if (strncmp(params, "say ", 4) == 0) {
|
|
if (op->contr->party == NULL) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"You are not a member of any party.", NULL);
|
|
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);
|
|
draw_ext_info_format(NDI_WHITE, 0, op, MSG_TYPE_COMMUNICATION, MSG_TYPE_COMMUNICATION_PARTY,
|
|
"<%s> You say: %s",
|
|
"<%s> You say: %s",
|
|
currentparty, params);
|
|
return 1;
|
|
}
|
|
|
|
if (strncmp(params, "form ", 5) == 0) {
|
|
int player_count;
|
|
player *pl;
|
|
|
|
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)) {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"The party %s already exists, pick another name",
|
|
"The party %s already exists, pick another name",
|
|
params);
|
|
return 1;
|
|
}
|
|
}
|
|
form_party(op, params);
|
|
} else {
|
|
form_party(op, params);
|
|
}
|
|
/*
|
|
* 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 (pl = first_player; pl->next != NULL; pl = pl->next) {
|
|
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) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"You are not a member of any party.", NULL);
|
|
return 1;
|
|
}
|
|
currentparty = op->contr->party->partyname;
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"You leave party %s.",
|
|
"You leave party %s.",
|
|
currentparty);
|
|
snprintf(buf, sizeof(buf), "%s leaves party %s.", op->name, currentparty);
|
|
send_party_message(op, buf);
|
|
op->contr->party = NULL;
|
|
return 1;
|
|
}
|
|
if (strcmp(params, "who") == 0) {
|
|
if (op->contr->party == NULL) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"You are not a member of any party.", NULL);
|
|
return 1;
|
|
}
|
|
list_players(op, NULL, op->contr->party);
|
|
return 1;
|
|
} /* leave */
|
|
|
|
if (strncmp(params, "passwd ", 7) == 0) {
|
|
partylist *tmplist;
|
|
|
|
params += 7;
|
|
|
|
if (op->contr->party == NULL) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"You are not a member of a party", NULL);
|
|
return 1;
|
|
}
|
|
|
|
if (strlen(params) > 8) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"The password must not exceed 8 characters", NULL);
|
|
return 1;
|
|
}
|
|
|
|
tmplist = firstparty;
|
|
while (tmplist != NULL) {
|
|
if (tmplist == op->contr->party) {
|
|
strcpy(tmplist->passwd, params);
|
|
replace_unprintable_chars(tmplist->passwd);
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"The password for party %s is %s",
|
|
"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) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"There are no parties active right now", NULL);
|
|
return 1;
|
|
}
|
|
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"[fixed]Party name Leader\n---------- ------",
|
|
"Party name Leader\n---------- ------");
|
|
|
|
while (tmplist != NULL) {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"[fixed]%-32s %s",
|
|
"%-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) {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"Party: %s does not exist. You must form it first",
|
|
"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) {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"Party: %s does not exist. You must form it first",
|
|
"Party: %s does not exist. You must form it first",
|
|
params);
|
|
return 1;
|
|
} else {
|
|
if (op->contr->party == firstparty) {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"You are already in party: %s",
|
|
"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;
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"You have joined party: %s",
|
|
"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) {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"You are already a member of party: %s",
|
|
"You are already a member of party: %s",
|
|
tmpparty->partyname);
|
|
return 1;
|
|
} else {
|
|
if (tmpparty->passwd[0] == '\0') {
|
|
if (op->contr->party != NULL) {
|
|
snprintf(buf, sizeof(buf), "%s leaves party %s.", op->name, op->contr->party->partyname);
|
|
send_party_message(op, buf);
|
|
}
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"You have joined party: %s",
|
|
"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;
|
|
}
|
|
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"Party %s does not exist. You must form it first.",
|
|
"Party %s does not exist. You must form it first.",
|
|
params);
|
|
return 1;
|
|
} /* join */
|
|
|
|
party_help(op);
|
|
return 1;
|
|
}
|
|
|
|
/** Valid modes for 'party_rejoin'. @todo document that */
|
|
static const char *rejoin_modes[] = {
|
|
"no",
|
|
"if_exists",
|
|
"always",
|
|
NULL
|
|
};
|
|
|
|
/**
|
|
* Handles the 'party_rejoin' command.
|
|
* @param op
|
|
* player.
|
|
* @param params
|
|
* optional parameters.
|
|
* @return
|
|
* 1.
|
|
*/
|
|
int command_party_rejoin(object *op, char *params) {
|
|
int mode;
|
|
|
|
if (!params) {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"party rejoin: %s", NULL, rejoin_modes[op->contr->rejoin_party]);
|
|
return 1;
|
|
}
|
|
for (mode = 0; rejoin_modes[mode] != NULL; mode++) {
|
|
if (strcmp(rejoin_modes[mode], params) == 0) {
|
|
op->contr->rejoin_party = mode;
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"party rejoin is now: %s", NULL, rejoin_modes[op->contr->rejoin_party]);
|
|
return 1;
|
|
}
|
|
}
|
|
if (strlen(params) > 50)
|
|
params[50] = '\0';
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_ERROR,
|
|
"invalid mode: %s", NULL, params);
|
|
return 1;
|
|
}
|