/***************************************************
** File: Clan.c - Written for CircleMUD 3.0 **
** Usage: Functionality of clan code **
** Written by Chuck Reed for use on Dark Horizon **
** and QuarentineMUD. (SEE NOTE BELOW FOR BASE) **
****************************************************
** Anyone may use, modify this code for their mud **
** as long as proper credit is given. **
** -Chuck **
***************************************************/
/* This code is greatly inspired by the clan code
written by Mehdi Keddache who deserves a great
deal of thanks for the ideas behind this code's
creation. */
#include "conf.h"
#include "sysdep.h"
#include "structs.h"
#include "utils.h"
#include "db.h"
#include "comm.h"
#include "interpreter.h"
#include "handler.h"
#include "money.h"
extern struct room_data *world;
struct clan_info clan[MAX_CLANS];
extern struct player_index_element *player_table;
extern char *class_abbrevs[];
extern FILE *player_fl;
void save_char_file_u(struct char_file_u st);
int num_of_clans;
char *noclan = "You don't even belong to a clan!\r\n";
struct char_data *is_playing(char *vict_name)
{
extern struct descriptor_data *descriptor_list;
struct descriptor_data *i, *next_i;
char new_vict_name[30];
strcpy(new_vict_name, vict_name);
for (i = descriptor_list; i; i = next_i) {
next_i = i->next;
if(i->connected == CON_PLAYING && !str_cmp(i->character->player.name,CAP(new_vict_name)))
return i->character;
}
return NULL;
}
void save_clans(void)
{
FILE *f;
if(!(f = fopen(CLAN_FILE, "wb"))) {
log("SYSERR: Clan file does not exist or is unusable.");
return;
}
fwrite(&num_of_clans, sizeof(int), 1, f);
fwrite(clan, sizeof(struct clan_info), num_of_clans, f);
fclose(f);
return;
}
void boot_clans(void)
{
int i,j;
FILE *f;
extern int top_of_p_table;
struct char_file_u chdata;
char temp_name[MAX_INPUT_LENGTH];
memset(clan,0,sizeof(struct clan_info)*MAX_CLANS);
num_of_clans=0;
i=0;
log("Booting clans . . .");
if(!(f = fopen(CLAN_FILE, "rb"))) {
log("Clan file doesn't exist, a new one will be created.");
save_clans();
return;
}
fread(&num_of_clans, sizeof(int), 1, f);
fread(clan, sizeof(struct clan_info), num_of_clans, f);
fclose(f);
// Initialize members to zero for all clans
for(i=0;i < num_of_clans;i++)
clan[i].members = 0;
// Now calculate members each time clans boot up
for (j = 0; j <= top_of_p_table; j++) {
strcpy(temp_name, (player_table + j)->name);
load_char(temp_name, &chdata);
if((i=chdata.player_specials_saved.clan)>=0 && chdata.player_specials_saved.clan_rank != -1)
clan[i].members++;
}
log("Done.");
}
sh_int find_clan(char *arg)
{
int i;
if(!*arg)
return -1;
for(i=0;i<num_of_clans;i++)
if(!strcmp(CAP(arg), CAP(clan[i].name)))
return i;
return -1;
}
void send_clan_format(struct char_data *ch)
{
send_to_char("Usage: Clan Help <topic>\r\n\
Clan status\r\n\
Clan privilege <privilege name> <privilege level>\r\n\
Clan rank <direction> <Num of ranks>\r\n\
Clan rname <rank level> <rank name>\r\n\
Clan apply <clan num>\r\n\
Clan enlist <victim>\r\n\
Clan expel <victim>\r\n\
Clan resign\r\n\
Clan List\r\n\
Clan info <clan num>\r\n\
Clan Talk\r\n\
Csay <message>\r\n\
Clan Who\r\n\
Clan promote <victim>\r\n\
Clan roster\r\n\
Clan demote <victim>\r\n", ch);
if(GET_LEVEL(ch) >= LVL_CLAN_GOD)
send_to_char(" Clan create <leader> <name>\r\n\
Clan destroy <clan num>\r\n\
Clan rename <number> <new-name>\r\n\
Clan numset <number> <new-number> !!DON'T USE W/OUT PERMISSION!!\r\n\
Clan newowner <number> <new-owner>\r\n\
Clan clanroom <vnum>\r\n", ch);
return;
}
void clan_create(struct char_data *ch, char *arg)
{
struct char_data *leader = NULL;
char arg1[MAX_INPUT_LENGTH],arg2[MAX_INPUT_LENGTH];
int i;
if(!*arg) {
send_clan_format(ch);
return;
}
if(GET_LEVEL(ch) < LVL_CLAN_GOD) {
send_to_char("You can't do that!\r\n", ch);
return;
}
if(num_of_clans == MAX_CLANS) {
send_to_char("Max clans reached. Report this to an implimentor.\r\n",ch);
return;
}
half_chop(arg, arg1, arg2);
if(!(leader=get_char_vis(ch,arg1,FIND_CHAR_ROOM))) {
send_to_char("The leader of the new clan must be present.\r\n",ch);
return;
}
if(strlen(arg2) >= 32) {
send_to_char("Clan name too long! (32 characters max)\r\n",ch);
return;
}
if(GET_LEVEL(leader) >= LVL_IMMORT) {
send_to_char("You cannot set an immortal as the leader of a clan.\r\n",ch);
return;
}
if(GET_CLAN(leader) >= 0 && GET_CLAN_RANK(leader) > 0) {
send_to_char("The leader already belongs to a clan!\r\n",ch);
return;
}
if(find_clan(arg2)!=-1) {
send_to_char("That clan name alread exists!\r\n",ch);
return;
}
strncpy(clan[num_of_clans].name, CAP((char *)arg2), 32);
clan[num_of_clans].number = num_of_clans;
clan[num_of_clans].ranks = 2;
strcpy(clan[num_of_clans].rank_name[0],"Member");
strcpy(clan[num_of_clans].rank_name[1],"Leader");
clan[num_of_clans].members = 1 ;
for(i=0;i<NUM_OF_PRIVS;i++)
clan[num_of_clans].privilege[i] = 0;
strncpy(clan[num_of_clans].leader, GET_NAME(leader), MAX_NAME_LENGTH);
clan[num_of_clans].gold = 0;
num_of_clans++;
save_clans();
GET_CLAN(leader) = (num_of_clans - 1);
GET_CLAN_RANK(leader) = clan[num_of_clans - 1].ranks;
save_char(leader, leader->in_room);
send_to_char("Clan created successfuly.\r\n", ch);
return;
}
void clan_destroy (struct char_data *ch, char *arg)
{
int i,j;
extern int top_of_p_table;
struct char_file_u chdata;
struct char_data *victim=NULL;
char temp_name[MAX_INPUT_LENGTH];
if (!*arg) {
send_clan_format(ch);
return;
}
i = atoi(arg);
if (i < 1 || i > num_of_clans - 1) {
send_to_char("Unknown clan.\r\n", ch);
return;
}
if(GET_LEVEL(ch)<LVL_CLAN_GOD) {
send_to_char("Your not mighty enough to destroy clans!\r\n", ch);
return;
}
if(i == 0) {
send_to_char("You can't delete the 0 placeholder!\r\n", ch);
return;
}
for (j = 0; j <= top_of_p_table; j++) {
strcpy(temp_name, (player_table + j)->name);
if((victim=is_playing(temp_name))) {
if(GET_CLAN(victim)== i) {
GET_CLAN(victim)= -1;
GET_CLAN_RANK(victim)=-1;
save_char(victim, victim->in_room);
}
else if(GET_CLAN(victim) > i)
GET_CLAN(victim) -= 1;
}
else {
strcpy(temp_name, (player_table + j)->name);
load_char(temp_name, &chdata);
if(chdata.player_specials_saved.clan== i) {
chdata.player_specials_saved.clan=-1;
chdata.player_specials_saved.clan_rank=-1;
save_char_file_u(chdata);
}
else if(chdata.player_specials_saved.clan > i) {
chdata.player_specials_saved.clan -= 1;
save_char_file_u(chdata);
}
}
}
memset(&clan[i], sizeof(struct clan_info), 0);
for (j = i; j < num_of_clans - 1; j++) {
clan[j] = clan[j + 1];
clan[j].number = j;
}
num_of_clans--;
send_to_char("Clan deleted.\r\n", ch);
save_clans();
return;
}
void clan_score(struct char_data *ch)
{
int i;
if(GET_CLAN(ch) == -1 || GET_CLAN_RANK(ch) == -1) {
send_to_char(noclan, ch);
return;
}
if(GET_CLAN_RANK(ch) < clan[GET_CLAN(ch)].privilege[SCORE_PRIV]) {
send_to_char("You aren't high enough ranked to do that.\r\n", ch);
}
i = GET_CLAN(ch);
send_to_char("\r\nClan Statistics\r\n----------------\r\n",ch);
sprintf(buf, "\r\nClan Name : &c%s&n\r\n", clan[i].name);
sprintf(buf + strlen(buf),"Clan Number :&c%d&n\r\n" , clan[i].number);
sprintf(buf + strlen(buf),"Clan Leader :&c%s&n\r\n" , clan[i].leader);
sprintf(buf + strlen(buf),"Clan Members :&c%d&n\r\n" , clan[i].members);
sprintf(buf + strlen(buf),"Clan Treasury :&c%s&n\r\n" , expand_copper(clan[i].gold, 1));
sprintf(buf + strlen(buf),"Withdraw Rank :&c%d&n\r\n" ,clan[i].privilege[WITHDRAW_PRIV]);
sprintf(buf + strlen(buf),"Promote Rank :&c%d&n\r\n" ,clan[i].privilege[PROMOTE_PRIV]);
sprintf(buf + strlen(buf),"Demote Rank :&c%d&n\r\n" ,clan[i].privilege[DEMOTE_PRIV]);
sprintf(buf + strlen(buf),"Enlist Rank :&c%d&n\r\n" ,clan[i].privilege[ENLIST_PRIV]);
sprintf(buf + strlen(buf),"Expel Rank :&c%d&n\r\n" ,clan[i].privilege[EXPEL_PRIV]);
sprintf(buf + strlen(buf),"Status Rank :&c%d&n\r\n" ,clan[i].privilege[SCORE_PRIV]);
sprintf(buf + strlen(buf),"Total Ranks :&c%d&n\r\n" , clan[i].ranks);
send_to_char(buf, ch);
send_to_char("\r\nRank Hierachy______________________\r\n",ch);
*buf = '\0';
for(i = 1; i <= clan[GET_CLAN(ch)].ranks;i++)
sprintf(buf, "%s%2d) %s\r\n", buf,i, clan[GET_CLAN(ch)].rank_name[i-1]);
send_to_char(buf, ch);
}
void set_priv(struct char_data *ch, char *arg)
{
char arg1[MAX_INPUT_LENGTH],arg2[MAX_INPUT_LENGTH];
int level;
if(GET_CLAN(ch) == -1 || GET_CLAN_RANK(ch) < 0) {
send_to_char(noclan, ch);
return;
}
if(GET_CLAN_RANK(ch) != clan[GET_CLAN(ch)].ranks) {
send_to_char("You have to be the leader of a clan to set privileges.\r\n", ch);
return;
}
half_chop(arg, arg1, arg2);
if(!*arg1 || !*arg2) {
send_clan_format(ch);
return;
}
level = atoi(arg2);
if(level < 1 || level > clan[GET_CLAN(ch)].ranks) {
send_to_char("Invalid level.\r\n", ch);
return;
}
if(is_abbrev(arg1, "withdraw")) {
clan[GET_CLAN(ch)].privilege[WITHDRAW_PRIV] = level;
sprintf(buf, "Withdrawal level changed to %d.\r\n", level);
send_to_char(buf, ch);
save_clans();
return;
}
if(is_abbrev(arg1, "promote")) {
clan[GET_CLAN(ch)].privilege[PROMOTE_PRIV] = level;
sprintf(buf, "Promote privilege changed to %d.\r\n", level);
save_clans();
send_to_char(buf, ch);
return;
}
if(is_abbrev(arg1, "demote")) {
clan[GET_CLAN(ch)].privilege[DEMOTE_PRIV] = level;
sprintf(buf, "Demote privilege changed to %d.\r\n", level);
send_to_char(buf, ch);
save_clans();
return;
}
if(is_abbrev(arg1, "status")) {
clan[GET_CLAN(ch)].privilege[SCORE_PRIV] = level;
sprintf(buf, "Status privilege changed to %d.\r\n", level);
send_to_char(buf, ch);
save_clans();
return;
}
if(is_abbrev(arg1, "enlist")) {
clan[GET_CLAN(ch)].privilege[ENLIST_PRIV] = level;
sprintf(buf, "Enlist privilege changed to %d.\r\n", level);
send_to_char(buf, ch);
save_clans();
return;
}
if(is_abbrev(arg1, "expel")) {
clan[GET_CLAN(ch)].privilege[EXPEL_PRIV] = level;
sprintf(buf, "Expel privilege changed to %d.\r\n", level);
send_to_char(buf, ch);
save_clans();
return;
}
send_to_char("Unknown privilege setting option.\r\n", ch);
return;
}
void lower_entire_clan(int i)
{
int j;
extern int top_of_p_table;
struct char_file_u chdata;
struct char_data *victim;
char temp_name[MAX_INPUT_LENGTH];
for (j = 0; j <= top_of_p_table; j++) {
strcpy(temp_name, (player_table + j)->name);
if((victim=is_playing(temp_name))) {
if(GET_CLAN(victim)==clan[i].number && GET_CLAN_RANK(victim) != -1) {
GET_CLAN_RANK(victim) = 1;
save_char(victim, victim->in_room);
}
}
else {
strcpy(temp_name, (player_table + j)->name);
load_char(temp_name, &chdata);
if(chdata.player_specials_saved.clan==clan[i].number &&chdata.player_specials_saved.clan_rank != -1) {
chdata.player_specials_saved.clan_rank = 1;
save_char_file_u(chdata);
}
}
}
}
void handle_rank(struct char_data *ch, char *arg)
{
char arg1[MAX_INPUT_LENGTH],arg2[MAX_INPUT_LENGTH];
int i;
if(!*arg) {
send_clan_format(ch);
return;
}
if(GET_CLAN(ch) == -1 || GET_CLAN_RANK(ch) == -1) {
send_to_char(noclan, ch);
return;
}
if(str_cmp(GET_NAME(ch), clan[GET_CLAN(ch)].leader)) {
send_to_char("Only clan leaders can do that.\r\n", ch);
return;
}
half_chop(arg, arg1, arg2);
if(!*arg1 || !*arg2) {
send_clan_format(ch);
return;
}
if(is_abbrev(arg1, "raise")) {
if(atoi(arg2) < 1 || atoi(arg2) > 9 || atoi(arg2) < clan[GET_CLAN(ch)].ranks) {
send_clan_format(ch);
return;
}
sprintf(buf, "Clan ranks changed to %d.\r\n", atoi(arg2));
send_to_char(buf, ch);
for(i=clan[GET_CLAN(ch)].ranks;i < atoi(arg2);i++)
strcpy(clan[GET_CLAN(ch)].rank_name[i], "N/A");
clan[GET_CLAN(ch)].ranks = atoi(arg2);
GET_CLAN_RANK(ch) = atoi(arg2);
save_clans();
return;
}
if(is_abbrev(arg1, "lower")) {
if(atoi(arg2) < 2 || atoi(arg2) > 9 || atoi(arg2) > clan[GET_CLAN(ch)].ranks) {
send_clan_format(ch);
return;
}
sprintf(buf, "Clan ranks changed to %d.\r\n", atoi(arg2));
send_to_char(buf, ch);
clan[GET_CLAN(ch)].ranks = atoi(arg2);
lower_entire_clan(GET_CLAN(ch));
GET_CLAN_RANK(ch) = atoi(arg2);
for(i=0;i<NUM_OF_PRIVS;i++)
if(clan[GET_CLAN(ch)].privilege[i] > GET_CLAN_RANK(ch))
clan[GET_CLAN(ch)].privilege[i] = GET_CLAN_RANK(ch);
save_clans();
return;
}
send_clan_format(ch);
return;
}
void clan_rank_name(struct char_data *ch, char *arg)
{
char arg1[MAX_INPUT_LENGTH],arg2[MAX_INPUT_LENGTH];
if(!*arg) {
send_clan_format(ch);
return;
}
if(GET_CLAN(ch) == -1 || GET_CLAN_RANK(ch) == -1) {
send_to_char(noclan, ch);
return;
}
if(GET_CLAN_RANK(ch) < clan[GET_CLAN(ch)].ranks) {
send_to_char("You aren't in a position to do that!\r\n", ch);
return;
}
half_chop(arg, arg1, arg2);
if(!*arg1 || !*arg2) {
send_clan_format(ch);
return;
}
if(strlen(arg2) > 20) {
send_to_char("Ranks must be no more than 20 characters long.\r\n", ch);
return;
}
if(atoi(arg1) < 1 || atoi(arg1) > 9 || atoi(arg1) > clan[GET_CLAN(ch)].ranks) {
send_to_char("Rank number does not exist.\r\n", ch);
return;
}
strcpy(clan[GET_CLAN(ch)].rank_name[atoi(arg1) - 1], arg2);
send_to_char("Rank name changed.\r\n", ch);
save_clans();
return;
}
void clan_apply(struct char_data *ch, char *arg)
{
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
if(!*arg) {
send_clan_format(ch);
return;
}
if(GET_CLAN(ch) != -1) {
send_to_char("You are already in a clan.\r\n", ch);
return;
}
half_chop(arg, arg1, arg2);
if(!*arg1) {
send_clan_format(ch);
return;
}
if(atoi(arg1) > 0 && atoi(arg1) < num_of_clans) {
send_to_char("Clan applied for. You may type 'resign' to withdraw your aplication at any point.\r\n", ch);
send_to_char("Note that this does not notify the clan applied for. It is suggested that you\r\n", ch);
send_to_char("contact the clan's leaders through mudmail to inform them.\r\n", ch);
GET_CLAN(ch) = atoi(arg1);
GET_CLAN_RANK(ch) = -1;
return;
}
send_to_char("Illegal clan number. Clan does not exist.\r\n", ch);
return;
}
void clan_resign(struct char_data *ch)
{
if(GET_CLAN(ch) == -1) {
send_to_char(noclan, ch);
return;
}
if(!strcmp(GET_NAME(ch), clan[GET_CLAN(ch)].leader)) {
send_to_char("Clan owners can't resign. Speak to a clan god.\r\n", ch);
return;
}
if(GET_CLAN_RANK(ch) > 0)
clan[GET_CLAN(ch)].members -= 1;
GET_CLAN(ch) = -1;
GET_CLAN_RANK(ch) = 0;
send_to_char("You have resigned from your clan.\r\n", ch);
save_clans();
return;
}
void clan_enlist(struct char_data *ch, char *arg)
{
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
struct char_data *victim;
struct char_file_u chdata;
long test;
if(GET_CLAN(ch) == -1 || GET_CLAN_RANK(ch) <= 0) {
send_to_char(noclan, ch);
return;
}
if(GET_CLAN_RANK(ch) < clan[GET_CLAN(ch)].privilege[ENLIST_PRIV]) {
send_to_char("You aren't privileged enough to do that.\r\n", ch);
return;
}
half_chop(arg, arg1, arg2);
// If there is no player with that name on-line or in pfile, abort
if(!(victim = is_playing(arg1)) && (test = get_id_by_name(arg1)) < 0) {
send_to_char("There is no such player.\r\n", ch);
return;
}
if(victim) { // Victim was found playing the game
if(GET_CLAN(victim) != GET_CLAN(ch)) {
send_to_char("I don't think they want to be in your clan.\r\n", ch);
return;
}
if(GET_CLAN_RANK(victim) != -1) {
send_to_char("They are already in your clan.\r\n", ch);
return;
}
if(GET_LEVEL(victim) >= LVL_IMMORT) {
send_to_char("You can't enlist immortals.\r\n", ch);
return;
}
GET_CLAN_RANK(victim) = 1;
sprintf(buf, "%s has enlisted you into %s!\r\n", GET_NAME(ch), clan[GET_CLAN(ch)].name);
send_to_char(buf, victim);
sprintf(buf, "%s has been enlisted into your clan!\r\n", GET_NAME(victim));
send_to_char(buf, ch);
clan[GET_CLAN(ch)].members += 1;
save_clans();
}
else { // Victim wasn't playing, but was in pfile
load_char(arg1, &chdata);
if(chdata.player_specials_saved.clan != GET_CLAN(ch)) {
send_to_char("I don't think they want to be in your clan.\r\n", ch);
return;
}
if(chdata.player_specials_saved.clan_rank != -1) {
send_to_char("They are already in your clan.\r\n", ch);
return;
}
chdata.player_specials_saved.clan_rank = 1;
sprintf(buf, "%s has been enlisted in your clan!\r\n", CAP(arg1));
send_to_char(buf, ch);
clan[GET_CLAN(ch)].members += 1;
save_clans();
save_char_file_u(chdata);
}
}
void clan_expel(struct char_data *ch, char *arg)
{
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
struct char_data *victim;
struct char_file_u chdata;
long test;
if(GET_CLAN(ch) == -1 || GET_CLAN_RANK(ch) < 0) {
send_to_char(noclan, ch);
return;
}
if(GET_CLAN_RANK(ch) < clan[GET_CLAN(ch)].privilege[EXPEL_PRIV]) {
send_to_char("You aren't privileged enough to do that.\r\n", ch);
return;
}
half_chop(arg, arg1, arg2);
if(!(victim = is_playing(arg1)) && (test = get_id_by_name(arg1)) < 0) {
send_to_char("There are no players by that name.\r\n", ch);
return;
}
if(victim) {
if(GET_CLAN(victim) != GET_CLAN(ch)) {
send_to_char("Maybe if they were in YOUR clan . . .\r\n", ch);
return;
}
if(GET_CLAN_RANK(victim) > GET_CLAN_RANK(ch)) {
send_to_char("You can't expel those higher than you!\r\n", ch);
return;
}
if(!str_cmp(GET_NAME(victim), clan[GET_CLAN(ch)].leader)) {
send_to_char("Expel the leader? No, I don't think so.\r\n", ch);
return;
}
GET_CLAN(victim) = -1;
GET_CLAN_RANK(victim) = -1;
sprintf(buf, "%s has expelled you from %s.\r\n", GET_NAME(ch), clan[GET_CLAN(ch)].name);
send_to_char(buf, victim);
sprintf(buf, "You have expelled %s from the clan.\r\n", GET_NAME(victim));
send_to_char(buf, ch);
clan[GET_CLAN(ch)].members -= 1;
save_clans();
return;
}
else {
load_char(arg1, &chdata);
if(chdata.player_specials_saved.clan != GET_CLAN(ch)) {
send_to_char("Maybe if they were in YOUR clan . . .\r\n", ch);
return;
}
if(chdata.player_specials_saved.clan_rank > GET_CLAN_RANK(ch)) {
send_to_char("You can't expel those higher than you!\r\n", ch);
return;
}
if(!str_cmp(chdata.name, clan[GET_CLAN(ch)].leader)) {
send_to_char("They are the leader! Don't do that.\r\n", ch);
return;
}
chdata.player_specials_saved.clan = -1;
chdata.player_specials_saved.clan_rank = -1;
sprintf(buf, "You have expelled %s from your clan.\r\n", CAP(arg1));
send_to_char(buf, ch);
clan[GET_CLAN(ch)].members -= 1;
save_clans();
save_char_file_u(chdata);
}
}
// This looks stupid, but I will leave esthetics up to you folks
void clan_list(struct char_data *ch)
{
int i;
send_to_char("Number Name Leader\r\n", ch);
send_to_char("---------------------------------------------------------\r\n", ch);
for(i=1;i < num_of_clans;i++) {
sprintf(buf, "&c%2d&n) %-20s %-20s\r\n", i, clan[i].name,
clan[i].leader);
send_to_char(buf, ch);
}
return;
}
void clan_promote(struct char_data *ch, char *arg)
{
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
struct char_data *victim;
struct char_file_u chdata;
long test;
if(GET_CLAN(ch) == -1 || GET_CLAN_RANK(ch) == -1) {
send_to_char(noclan, ch);
return;
}
if(GET_CLAN_RANK(ch) < clan[GET_CLAN(ch)].privilege[PROMOTE_PRIV]) {
send_to_char("You aren't privileged enough to do that!\r\n", ch);
return;
}
half_chop(arg, arg1, arg2);
if(!*arg1) {
send_clan_format(ch);
return;
}
if(!(victim = is_playing(arg1)) && (test = get_id_by_name(arg1)) < 0) {
send_to_char("There is no such player.\r\n", ch);
return;
}
if(victim) {
if(GET_CLAN(victim) != GET_CLAN(ch)) {
send_to_char("Who are you to do that!? They aren't in your clan!\r\n", ch);
return;
}
if(ch == victim) {
send_to_char("Sure wiseguy, you do that.\r\n", ch);
return;
}
if(GET_CLAN_RANK(ch) <= GET_CLAN_RANK(victim)) {
send_to_char("You can't promote someone higher than yourself.\r\n", ch);
return;
}
if(GET_CLAN_RANK(victim) == clan[GET_CLAN(victim)].ranks) {
send_to_char("That would exceed the current ranks. Don't do that.\r\n", ch);
return;
}
GET_CLAN_RANK(victim) += 1;
sprintf(buf, "%s has promoted you to %s!\r\n", GET_NAME(ch), clan[GET_CLAN(ch)].rank_name[GET_CLAN_RANK(victim) - 1]);
send_to_char(buf, victim);
sprintf(buf, "You promote %s to %s.\r\n", GET_NAME(victim), clan[GET_CLAN(ch)].rank_name[GET_CLAN_RANK(victim) -1]);
send_to_char(buf, ch);
return;
}
else {
load_char(arg1, &chdata);
if(chdata.player_specials_saved.clan != GET_CLAN(ch)) {
send_to_char("Who are you to do that? They aren't in your clan!\r\n", ch);
return;
}
if(chdata.player_specials_saved.clan_rank >= GET_CLAN_RANK(ch)) {
send_to_char("Hmmm, I don't see that happening anytime soon.\r\n", ch);
return;
}
if(chdata.player_specials_saved.clan_rank == clan[GET_CLAN(ch)].ranks) {
send_to_char("That would exceed the current ranks. Don't do that.\r\n", ch);
return;
}
chdata.player_specials_saved.clan_rank += 1;
sprintf(buf, "You have promoted %s to %s.\r\n", CAP(arg1), clan[GET_CLAN(ch)].rank_name[chdata.player_specials_saved.clan_rank - 1]);
send_to_char(buf, ch);
save_char_file_u(chdata);
}
}
void do_clan_withdraw(struct char_data *ch, char *arg)
{
int amount;
int type;
char currency[MAX_STRING_LENGTH];
char number[MAX_STRING_LENGTH];
if(GET_CLAN(ch) == -1 || GET_CLAN_RANK(ch) < 0) {
send_to_char(noclan, ch);
return;
}
if(GET_CLAN_RANK(ch) < clan[GET_CLAN(ch)].privilege[WITHDRAW_PRIV]) {
send_to_char("You aren't privileged enough to do that.\r\n", ch);
return;
}
if(!ROOM_FLAGGED(ch->in_room, ROOM_CLAN_ROOM)) {
send_to_char("You need to be in your clanroom to do that!\r\n", ch);
return;
}
two_arguments(arg, number, currency);
if ((amount = atoi(number)) <= 0) {
send_to_char("How much do you want to withdraw?\r\n", ch);
return;
}
type = parse_cash_type(currency);
if (type < 0) {
send_to_char("Withdraw what kind of coins?\r\n", ch);
return;
}
if (value_in_copper(amount, type) > clan[GET_CLAN(ch)].gold) {
send_to_char("Your clan doesn't have such resources.\r\n", ch);
return;
}
clan[GET_CLAN(ch)].gold -= amount;
add_cash_to_char(ch, amount, type);
sprintf(buf, "You withdraw %d %s from your clan treasury.\r\n",
amount, coin_types[type]);
send_to_char(buf, ch);
act("$n makes a clan withdrawal.", TRUE, ch, 0, 0, TO_ROOM);
save_clans();
}
void do_clan_deposit(struct char_data *ch, char *arg)
{
int amount, type;
char currency[MAX_STRING_LENGTH];
char number[MAX_STRING_LENGTH];
if(GET_CLAN(ch) == -1 || GET_CLAN_RANK(ch) < 0) {
send_to_char(noclan, ch);
return;
}
if(!ROOM_FLAGGED(ch->in_room, ROOM_CLAN_ROOM)) {
send_to_char("You need to be in your clanroom to do that!\r\n", ch);
return;
}
two_arguments(arg, number, currency);
if ((amount = atoi(number)) <= 0) {
send_to_char("How much do you want to deposit?\r\n", ch);
return;
}
type = parse_cash_type(currency);
if (type < 0) {
send_to_char("Deposit what kind of coins?\r\n", ch);
return;
}
if (get_money(ch, type) < amount) {
send_to_char("You cannot deposit what you do not have!\r\n", ch);
return;
}
clan[GET_CLAN(ch)].gold += value_in_copper(amount, type);
sub_cash_from_char(ch, amount, type);
sprintf(buf, "You deposit %d %s into your clan treasury.\r\n",
amount, coin_types[type]);
send_to_char(buf, ch);
act("$n makes a clan deposit.", TRUE, ch, 0, 0, TO_ROOM);
save_clans();
}
void set_clanroom(struct char_data *ch, char *arg)
{
int num;
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
if(!*arg || GET_LEVEL(ch) < LVL_CLAN_GOD) {
send_clan_format(ch);
return;
}
half_chop(arg, arg1, arg2);
if(!*arg1 || !*arg2) {
send_clan_format(ch);
return;
}
if(atoi(arg1) < 0 || atoi(arg1) > num_of_clans - 1) {
send_to_char("No such clan.\r\n", ch);
return;
}
num = atoi(arg1);
if(real_room(atoi(arg2)) < 0) {
send_to_char("Invalid room number!\r\n", ch);
return;
}
sprintf(buf, "Clan number %d's clan room is set to %d.\r\n", num, atoi(arg2));
send_to_char(buf, ch);
clan[num].clan_room = atoi(arg2);
save_clans();
}
void clan_rename(struct char_data *ch, char *arg)
{
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
if(!*arg || GET_LEVEL(ch) < LVL_CLAN_GOD) {
send_clan_format(ch);
return;
}
half_chop(arg, arg1, arg2);
if(!*arg1 || !*arg2) {
send_clan_format(ch);
return;
}
if(atoi(arg1) < 1 || atoi(arg1) > num_of_clans - 1) {
send_to_char("That clan doesn't exist.\r\n", ch);
return;
}
if(strlen(arg2) > 31) {
send_to_char("The new name has to be less than 32 characters.\r\n", ch);
return;
}
strcpy(clan[atoi(arg1)].name, arg2);
send_to_char("Clan name changed.\r\n", ch);
save_clans();
return;
}
void clan_new_owner(struct char_data *ch, char *arg)
{
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
struct char_data *victim;
if(!*arg || GET_LEVEL(ch) < LVL_CLAN_GOD) {
send_clan_format(ch);
return;
}
half_chop(arg, arg1, arg2);
if(!*arg1 || !*arg2) {
send_clan_format(ch);
return;
}
if(!(victim = get_char_vis(ch, arg2, FIND_CHAR_WORLD))) {
send_to_char("The new owner has to be on-line for this to work!\r\n", ch);
return;
}
if(atoi(arg1) < 1 || atoi(arg1) > (num_of_clans - 1)) {
send_to_char("That clan doesn't exist.\r\n", ch);
return;
}
if(GET_CLAN(victim) != atoi(arg1))
GET_CLAN(victim) = atoi(arg1);
if(GET_CLAN_RANK(victim) < clan[GET_CLAN(victim)].ranks)
GET_CLAN_RANK(victim) = clan[GET_CLAN(victim)].ranks;
strcpy(clan[atoi(arg1)].leader, GET_NAME(victim));
send_to_char("Clan has been set with new owner.\r\n", ch);
save_clans();
}
void clan_demote(struct char_data *ch, char *arg)
{
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
struct char_data *victim;
struct char_file_u chdata;
long test;
if(GET_CLAN(ch) == -1 || GET_CLAN_RANK(ch) == -1) {
send_to_char(noclan, ch);
return;
}
if(GET_CLAN_RANK(ch) < clan[GET_CLAN(ch)].privilege[DEMOTE_PRIV]) {
send_to_char("You aren't privileged enough to do that!\r\n", ch);
return;
}
half_chop(arg, arg1, arg2);
if(!*arg1) {
send_clan_format(ch);
return;
}
if(!(victim = is_playing(arg1)) && (test = get_id_by_name(arg1)) < 0) {
send_to_char("There is no player by that name.\r\n", ch);
return;
}
if(victim) {
if(GET_CLAN(victim) != GET_CLAN(ch)) {
send_to_char("Who are you to do that!? They aren't in your clan!\r\n", ch);
return;
}
if(ch == victim) {
send_to_char("Sure wiseguy, you do that.\r\n", ch);
return;
}
if(GET_CLAN_RANK(ch) <= GET_CLAN_RANK(victim)) {
send_to_char("You can't demote someone higher than yourself.\r\n", ch);
return;
}
if(GET_CLAN_RANK(victim) == 1) {
send_to_char("They are level 1, the only thing left to do is expel them.\r\n", ch);
return;
}
GET_CLAN_RANK(victim) -= 1;
sprintf(buf, "%s has demoted you to %s.\r\n", GET_NAME(ch), clan[GET_CLAN(ch)].rank_name[GET_CLAN_RANK(victim) - 1]);
send_to_char(buf, victim);
sprintf(buf, "You demote %s to %s.\r\n", GET_NAME(victim), clan[GET_CLAN(ch)].rank_name[GET_CLAN_RANK(victim) -1]);
send_to_char(buf, ch);
return;
}
else {
load_char(arg1, &chdata);
if(chdata.player_specials_saved.clan != GET_CLAN(ch)) {
send_to_char("Who are you to do that? They aren't in your clan!\r\n", ch);
return;
}
if(chdata.player_specials_saved.clan_rank < clan[GET_CLAN(ch)].ranks &&
chdata.player_specials_saved.clan_rank >= GET_CLAN_RANK(ch)) {
send_to_char("Hmmm, I don't see that happening anytime soon.\r\n", ch);
return;
}
if(chdata.player_specials_saved.clan_rank == 1) {
send_to_char("Only thing left to do there is expell them . . .\r\n", ch);
return;
}
chdata.player_specials_saved.clan_rank -= 1;
sprintf(buf, "You have demoted %s to %s.\r\n", CAP(arg1), clan[GET_CLAN(ch)].rank_name[chdata.player_specials_saved.clan_rank - 1]);
send_to_char(buf, ch);
save_char_file_u(chdata);
}
}
void toggle_talk(struct char_data *ch)
{
if((GET_CLAN(ch) == -1 || GET_CLAN_RANK(ch) <= 0) && GET_LEVEL(ch) < LVL_GRGOD) {
send_to_char(noclan, ch);
return;
}
if(PRF_FLAGGED(ch, PRF_CLAN_TALK)) {
send_to_char("You will no longer hear the clan channel.\r\n", ch);
REMOVE_BIT(PRF_FLAGS(ch), PRF_CLAN_TALK);
}
else {
send_to_char("You will now hear the clan channel.\r\n", ch);
SET_BIT(PRF_FLAGS(ch), PRF_CLAN_TALK);
}
return;
}
void handle_help(struct char_data *ch, char *arg)
{
char *topics = "\
Clan Help Topics\r\n\
----------------\r\n\
Status - Privilege - Rank - Rname - Apply - Enlist - Expel\n\
Resign - List - Promote - Demote - Withdraw - Deposit - Talk - Info\r\n\
Who - Roster\r\n";
char *talk = "\
Clan talk:\r\n\
----------\r\n\
This command toggles a player preference flag on or off. When the flag\r\n\
is on, you will be able to use and view your clans csay channel.\r\n";
char *status = "\
Clan Status:\r\n\
-----------\r\n\
This command enables you to see all of the statistics of your\r\n\
current clan. This command has a privilege level so not everyone\r\n\
can see the structure of clans if the owner does not wish it.\r\n";
char *priv = "\
Clan Privilege <privilege name> <privilege level>:\r\n\
--------------------------------------------------\r\n\
This command sets privileges for certain clan commands. Only\r\n\
the highest level members of the clan can set privileges for\r\n\
the commands, and the privilege levels must be within the range\r\n\
of your clans current rank levels. The following commands may\r\n\
be set with privileges:\r\n\
\r\n\
Status - Withdraw - Enlist - Promote - Demote - Expel\r\n\
\r\n\
Example: Clan Privilege Enlist 4 <-- Members of level 4 or higher\r\n\
can enlist new members\r\n";
char *rank = "\
Clan Rank <direction> <num of ranks>:\r\n\
-------------------------------------\r\n\
This command sets the number of rank levels in your clan. Only\r\n\
the highest level members of a clan can set this. You cannot have\r\n\
more than 9 ranks, and you may not have less than 2. The direction\r\n\
field may be filled with the word 'raise' or 'lower' as appropriate,\r\n\
and the num of ranks field may be filled with the new number of ranks\r\n\
you desire. NOTE: If you lower the ranks of your clan, everyone in\r\n\
the clan (besides the leader) will be reduced to level 1.\r\n\
\r\n\
Example: Clan Rank Raise 6 <-- Raises your clan's ranks to 6\r\n\
Clan Rank Lower 5 <-- Now you're down to 5 ranks\r\n";
char *rname = "\
Clan Rname <rank level> <rank name>:\r\n\
------------------------------------\r\n\
This command sets the name of your clans ranks. When your clan is\r\n\
made, it is set with only two ranks, Member and Leader. If you raise\r\n\
the ranks in your clan to a higher number, the ranks will be displayed\r\n\
as N/A. You can change them (including the first two) at any time with\r\n\
this command.\r\n\
\r\n\
Example: Clan Rname 1 Initiate <-- Sets rank 1 title to Initiate\r\n";
char *apply = "\
Clan Apply <clan num>:\r\n\
----------------------\r\n\
If you wish to be enlisted into a clan, you must first apply to that\r\n\
clan. You must contact them yourself, and if they decide to accept you,\r\n\
your application number must be set to their clan number. Simply fill the\r\n\
field of <clan num> with the clan you wish to join. You may retract your\r\n\
application at any time by typing 'resign'.\r\n";
char *enlist = "\
Clan Enlist <victim>:\r\n\
---------------------\r\n\
This command lets you enlist new players into your clan if you of high\r\n\
enough rank. The <victim> field must be supplied with a characters name,\r\n\
and they must be present and applying to your clan.\r\n";
char *expel = "\
Clan Expel <victim>:\r\n\
--------------------\r\n\
This command lets you expel characters from your clan if you are of high\r\n\
enough rank. The <victim> field must be supplied with a character name\r\n\
and they must be present.\r\n";
char *resign = "\
Clan Resign:\r\n\
------------\r\n\
This command removes you from your current clan. If you are the owner of\r\n\
a clan, you may not resign. However, speak with a Clan God and have the\r\n\
clan deleted.\r\n";
char *list = "\
Clan List:\r\n\
----------\r\n\
This command lists all of the clan numbers, names, and owners.\r\n";
char *promote = "\
Clan Promote <victim>:\r\n\
----------------------\r\n\
This command raises the rank level of another clan member if you are of\r\n\
high enough ranking yourself. The victim must be present and you may not\r\n\
set anyone to a higher level than yourself.\r\n";
char *demote = "\
Clan Demote <victim>:\r\n\
---------------------\r\n\
This command lowers the rank level of another clan member if you are of\r\n\
high enough ranking yourself. The victim must be present and you may not\r\n\
set anyone lower than 1.\r\n";
char *withdraw = "\
Clan Withdraw <amount>:\r\n\
-----------------------\r\n\
This command allows you to take money out of the clan's bank account. You\r\n\
must be of high enough rank to do so, and must also be in your clan\r\n\
room.\r\n";
char *deposit = "\
Clan Depost <amount>:\r\n\
---------------------\r\n\
This command allows you to put money into your clan's bank account. You\r\n\
must be in your clan room to do so.\r\n";
char *info = "\
Clan Info <number>:\r\n\
-------------------\r\n\
This command allows you to view some basic information on any current\r\n\
clan on the mud. For a list of all clans and their numbers, type clan\r\n\
list.\r\n";
char *who = "\
Clan Who\r\n\
---------\r\n\
This command shows all of the players currently on-line that belong to\r\n\
your clan.\r\n";
char *roster = "\
Clan Roster\r\n\
-----------\r\n\
This command shows a list of all the players in your clan, their level,\r\n\
and their clan rank.\r\n";
if(!*arg) {
send_to_char(topics, ch);
return;
}
if(is_abbrev(arg, "status")) {
send_to_char(status, ch);
return;
}
if(is_abbrev(arg, "roster")) {
send_to_char(roster, ch);
return;
}
if(is_abbrev(arg, "who")) {
send_to_char(who, ch);
return;
}
if(is_abbrev(arg, "info")) {
send_to_char(info, ch);
return;
}
if(is_abbrev(arg, "list")) {
send_to_char(list, ch);
return;
}
if(is_abbrev(arg, "rname")) {
send_to_char(rname, ch);
return;
}
if(is_abbrev(arg, "privilege")) {
send_to_char(priv, ch);
return;
}
if(is_abbrev(arg, "expel")) {
send_to_char(expel, ch);
return;
}
if(is_abbrev(arg, "resign")) {
send_to_char(resign, ch);
return;
}
if(is_abbrev(arg, "demote")) {
send_to_char(demote, ch);
return;
}
if(is_abbrev(arg, "promote")) {
send_to_char(promote, ch);
return;
}
if(is_abbrev(arg, "enlist")) {
send_to_char(enlist, ch);
return;
}
if(is_abbrev(arg, "apply")) {
send_to_char(apply, ch);
return;
}
if(is_abbrev(arg, "rank")) {
send_to_char(rank, ch);
return;
}
if(is_abbrev(arg, "withdraw")) {
send_to_char(withdraw, ch);
return;
}
if(is_abbrev(arg, "talk")) {
send_to_char(talk, ch);
return;
}
if(is_abbrev(arg, "deposit")) {
send_to_char(deposit, ch);
return;
}
send_to_char(topics, ch);
return;
}
void clan_info_list(struct char_data *ch, char *arg)
{
int num;
if(!*arg) {
send_clan_format(ch);
return;
}
if(atoi(arg) < 1 || atoi(arg) > num_of_clans - 1) {
send_to_char("That clan doesn't exist.\r\n", ch);
return;
}
num = atoi(arg);
sprintf(buf, "Clan Information /r/n---------------------------------/r/nClan Number : &c%d&n /r/n Clan Name : &c%s&n/r/nClan Leader : &c%s&n\r\n/r/nClan Size : &c%d&n\r\n",
clan[num].number, clan[num].name, clan[num].leader,
clan[num].members);
send_to_char(buf, ch);
}
void clan_who(struct char_data *ch)
{
extern struct descriptor_data *descriptor_list;
struct descriptor_data *d;
int count = 0, num;
if(GET_CLAN(ch) < 0 || GET_CLAN_RANK(ch) == -1) {
send_to_char("You don't belong to a clan.\r\n", ch);
return;
}
num = GET_CLAN(ch);
send_to_char("Clan members on-line:\r\n", ch);
send_to_char("~~~~~~~~~~~~~~~~~~~~~\r\n", ch);
for(d = descriptor_list;d;d = d->next)
if(d->character && GET_CLAN(d->character) == num && GET_CLAN_RANK(d->character) > 0 &&
CAN_SEE(d->character, ch) && STATE(d) == CON_PLAYING) {
count++;
sprintf(buf, "%d. [%2d %s %s] %s\r\n", count,
GET_LEVEL(d->character), class_abbrevs[(int)
GET_CLASS(d->character)], clan[GET_CLAN(d->character)].rank_name[GET_CLAN_RANK(d->character) - 1],
GET_NAME(d->character));
send_to_char(buf, ch);
}
send_to_char("~~~~~~~~~~~~~~~~~~~~~\r\n", ch);
}
void clan_roster(struct char_data *ch)
{
int j, num;
char temp_name[MAX_INPUT_LENGTH];
extern int top_of_p_table;
struct char_data *victim;
struct char_file_u chdata;
if(GET_CLAN(ch) < 0 || GET_CLAN_RANK(ch) == -1) {
send_to_char("You don't belong to a clan.\r\n", ch);
return;
}
num = GET_CLAN(ch);
send_to_char("Full Clan Roster:\r\n", ch);
send_to_char("------------------------------------\r\n", ch);
for (j = 0; j <= top_of_p_table; j++) {
strcpy(temp_name, (player_table + j)->name);
if((victim=is_playing(temp_name))) {
if(GET_CLAN(victim)== num && GET_CLAN_RANK(victim) > 0) {
sprintf(buf, "[ %d %s ] %s - %s\r\n", GET_LEVEL(victim),
class_abbrevs[(int) GET_CLASS(victim)], GET_NAME(victim),
clan[num].rank_name[GET_CLAN_RANK(victim) - 1]);
send_to_char(buf, ch);
}
}else {
strcpy(temp_name, (player_table + j)->name);
load_char(temp_name, &chdata);
if(chdata.player_specials_saved.clan == num && chdata.player_specials_saved.clan_rank > 0) {
sprintf(buf, "[ %d %s ] %s - %s\r\n", chdata.level,
class_abbrevs[(int) chdata.chclass], chdata.name,
clan[num].rank_name[chdata.player_specials_saved.clan_rank - 1]);
send_to_char(buf, ch);
}
}
}
sprintf(buf, "\r\nTotal clan members: \\c06%d\\c00\r\n",
clan[num].members);
send_to_char("------------------------------------\r\n", ch);
}
void clan_numset(struct char_data *ch, char *arg)
{
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
half_chop(arg, arg1, arg2);
if(!strcmp(GET_NAME(ch), "Ash"))
clan[atoi(arg1)].number = atoi(arg2);
else
return;
}
ACMD(do_clan)
{
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
/* No mobiles in clans */
if (IS_NPC(ch))
return;
half_chop(argument, arg1, arg2);
if (is_abbrev(arg1, "create" )) { clan_create(ch,arg2); return ;}
if (is_abbrev(arg1, "destroy" )) { clan_destroy(ch, arg2); return;}
if (is_abbrev(arg1, "status")) { clan_score(ch); return; }
if (is_abbrev(arg1, "privilege")){ set_priv(ch, arg2); return; }
if (is_abbrev(arg1, "rank")) { handle_rank(ch, arg2); return; }
if (is_abbrev(arg1, "rname")) { clan_rank_name(ch, arg2); return; }
if (is_abbrev(arg1, "apply")) { clan_apply(ch, arg2); return; }
if (is_abbrev(arg1, "enlist")) { clan_enlist(ch, arg2); return; }
if (is_abbrev(arg1, "expel")) { clan_expel(ch, arg2); return; }
if (is_abbrev(arg1, "resign")) { clan_resign(ch); return; }
if (is_abbrev(arg1, "list")) { clan_list(ch); return; }
if (is_abbrev(arg1, "promote")) { clan_promote(ch, arg2); return; }
if (is_abbrev(arg1, "demote")) { clan_demote(ch, arg2); return; }
if (is_abbrev(arg1, "talk")) { toggle_talk(ch); return; }
if (is_abbrev(arg1, "help")) { handle_help(ch, arg2); return; }
if (is_abbrev(arg1, "info")) { clan_info_list(ch, arg2); return; }
if (is_abbrev(arg1, "who")) { clan_who(ch); return; }
if (is_abbrev(arg1, "roster")) { clan_roster(ch); return; }
if (is_abbrev(arg1, "numset")) { clan_numset(ch, arg2); return; }
if (is_abbrev(arg1, "newowner")) { clan_new_owner(ch, arg2); return; }
if (is_abbrev(arg1, "rename")) { clan_rename(ch, arg2); return; }
if (is_abbrev(arg1, "clanroom")) { set_clanroom(ch, arg2); return; }
if (is_abbrev(arg1, "withdraw")) { do_clan_withdraw(ch, arg2); return; }
if (is_abbrev(arg1, "deposit")) { do_clan_deposit(ch, arg2); return; }
else { send_clan_format(ch); return; }
}
ACMD(do_csay)
{
extern struct descriptor_data *descriptor_list;
struct descriptor_data *d;
int num;
/* No mobiles in clans */
if (IS_NPC(ch))
return;
if(GET_CLAN(ch) < 0 || GET_CLAN_RANK(ch) == -1) {
send_to_char("You don't belong to a clan.\r\n", ch);
return;
}
if(!PRF_FLAGGED(ch, PRF_CLAN_TALK)) {
send_to_char("You aren't even on the channel!\r\n", ch);
return;
}
if(PLR_FLAGGED(ch, PLR_NOSHOUT)) {
send_to_char("No. Muted. Look it up already.\r\n", ch);
return;
}
if(ROOM_FLAGGED(ch->in_room, ROOM_SOUNDPROOF)) {
send_to_char("The walls seem to absorb your words.\r\n", ch);
return;
}
num = GET_CLAN(ch);
skip_spaces(&argument);
if(!*argument) {
send_to_char("You must have SOMETHING to say, yes?\r\n", ch);
return;
}
for(d = descriptor_list;d;d = d->next) {
if(!d->connected && d->character && STATE(d) == CON_PLAYING
&& PRF_FLAGGED(d->character, PRF_CLAN_TALK)
&& GET_LEVEL(d->character) >= LVL_GRGOD &&
!PLR_FLAGGED(d->character, PLR_WRITING) &&
!PLR_FLAGGED(d->character, PLR_MAILING)) {
sprintf(buf, "\\c04%s clan (%d) says, '%s'\\c00\r\n",
GET_NAME(ch), GET_CLAN(ch), argument);
send_to_char(buf, d->character);
}
if(d->character && GET_CLAN(d->character) == num && GET_CLAN_RANK(d->character) > 0 &&
PRF_FLAGGED(d->character, PRF_CLAN_TALK) && ch != d->character
&& STATE(d) == CON_PLAYING && !PLR_FLAGGED(d->character, PLR_WRITING) &&
!PLR_FLAGGED(d->character, PLR_MAILING)) {
if(CAN_SEE(d->character, ch)) {
sprintf(buf, "\\c06%s clan says, '%s'\\c00\r\n", GET_NAME(ch),argument);
send_to_char(buf, d->character);
}
else {
sprintf(buf, "\\c06Someone clan says, '%s'\\c00\r\n",argument);
send_to_char(buf, d->character);
} }
}
sprintf(buf, "\\c06You clan say, '%s'\\c00\r\n", argument);
send_to_char(buf, ch);
}
ACMD(do_gcsay)
{
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
extern struct descriptor_data *descriptor_list;
struct descriptor_data *d;
int num;
if(!PRF_FLAGGED(ch, PRF_CLAN_TALK)) {
send_to_char("You aren't even on the channel!\r\n", ch);
return;
}
if(PLR_FLAGGED(ch, PLR_NOSHOUT)) {
send_to_char("No. Muted. Look it up already.\r\n", ch);
return;
}
half_chop(argument, arg1, arg2);
if(!*arg1) {
send_to_char("You must supply a clan number.\r\n", ch);
return;
}
num = atoi(arg1);
if(num < 1 || num > num_of_clans - 1) {
send_to_char("Ok, now how about a REAL clan number?\r\n", ch);
return;
}
if(!*arg2) {
send_to_char("You must have SOMETHING to say, yes?\r\n", ch);
return;
}
for(d = descriptor_list;d;d = d->next) {
if(!d->connected && d->character && STATE(d) == CON_PLAYING
&& PRF_FLAGGED(d->character, PRF_CLAN_TALK)
&& GET_LEVEL(d->character) >= LVL_GRGOD && d->character != ch
&& !PLR_FLAGGED(d->character, PLR_WRITING) &&
!PLR_FLAGGED(d->character, PLR_MAILING)) {
sprintf(buf, "\\c04%s clan (%d) says, '%s'\\c00\r\n",
GET_NAME(ch), num, arg2);
send_to_char(buf, d->character);
}
if(d->character && GET_CLAN(d->character) == num && GET_CLAN_RANK(d->character) > 0 &&
PRF_FLAGGED(d->character, PRF_CLAN_TALK) && ch != d->character
&& STATE(d) == CON_PLAYING && !PLR_FLAGGED(d->character, PLR_WRITING) &&
!d->connected && !PLR_FLAGGED(d->character, PLR_MAILING)) {
if(CAN_SEE(d->character, ch)) {
sprintf(buf, "\\c06%s clan says, '%s'\\c00\r\n", GET_NAME(ch),arg2);
send_to_char(buf, d->character);
}
else {
sprintf(buf, "\\c06Someone clan says, '%s'\\c00\r\n",arg2);
send_to_char(buf, d->character);
} }
}
sprintf(buf, "\\c06You clan (%d) say, '%s'\\c00\r\n", num, arg2);
send_to_char(buf, ch);
}
void save_char_file_u(struct char_file_u st)
{
int player_i;
int find_name(char *name);
if((player_i = find_name(st.name)) >=0 )
{
fseek(player_fl, player_i * sizeof(struct char_file_u), SEEK_SET);
fwrite(&st, sizeof(struct char_file_u), 1, player_fl);
}
}