kingdom.c

Go to the documentation of this file.

#if defined(macintosh)
#include <types.h>
#include <time.h>
#else
#include <sys/types.h>
#include <sys/time.h>
#endif
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include "merc.h"
#include "interp.h"
#include "recycle.h"
#include "tables.h"
#include "lookup.h"

void do_kingdom_guild (CHAR_DATA *ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    CHAR_DATA *victim;
    
    if (argument[0] == '\0')
    {
        send_to_char ("Syntax - Kguild <person>\n\r",ch);
        return;
    }
        
    /*if ((victim = get_char_world(ch, argument)) == NULL)
    {*/
        if (ch->level > 51  && (kingdom_lookup(argument) !=0 ))
        {
            sprintf(buf, "You are now a member of %s\n\r", kingdom_table[kingdom_lookup(argument)].name);
            send_to_char(buf,ch);
            if (ch->king != 0)
                kingdom_data[ch->king].member_count--;
            
            ch->king = kingdom_lookup(argument);

            kingdom_data[ch->king].member_count++;
            return;
        }
    if ((victim = get_char_world(ch,argument)) == NULL)
    {   
        send_to_char ("They are not here.\n\r",ch);
        return;
    }
    if (IS_NPC(victim))
    {
        send_to_char("They are not here.\n\r",ch);
        return;
    }

    if (victim->king > 0)
    {
        send_to_char ("They are already part of a kingdom!\n\r",ch);
        return;
    }
    if (!IS_SET(ch->kking, KING_RECRUITER))
    {
        if (ch->level > 51)
        {
        }
        else
        {
        send_to_char("You are not a recruiter.\n\r",ch);
        return;
    }
    }
    if (ch->king == 0)
    {
        send_to_char("How can you make them part of your [non-existant] kingdom?\n\r",ch);
        return;
    }

    if (victim->clan > 0 && !(ch->level > 51))
    {
        send_to_char("They are part of a clan!\n\r",ch);
        return;
    }
    if (victim == ch)
    {
        send_to_char ("heh..funny\n\r",ch);
        return;
    }

    sprintf(buf, "You have been guilded into %s by %s\n\r", kingdom_table[ch->king].name, ch->name);
    send_to_char(buf,victim);
    sprintf(buf, "%s %s\n\r",victim->name,kingdom_table[ch->king].join_string);
    send_to_all("",buf);
    victim->king = ch->king;
    kingdom_data[ch->king].member_count++;
    save_kingdom_data();


    
}



