/***************************************************************************** * DikuMUD (C) 1990, 1991 by: * * Sebastian Hammer, Michael Seifert, Hans Henrik Staefeldt, Tom Madsen, * * and Katja Nyboe. * *---------------------------------------------------------------------------* * MERC 2.1 (C) 1992, 1993 by: * * Michael Chastain, Michael Quan, and Mitchell Tse. * *---------------------------------------------------------------------------* * SMAUG 1.4 (C) 1994, 1995, 1996, 1998 by: Derek Snider. * * Team: Thoric, Altrag, Blodkai, Narn, Haus, Scryn, Rennard, Swordbearer, * * gorog, Grishnakh, Nivek, Tricops, and Fireblade. * *---------------------------------------------------------------------------* * SMAUG 1.7 FUSS by: Samson and others of the SMAUG community. * * Their contributions are greatly appreciated. * *---------------------------------------------------------------------------* * LoP (C) 2006, 2007, 2008 by: the LoP team. * *---------------------------------------------------------------------------* * Bank Support * *****************************************************************************/ /* * Can create/delete an account. * Can withdraw/deposit into an account. * Can transfer gold from your account to another. * Accounts can have other characters share it. * Memory Cleaned up on exit. * Bank data is saved and loaded. */ #include <ctype.h> #include <stdio.h> #include <string.h> #include <time.h> #include <sys/time.h> #include "h/mud.h" #include "h/sha256.h" #include "h/bank.h" bool check_parse_name( char *name, bool newchar ); BANK_DATA *first_bank, *last_bank; #define GCHANGE 1000000 bool has_gold( CHAR_DATA *ch, int amount ) { int cgold, cmillion; int check = amount; int millions = 0; if( !ch ) return false; cmillion = ch->mgold; cgold = ch->gold; while( check >= GCHANGE ) { millions++; check -= GCHANGE; } while( cgold < check ) { cmillion--; cgold += GCHANGE; } if( millions > cmillion ) return false; if( check > cgold ) return false; return true; } bool has_balance( BANK_DATA *bank, int amount ) { int cgold, cmillion; int check = amount; int millions = 0; if( !bank ) return false; cmillion = bank->mbalance; cgold = bank->balance; while( check >= GCHANGE ) { millions++; check -= GCHANGE; } while( cgold < check ) { cmillion--; cgold += GCHANGE; } if( millions > cmillion ) return false; if( check > cgold ) return false; return true; } void set_gold( CHAR_DATA *ch, int amount ) { int uamt = amount; if( !ch ) return; ch->mgold = 0; ch->gold = 0; while( uamt >= GCHANGE ) { ch->mgold++; uamt -= GCHANGE; } ch->gold += uamt; while( ch->gold >= GCHANGE ) { ch->mgold++; ch->gold -= GCHANGE; } } void increase_gold( CHAR_DATA *ch, int amount ) { int uamt = amount; if( !ch ) return; if( ch->mgold >= 2000000000 ) { send_to_char( "You already have as much gold as you can handle.\r\n", ch ); return; } while( uamt >= GCHANGE ) { if( ++ch->mgold >= 2000000000 ) { send_to_char( "You are now carrying as much gold as you can handle.\r\n", ch ); ch->gold = 0; return; } uamt -= GCHANGE; } ch->gold += uamt; while( ch->gold >= GCHANGE ) { if( ++ch->mgold >= 2000000000 ) { send_to_char( "You are now carrying as much gold as you can handle.\r\n", ch ); ch->gold = 0; return; } ch->gold -= GCHANGE; } } void increase_balance( CHAR_DATA *ch, BANK_DATA *bank, int amount ) { int uamt = amount; if( !bank ) return; if( bank->mbalance >= 2000000000 ) { if( ch ) send_to_char( "The account already has as much gold as it can handle.\r\n", ch ); return; } while( uamt >= GCHANGE ) { if( ++bank->mbalance >= 2000000000 ) { if( ch ) send_to_char( "The account now has as much gold as it can handle.\r\n", ch ); bank->balance = 0; return; } uamt -= GCHANGE; } bank->balance += uamt; while( bank->balance >= GCHANGE ) { if( ++bank->mbalance >= 2000000000 ) { if( ch ) send_to_char( "The account now has as much gold as it can handle.\r\n", ch ); bank->balance = 0; return; } bank->balance -= GCHANGE; } } void decrease_gold( CHAR_DATA *ch, int amount ) { int uamt = amount; if( !ch ) return; while( uamt >= GCHANGE ) { ch->mgold--; uamt -= GCHANGE; } while( ch->gold < uamt ) { ch->mgold--; ch->gold += GCHANGE; } ch->gold -= uamt; if( ch->mgold < 0 ) ch->mgold = 0; if( ch->gold < 0 ) ch->gold = 0; } void decrease_balance( BANK_DATA *bank, int amount ) { int uamt = amount; if( !bank ) return; while( uamt >= GCHANGE ) { bank->mbalance--; uamt -= GCHANGE; } while( bank->balance < uamt ) { bank->mbalance--; bank->balance += GCHANGE; } bank->balance -= uamt; if( bank->mbalance < 0 ) bank->mbalance = 0; if( bank->balance < 0 ) bank->balance = 0; } /* This is set up to show as first is in millions and amount has the rest */ char *show_big_nums( int millions, int amount ) { int index_new, rest, x; unsigned int nindex; char buf[32]; static char buf_new[32]; if( millions > 0 ) snprintf( buf, sizeof( buf ), "%d%6.6d", millions, amount ); else snprintf( buf, sizeof( buf ), "%d", amount ); rest = strlen( buf ) % 3; for( nindex = index_new = 0; nindex < strlen( buf ); nindex++, index_new++ ) { x = nindex - rest; if( nindex != 0 && ( x % 3 ) == 0 ) buf_new[index_new++] = ','; buf_new[index_new] = buf[nindex]; } buf_new[index_new] = '\0'; return buf_new; } void free_shared( SHARE_DATA *shared ) { STRFREE( shared->name ); DISPOSE( shared ); } void free_transaction( TRANSACTION_DATA *trans ) { STRFREE( trans->transaction ); DISPOSE( trans ); } void remove_shared( BANK_DATA *bank, SHARE_DATA *shared ) { UNLINK( shared, bank->first_share, bank->last_share, next, prev ); } void remove_transaction( BANK_DATA *bank, TRANSACTION_DATA *trans ) { UNLINK( trans, bank->first_transaction, bank->last_transaction, next, prev ); } void free_all_shared( BANK_DATA *bank ) { SHARE_DATA *shared, *shared_next; for( shared = bank->first_share; shared; shared = shared_next ) { shared_next = shared->next; remove_shared( bank, shared ); free_shared( shared ); } } void free_all_transactions( BANK_DATA *bank ) { TRANSACTION_DATA *trans, *trans_next; for( trans = bank->first_transaction; trans; trans = trans_next ) { trans_next = trans->next; remove_transaction( bank, trans ); free_transaction( trans ); } } void add_shared( BANK_DATA *bank, SHARE_DATA *shared ) { LINK( shared, bank->first_share, bank->last_share, next, prev ); } void add_transaction( BANK_DATA *bank, TRANSACTION_DATA *trans ) { LINK( trans, bank->first_transaction, bank->last_transaction, next, prev ); } void free_bank( BANK_DATA *bank ) { STRFREE( bank->account ); STRFREE( bank->created ); free_all_shared( bank ); free_all_transactions( bank ); DISPOSE( bank ); } void remove_bank( BANK_DATA *bank ) { UNLINK( bank, first_bank, last_bank, next, prev ); } void free_all_banks( void ) { BANK_DATA *bank, *bank_next; for( bank = first_bank; bank; bank = bank_next ) { bank_next = bank->next; remove_bank( bank ); free_bank( bank ); } } void add_bank( BANK_DATA *bank ) { LINK( bank, first_bank, last_bank, next, prev ); } void save_banks( void ) { BANK_DATA *bank; SHARE_DATA *shared; TRANSACTION_DATA *trans; FILE *fp; if( !first_bank ) { remove_file( BANK_FILE ); return; } if( !( fp = fopen( BANK_FILE, "w" ) ) ) { bug( "%s: Can't open %s for writing.", __FUNCTION__, BANK_FILE ); perror( BANK_FILE ); return; } for( bank = first_bank; bank; bank = bank->next ) { fprintf( fp, "%s", "#BANK\n" ); fprintf( fp, "Createdby %s~\n", bank->created ); fprintf( fp, "Account %s~\n", bank->account ); fprintf( fp, "MBalance %d\n", bank->mbalance ); fprintf( fp, "Balance %d\n", bank->balance ); for( shared = bank->first_share; shared; shared = shared->next ) if( shared->name ) fprintf( fp, "Shared %s~\n", shared->name ); for( trans = bank->first_transaction; trans; trans = trans->next ) if( trans->transaction ) fprintf( fp, "Trans %s~\n", trans->transaction ); fprintf( fp, "%s", "End\n\n" ); } fprintf( fp, "%s", "#END\n" ); fclose( fp ); fp = NULL; } void fread_bank( FILE *fp ) { const char *word; bool fMatch; BANK_DATA *bank; CREATE( bank, BANK_DATA, 1 ); bank->first_share = bank->last_share = NULL; for( ;; ) { word = feof( fp ) ? "End" : fread_word( fp ); fMatch = false; switch( UPPER( word[0] ) ) { case '*': fMatch = true; fread_to_eol( fp ); break; case 'E': if( !str_cmp( word, "End" ) ) { add_bank( bank ); return; } break; case 'A': KEY( "Account", bank->account, fread_string( fp ) ); break; case 'B': KEY( "Balance", bank->balance, fread_number( fp ) ); break; case 'C': KEY( "Createdby", bank->created, fread_string( fp ) ); break; case 'M': KEY( "MBalance", bank->mbalance, fread_number( fp ) ); break; case 'S': if( !str_cmp( word, "Shared" ) ) { SHARE_DATA *shared; CREATE( shared, SHARE_DATA, 1 ); shared->name = fread_string( fp ); add_shared( bank, shared ); fMatch = true; break; } break; case 'T': if( !str_cmp( word, "Trans" ) ) { TRANSACTION_DATA *trans; CREATE( trans, TRANSACTION_DATA, 1 ); trans->transaction = fread_string( fp ); add_transaction( bank, trans ); fMatch = true; break; } break; } if( !fMatch ) { bug( "%s: no match: %s", __FUNCTION__, word ); fread_to_eol( fp ); } } free_bank( bank ); } void load_banks( void ) { FILE *fp; first_bank = last_bank = NULL; if( !( fp = fopen( BANK_FILE, "r" ) ) ) return; for( ;; ) { char letter; char *word; letter = fread_letter( fp ); if( letter == '*' ) { fread_to_eol( fp ); continue; } if( letter != '#' ) { bug( "%s: # not found.", __FUNCTION__ ); break; } word = fread_word( fp ); if( !str_cmp( word, "BANK" ) ) { fread_bank( fp ); continue; } else if( !str_cmp( word, "END" ) ) break; else { bug( "%s: bad section (%s).", __FUNCTION__, word ); fread_to_eol( fp ); continue; } } fclose( fp ); fp = NULL; } typedef enum { BANK_DELETE, BANK_SHARE, BANK_TRANSFER, BANK_BALANCE, BANK_WITHDRAW, BANK_DEPOSIT, BANK_CREATE } bank_types; BANK_DATA *find_bank( char *account ) { BANK_DATA *bank; for( bank = first_bank; bank; bank = bank->next ) { if( !str_cmp( bank->account, account ) ) return bank; } return NULL; } CHAR_DATA *find_banker( CHAR_DATA *ch ) { CHAR_DATA *banker = NULL; for( banker = ch->in_room->first_person; banker; banker = banker->next_in_room ) { if( is_npc( banker ) && xIS_SET( banker->act, ACT_BANKER ) ) break; } return banker; } bool can_access_bank( BANK_DATA *bank, CHAR_DATA *ch ) { SHARE_DATA *shared; /* Creater of the account naturally has access */ if( !str_cmp( bank->created, ch->name ) ) return true; for( shared = bank->first_share; shared; shared = shared->next ) { /* If they are in the shared then they have access */ if( !str_cmp( shared->name, ch->name ) ) return true; } /* Well made it this far so naturally they can't access it */ return false; } void modify_shared( CHAR_DATA *ch, BANK_DATA *bank, char *argument ) { SHARE_DATA *shared; char arg[MIL]; bool adding, save = false; /* See if they have access to it already and they aren't the leader */ while( argument && argument[0] != '\0' ) { adding = true; /* Lets assume we will be adding at first */ argument = one_argument( argument, arg ); /* If the arg is the creator just ignore it so it doesn't get put in as shared */ if( !str_cmp( bank->created, arg ) ) continue; for( shared = bank->first_share; shared; shared = shared->next ) { /* Ok it was in the list so lets remove it */ if( !str_cmp( shared->name, arg ) ) { remove_shared( bank, shared ); free_shared( shared ); adding = false; save = true; ch_printf( ch, "%s is no longer able to access the account.\r\n", arg ); break; /* Break out the for loop */ } } /* Didn't find one so lets add it */ if( adding ) { /* Check for a valid pfile */ if( !valid_pfile( arg ) ) { ch_printf( ch, "%s is not a valid player and can't be added.\r\n", arg ); continue; } CREATE( shared, SHARE_DATA, 1 ); shared->name = STRALLOC( arg ); add_shared( bank, shared ); save = true; ch_printf( ch, "%s is now able to access the account.\r\n", arg ); } } if( save ) save_banks( ); else send_to_char( "Nothing changed in the account.\r\n", ch ); } void new_transaction( BANK_DATA *bank, char *string ) { TRANSACTION_DATA *trans; struct timeval now_time; int count = 0; char buf[MSL]; /* Update time. */ gettimeofday( &now_time, NULL ); current_time = ( time_t ) now_time.tv_sec; current_time += ( time_t ) TIME_MODIFY; snprintf( buf, sizeof( buf ), "%s %s", distime( current_time ), string ); CREATE( trans, TRANSACTION_DATA, 1 ); STRSET( trans->transaction, buf ); add_transaction( bank, trans ); for( trans = bank->first_transaction; trans; trans = trans->next ) ++count; while( count > 20 ) { trans = bank->first_transaction; remove_transaction( bank, trans ); free_transaction( trans ); --count; } } void give_interest( void ) { BANK_DATA *bank = NULL; char buf[MSL]; int interest = 0; for( bank = first_bank; bank; bank = bank->next ) { /* Interest on 1 million gold is 300 coins so use it instead of .0003 */ if( bank->mbalance > 0 ) interest += ( int )( bank->mbalance * 300 ); if( bank->balance > 0 ) interest += ( int )( bank->balance * .0003 ); if( interest > 0 ) { snprintf( buf, sizeof( buf ), "Gained %s interest.", num_punct( interest ) ); new_transaction( bank, buf ); increase_balance( NULL, bank, interest ); } } save_banks( ); } void handle_bank( CHAR_DATA *ch, char *account, short type, int amount, char *taccount ) { CHAR_DATA *banker = NULL; BANK_DATA *bank = NULL, *tbank = NULL; TRANSACTION_DATA *trans; char buf[MSL]; if( !( banker = find_banker( ch ) ) ) { send_to_char( "You aren't at a banker.\r\n", ch ); return; } /* Other wise we should be doing something to balance */ if( type != BANK_SHARE && type != BANK_DELETE && type != BANK_BALANCE && amount <= 0 ) { send_to_char( "You need to use a number above 0.\r\n", ch ); return; } if( ( bank = find_bank( account ) ) && type == BANK_CREATE ) { send_to_char( "An account by that name already exist.\r\n", ch ); return; } if( !bank && type != BANK_CREATE ) { send_to_char( "Invalid account.\r\n", ch ); return; } /* Create a new account with amount deposit */ if( type == BANK_CREATE ) { if( amount <= 0 ) { send_to_char( "You need to at least deposit something to open an account.\r\n", ch ); return; } if( amount > 2000000000 ) { send_to_char( "You can't deposit more then 2 billion coins at once.\r\n", ch ); return; } CREATE( bank, BANK_DATA, 1 ); bank->created = STRALLOC( ch->name ); bank->account = STRALLOC( account ); increase_balance( ch, bank, amount ); decrease_gold( ch, amount ); bank->first_share = bank->last_share = NULL; snprintf( buf, sizeof( buf ), "%s opened account with %d coins.", ch->name, amount ); new_transaction( bank, buf ); add_bank( bank ); save_banks( ); save_char_obj( ch ); ch_printf( ch, "Account %s has been created and has a balance of %s.\r\n", bank->account, show_big_nums( bank->mbalance, bank->balance ) ); return; } /* Do they have access to this account? */ if( !can_access_bank( bank, ch ) ) { send_to_char( "You don't have permission to do anything with that account.\r\n", ch ); return; } /* Modify who all else can access this account */ if( type == BANK_SHARE ) { modify_shared( ch, bank, taccount ); return; } /* Check balance */ if( type == BANK_BALANCE ) { ch_printf( ch, "You have %s gold in that account.\r\n", show_big_nums( bank->mbalance, bank->balance ) ); for( trans = bank->first_transaction; trans; trans = trans->next ) { if( trans == bank->first_transaction ) send_to_char( "Last 20 Transactions.\r\n", ch ); ch_printf( ch, "%s\r\n", trans->transaction ); } return; } /* Delete account */ if( type == BANK_DELETE ) { remove_bank( bank ); free_bank( bank ); save_banks( ); send_to_char( "The account has been deleted.\r\n", ch ); return; } /* Withdraw amount */ if( type == BANK_WITHDRAW ) { if( !has_balance( bank, amount ) ) { send_to_char( "You don't have that much to withdraw.\r\n", ch ); return; } if( amount <= 0 ) { send_to_char( "You can't withdraw 0 or less coins.\r\n", ch ); return; } if( amount > 2000000000 ) { send_to_char( "You can't withdraw more then 2 billion coins at once.\r\n", ch ); return; } snprintf( buf, sizeof( buf ), "%s withdrawled %d coins.", ch->name, amount ); new_transaction( bank, buf ); decrease_balance( bank, amount ); increase_gold( ch, amount ); ch_printf( ch, "You have withdrawn %d gold ", amount ); ch_printf( ch, "and now have %s on that account.\r\n", show_big_nums( bank->mbalance, bank->balance ) ); if( bank->balance <= 0 ) { remove_bank( bank ); free_bank( bank ); send_to_char( "As you get the last of your gold from the bank the account is closed.\r\n", ch ); } save_banks( ); save_char_obj( ch ); return; } /* Transfer amount */ if( type == BANK_TRANSFER ) { if( !has_balance( bank, amount ) ) { send_to_char( "You don't have that much in that account.\r\n", ch ); return; } if( amount <= 0 ) { send_to_char( "You can't transfer 0 or less coins.\r\n", ch ); return; } if( amount > 2000000000 ) { send_to_char( "You can't transfer more then 2 billion coins at once.\r\n", ch ); return; } if( !( tbank = find_bank( taccount ) ) ) { send_to_char( "Invalid account to transfer funds to.\r\n", ch ); return; } snprintf( buf, sizeof( buf ), "%s transfered %d coins from %s.", ch->name, amount, bank->account ); new_transaction( tbank, buf ); snprintf( buf, sizeof( buf ), "%s transfered %d coins to %s.", ch->name, amount, tbank->account ); new_transaction( bank, buf ); increase_balance( ch, tbank, amount ); decrease_balance( bank, amount ); save_banks( ); ch_printf( ch, "You have transfered %d gold to another account.\r\n", amount ); return; } /* Deposit amount */ if( type == BANK_DEPOSIT ) { if( !has_gold( ch, amount ) ) { send_to_char( "You can't deposit more gold then you have.\r\n", ch ); return; } if( amount <= 0 ) { send_to_char( "You can't deposit 0 or less coins.\r\n", ch ); return; } if( amount > 2000000000 ) { send_to_char( "You can't deposit more then 2 billion coins at once.\r\n", ch ); return; } snprintf( buf, sizeof( buf ), "%s deposited %d coins.", ch->name, amount ); new_transaction( bank, buf ); increase_balance( ch, bank, amount ); decrease_gold( ch, amount ); save_banks( ); save_char_obj( ch ); ch_printf( ch, "You have deposited %d gold and now have %s on that account.\r\n", amount, show_big_nums( bank->mbalance, bank->balance ) ); return; } send_to_char( "Ok, now exactly how did you get here???\r\n", ch ); } void bank_Usage_display( CHAR_DATA *ch ) { send_to_char( "Usage: bank <account> delete/balance\r\n", ch ); send_to_char( "Usage: bank <account> share <name>\r\n", ch ); send_to_char( "Usage: bank <account> create/deposit/withdraw <amount>.\r\n", ch ); send_to_char( "Usage: bank <account> transfer <amount> <account>\r\n", ch ); } CMDF( do_bank ) { CHAR_DATA *banker = NULL; char arg[MIL], account[MIL]; short type; int amount = 0; /* Show immortals above and equal to a certian level all bank accounts and amounts? */ if( get_trust( ch ) >= PERM_HEAD && ( !argument || argument[0] == '\0' ) ) { BANK_DATA *bank; int count = 0; for( bank = first_bank; bank; bank = bank->next ) { amount++; ch_printf( ch, "&[white]%15.15s &[yellow]%19s&D", bank->account, show_big_nums( bank->mbalance, bank->balance ) ); if( ++count == 3 ) { count = 0; send_to_char( "\r\n", ch ); } else send_to_char( " ", ch ); } if( count != 0 ) send_to_char( "\r\n", ch ); if( amount == 0 ) send_to_char( "&[white]No accounts found to display.&D\r\n", ch ); else ch_printf( ch, "&[lblue]%d &[white]accounts.&D\r\n", amount ); return; } if( !( banker = find_banker( ch ) ) ) { send_to_char( "You aren't at a banker.\r\n", ch ); return; } argument = one_argument( argument, account ); if( !account || account[0] == '\0' ) { bank_Usage_display( ch ); return; } argument = one_argument( argument, arg ); if( !str_cmp( arg, "create" ) ) type = BANK_CREATE; else if( !str_cmp( arg, "balance" ) ) type = BANK_BALANCE; else if( !str_cmp( arg, "deposit" ) ) type = BANK_DEPOSIT; else if( !str_cmp( arg, "withdraw" ) ) type = BANK_WITHDRAW; else if( !str_cmp( arg, "transfer" ) ) type = BANK_TRANSFER; else if( !str_cmp( arg, "delete" ) ) type = BANK_DELETE; else if( !str_cmp( arg, "share" ) ) type = BANK_SHARE; else { bank_Usage_display( ch ); return; } if( type != BANK_SHARE && type != BANK_DELETE && type != BANK_BALANCE ) { argument = one_argument( argument, arg ); amount = atoi( arg ); } if( type != BANK_SHARE && type != BANK_DELETE && type != BANK_BALANCE && amount <= 0 ) { bank_Usage_display( ch ); return; } handle_bank( ch, account, type, amount, argument ); }