void do_kingdom_recruiter (CHAR_DATA *ch, char *argument)
{
    char buf[MAX_STRING_LENGTH];
    CHAR_DATA *victim;
    char arg[MAX_STRING_LENGTH];
    argument = one_argument(argument,arg);
    
    if (arg[0] == '\0')
    {
        if (ch->level > 51)
        {
            send_to_char("Syntax - kset [recruiter/guardian/leader] <person>\n\r",ch);
            return;
        }
        
        send_to_char("Syntax - kset [recruiter/guardian] <person>\n\r",ch);
        return;
    }
    if (ch->king == 0)
    {
        send_to_char ("You are not in a kingdom.\n\r",ch);
        return;
    }
    if (!IS_SET(ch->kking, KING_LEADER) && ch->level < 52)
    {
        send_to_char("You are not a kingdom leader.\n\r",ch);
        return;
    }
    if (!str_cmp(arg, "recruiter"))
    {
        if (argument[0] == '\0')
        {
            send_to_char ("Syntax - kset recruiter <person>\n\r",ch);
            return;
        }
        if ((victim = get_char_world(ch, argument)) == NULL)
        {
            send_to_char("They are not here.\n\r",ch);
            return;
        }
        if (IS_NPC(victim))
        {
            send_to_char("They are not here.\n\r",ch);
            return;
        }
        if (victim->king != ch->king)
        {
            send_to_char ("They are not a member of your kingdom.\n\r",ch);
            return;
        }
        sprintf(buf, "%s is now set to recruit in your kingdom.\n\r", victim->name);
        send_to_char(buf,ch);
        sprintf(buf, "You are now a recruiter of %s", kingdom_table[victim->king].name);
        send_to_char(buf,victim);
        SET_BIT(victim->kking, KING_RECRUITER);
        return;
    }
    if (!str_cmp(arg, "guardian"))
    {
        if (argument[0] == '\0')
        {
            send_to_char("Syntax - kset guardian <person>\n\r",ch);
            return;
        }
        if ((victim = get_char_world(ch,argument)) == NULL)
        {
            send_to_char("They are not here.\n\r",ch);
            return;
        }
        if (IS_NPC(victim))
        {
            send_to_char("They are not here.\n\r",ch);
            return;
        }
        if (victim->king != ch->king)
        {
            send_to_char("They are not a member of your kingdom.\n\r",ch);
            return;
        }
        sprintf(buf, "%s is now a guardian over your kingdom.\n\r", victim->name);
        send_to_char(buf,ch);
        sprintf(buf, "You are now a guardian of the kingdom of %s\n\r",kingdom_table[victim->king].name);
        send_to_char(buf,victim);
        SET_BIT(victim->kking, KING_GUARDIAN);
        return;
    }
    if (!str_cmp(arg, "leader") && ch->level > 51)
    {
        if (argument[0] == '\0')
        {
            send_to_char ("Syntax - kset leader <person>",ch);
            return;
        }
        if ((victim = get_char_world(ch, argument)) == NULL)
        {
            send_to_char("They are not here.\n\r",ch);
            return;
        }
        if (IS_NPC(victim))
        {
            send_to_char("They are not here.\n\r",ch);
            return;
        }
        if (victim->king == 0)
        {
            send_to_char ("They are not in a kingdom!\n\rdo 'kguild <kingdom name>' then 'kguild <person>' THEN kset leader!\n\r",ch);
            return;
        }
        sprintf(buf, "%s is now the leader of %s\n\r", victim->name, kingdom_table[victim->king].name);
        send_to_char(buf,ch);
        sprintf(buf, "You are now the leader of %s\n\r", kingdom_table[victim->king].name);
        send_to_char(buf,victim);
        SET_BIT(victim->kking, KING_LEADER);
        SET_BIT(victim->kking, KING_RECRUITER);
        return;
    }
    send_to_char("Syntax - kset [recruiter/guardian] <person>\n\r",ch);
    return;
    
    
        
    
}
void do_who_kingdom (CHAR_DATA *ch, char * argument)
{
    DESCRIPTOR_DATA *d;
        char buf[MAX_STRING_LENGTH];
        char buf2[MAX_STRING_LENGTH];
        CHAR_DATA *victim;
        BUFFER *buffer;
        int numchar;
        bool rgfKing[MAX_KINGDOM];
        register int iKing;
        bool fKingRestrict = FALSE;
        int nNumber;
        int iLevelLower;
        int iLevelUpper;
        bool fLeader;
        bool fRecruiter;
        int king;
        int space;
        iLevelLower    = 0;
        iLevelUpper    = MAX_LEVEL;
        fLeader = FALSE;
        fRecruiter = FALSE;
        for (iKing = 0; iKing < MAX_KINGDOM; iKing++)
            rgfKing[iKing] = FALSE;
        nNumber = 0;
            for ( ;; )
        {
                char arg[MAX_STRING_LENGTH];
            argument = one_argument( argument, arg );
                    if ( arg[0] == '\0' )
                    break;

                if ( is_number( arg ) )
                {
                    switch ( ++nNumber )
                        {
                        case 1: iLevelLower = atoi( arg ); break;
                        case 2: iLevelUpper = atoi( arg ); break;
                        default:
                        send_to_char( "Only two level numbers allowed.\n\r", ch );
                        return;
                    }
                    }
            else
            {
                if (!str_prefix(arg,"leader"))
                    fLeader = TRUE;
                else if (!str_prefix(arg, "recruiter"))
                    fRecruiter = TRUE;
                else
                {
                    iKing = kingdom_lookup(arg);
                    if (iKing)
                    {
                        fKingRestrict = TRUE;
                         rgfKing[iKing] = TRUE;
                    }
                    else
                    {
                        send_to_char("That's not a valid race, class, clan, or kingdom.\n\r",ch);
                        return;
                    }
                }
            }
        }
        buffer = new_buf();
        numchar=0;
        for (d=descriptor_list;d;d=d->next)
        {
            if ( d->connected != CON_PLAYING || !can_see( ch, d->character ) )
                    continue;
            victim   = ( d->original != NULL ) ? d->original : d->character;
            if (victim->king == 0)
            {
                continue;
            }
            king = victim->king;
            buf[0] = '\0';
                        buf2[0] = '\0';
            sprintf(buf, "[%2d %6s] ",victim->level,victim->race < MAX_PC_RACE ?pc_race_table[victim->race].who_name: "");
            sprintf(buf2,"%-16s",kingdom_table[victim->king].who_name);
            space = (20 - strlen(buf2));
            for( ; space > 0;space--)
            {
                strcat(buf2, " ");
            }
            strcat(buf,buf2);
            sprintf(buf2,"%-11s %-9s%-9s%-9s\n\r",victim->name, IS_SET (victim->kking, KING_LEADER) ? "({WLEADER{x) " : "",
                    IS_SET (victim->kking, KING_RECRUITER) ? "({WRECRUITER{x) " : "", IS_SET(victim->kking,
                        KING_GUARDIAN) ? "({WGUARDIAN{x)" : "");
            strcat(buf,buf2);
            add_buf(buffer,buf);
            numchar++;
        }
        sprintf(buf, "Total: %d.\n\r",numchar);
        add_buf(buffer,buf);
        page_to_char(buf_string(buffer),ch);
        free_buf(buffer);
         return;
}

void do_kingdom_status (CHAR_DATA *ch, char * argument)
{
    char buf[MSL];
    BUFFER *buffer;
    int runner=0;
    int col=0;

    if (ch->king <= 0)
    {
        send_to_char("You are not in a kingdom.\n\r",ch);
        return;
    }
    
    if (!IS_SET(ch->kking, KING_LEADER))
    {
        send_to_char("You are not the leader of your kingdom.\n\r",ch);
        return;
    }
    buffer = new_buf();

    sprintf(buf, "{cLeader{x: {W%-14s{x {cMember's{x: {W%d{x\n\r\n\r", kingdom_data[ch->king].leader, 
            kingdom_data[ch->king].member_count);
    add_buf(buffer, buf);

    for (runner=0;runner<=9;runner++)
    {
        sprintf(buf, "{cRank {C%-2d{x {W%-15s", runner+1, kingdom_data[ch->king].rank[runner]);
        add_buf(buffer,buf);
        if (++col % 2 == 0)
            add_buf(buffer, "\n\r");
    }
    add_buf(buffer, "\n\r");
    if (kingdom_data[ch->king].tithe == 0)
        sprintf(buf, "{cTithe{x: None.\n\r");
    else
        sprintf(buf, "{cTithe{x:{W %f%% {x\n\r", kingdom_data[ch->king].tithe);
    add_buf(buffer, buf);

    send_to_char(buf_string(buffer), ch);
    free_buf(buffer);
}

void do_kingdom_set_rank(CHAR_DATA *ch, char *argument)
{
    char buf[MSL];
    char arg1[MSL];

    argument = one_argument(argument,arg1);

    if (ch->king <=0)
    {
        send_to_char("You are not in a kingdom.\n\r",ch);
        return;
    }
    else if (IS_IMMORTAL(ch) && ch->king <=0)
    {
        send_to_char("Please set yourself into a kingdom first.\n\r",ch);
        return;
    }

    if (!IS_SET(ch->kking, KING_LEADER))
    {
        send_to_char("You are not the leader of your kingdom.\n\r",ch);
        return;
    }

    if (argument[0] == '\0' || arg1[0] == '\0')
    {
        send_to_char ("Syntax - krank <number> <rank>\n\r",ch);
        return;
    }

    if (atoi(arg1) > 10)
    {
        send_to_char("You may not have more or than 10 ranks.\n\r",ch);
        return;
    }
    
    if (atoi(arg1) < 1)
    {
        send_to_char("Invalid rank number. Ranks may only go one through ten.\n\r",ch);
        return;
    }

    if (strlen(argument) > 15)
    {
        send_to_char("Rank name too long.\n\r",ch);
        return;
    }

    sprintf(buf, "Rank %d assigned as %s.\n\r", atoi(arg1), argument);
    send_to_char(buf,ch);

    kingdom_data[ch->king].rank[atoi(arg1)-1] = str_dup(argument);
    save_kingdom_data();

    return;
}

    

    
    
             

---