void hcontrol_build_house(struct char_data * ch, char *arg)
{
char arg1[MAX_INPUT_LENGTH];
struct house_control_rec temp_house;
int virt_house, real_house, real_atrium, virt_atrium, exit_num;
long owner;
if (num_of_houses >= MAX_HOUSES) {
send_to_char("Max houses already defined.\r\n", ch);
return;
}
/* first arg: house's vnum */
arg = one_argument(arg, arg1);
if (!*arg1) {
send_to_char(HCONTROL_FORMAT, ch);
return;
}
virt_house = atoi(arg1);
if ((real_house = real_room(virt_house)) < 0) {
send_to_char("No such room exists.\r\n", ch);
return;
}
if ((find_house(virt_house)) >= 0) {
send_to_char("House already exists.\r\n", ch);
return;
}
/* second arg: direction of house's exit */
arg = one_argument(arg, arg1);
if (!*arg1) {
send_to_char(HCONTROL_FORMAT, ch);
return;
}
if ((exit_num = search_block(arg1, dirs, FALSE)) < 0) {
sprintf(buf, "'%s' is not a valid direction.\r\n", arg1);
send_to_char(buf, ch);
return;
}
if (TOROOM(real_house, exit_num) == NOWHERE) {
sprintf(buf, "There is no exit %s from room %d.\r\n", dirs[exit_num],
virt_house);
send_to_char(buf, ch);
return;
}
real_atrium = TOROOM(real_house, exit_num);
virt_atrium = world[real_atrium].number;
if (TOROOM(real_atrium, rev_dir[exit_num]) != real_house) {
send_to_char("A house's exit must be a two-way door.\r\n", ch);
return;
}
/* third arg: player's name */
arg = one_argument(arg, arg1);
if (!*arg1) {
send_to_char(HCONTROL_FORMAT, ch);
return;
}
if ((owner = get_id_by_name(arg1)) < 0) {
sprintf(buf, "Unknown player '%s'.\r\n", arg1);
send_to_char(buf, ch);
return;
}
temp_house.mode = HOUSE_PRIVATE;
temp_house.vnum = virt_house;
temp_house.atrium = virt_atrium;
temp_house.exit_num = exit_num;
temp_house.built_on = time(0);
temp_house.last_payment = 0;
temp_house.owner = owner;
temp_house.num_of_guests = 0;
house_control[num_of_houses++] = temp_house;
SET_BIT_AR(ROOM_FLAGS(real_house), ROOM_HOUSE);
SET_BIT_AR(ROOM_FLAGS(real_house), ROOM_PRIVATE);
SET_BIT_AR(ROOM_FLAGS(real_atrium), ROOM_ATRIUM);
House_crashsave(virt_house);
send_to_char("House built. Mazel tov!\r\n", ch);
House_save_control();
}
void do_ban( CHAR_DATA* ch, const char* argument)
{
char arg1[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
char arg3[MAX_INPUT_LENGTH];
char arg4[MAX_INPUT_LENGTH];
char *temp;
BAN_DATA *pban;
int value = 0, btime;
if( IS_NPC( ch ) ) /* Don't want mobs banning sites ;) */
{
send_to_char( "Monsters are too dumb to do that!\r\n", ch );
return;
}
if( !ch->desc ) /* No desc means no go :) */
{
bug( "%s", "do_ban: no descriptor" );
return;
}
set_char_color( AT_IMMORT, ch );
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
argument = one_argument( argument, arg3 );
argument = one_argument( argument, arg4 );
/*
* Do we have a time duration for the ban?
*/
if( arg4[0] != '\0' && is_number( arg4 ) )
btime = atoi( arg4 );
else
btime = -1;
/*
* -1 is default, but no reason the time should be greater than 1000
* * or less than 1, after all if it is greater than 1000 you are talking
* * around 3 years.
*/
if( btime != -1 && ( btime < 1 || btime > 1000 ) )
{
send_to_char( "Time value is -1 (forever) or from 1 to 1000.\r\n", ch );
return;
}
/*
* Need to be carefull with sub-states or everything will get messed up.
*/
switch ( ch->substate )
{
default:
bug( "%s", "do_ban: illegal substate" );
return;
case SUB_RESTRICTED:
send_to_char( "You cannot use this command from within another command.\r\n", ch );
return;
case SUB_NONE:
ch->tempnum = SUB_NONE;
break;
/*
* Returning to end the editing of the note
*/
case SUB_BAN_DESC:
add_ban( ch, "", "", 0, 0 );
return;
}
if( arg1[0] == '\0' )
goto syntax_message;
/*
* If no args are sent after the class/site/race, show the current banned
* * items. Shaddai
*/
if( !str_cmp( arg1, "site" ) )
{
if( arg2[0] == '\0' )
{
show_bans( ch, BAN_SITE );
return;
}
/*
* Are they high enough to ban sites?
*/
if( get_trust( ch ) < sysdata.ban_site_level )
{
ch_printf( ch, "You must be %d level to add bans.\r\n", sysdata.ban_site_level );
return;
}
if( arg3[0] == '\0' )
goto syntax_message;
if( !add_ban( ch, arg2, arg3, btime, BAN_SITE ) )
return;
}
else if( !str_cmp( arg1, "race" ) )
{
if( arg2[0] == '\0' )
{
show_bans( ch, BAN_RACE );
return;
}
/*
* Are they high enough level to ban races?
*/
if( get_trust( ch ) < sysdata.ban_race_level )
{
ch_printf( ch, "You must be %d level to add bans.\r\n", sysdata.ban_race_level );
return;
}
if( arg3[0] == '\0' )
goto syntax_message;
if( !add_ban( ch, arg2, arg3, btime, BAN_RACE ) )
return;
}
else if( !str_cmp( arg1, "class" ) )
{
if( arg2[0] == '\0' )
{
show_bans( ch, BAN_CLASS );
return;
}
/*
* Are they high enough to ban classes?
*/
if( get_trust( ch ) < sysdata.ban_class_level )
{
ch_printf( ch, "You must be %d level to add bans.\r\n", sysdata.ban_class_level );
return;
}
if( arg3[0] == '\0' )
goto syntax_message;
if( !add_ban( ch, arg2, arg3, btime, BAN_CLASS ) )
return;
}
else if( !str_cmp( arg1, "show" ) )
{
/*
* This will show the note attached to a ban
*/
if( arg2[0] == '\0' || arg3[0] == '\0' )
goto syntax_message;
temp = arg3;
if( arg3[0] == '#' ) /* Use #1 to show the first ban */
{
temp = arg3;
temp++;
if( !is_number( temp ) )
{
send_to_char( "Which ban # to show?\r\n", ch );
return;
}
value = atoi( temp );
if( value < 1 )
{
send_to_char( "You must specify a number greater than 0.\r\n", ch );
return;
}
}
if( !str_cmp( arg2, "site" ) )
{
pban = first_ban;
if( temp[0] == '*' )
temp++;
if( temp[strlen( temp ) - 1] == '*' )
temp[strlen( temp ) - 1] = '\0';
}
else if( !str_cmp( arg2, "class" ) )
pban = first_ban_class;
else if( !str_cmp( arg2, "race" ) )
pban = first_ban_race;
else
goto syntax_message;
for( ; pban; pban = pban->next )
if( value == 1 || !str_cmp( pban->name, temp ) )
break;
else if( value > 1 )
value--;
if( !pban )
{
send_to_char( "No such ban.\r\n", ch );
return;
}
ch_printf( ch, "Banned by: %s\r\n", pban->ban_by );
send_to_char( pban->note, ch );
return;
}
else
goto syntax_message;
return;
/* Catch all syntax message, make sure that return stays above this or you
* will get the syntax message everytime you issue the command even if it
* is a valid one. Shaddai
*/
syntax_message:
send_to_char( "Syntax: ban site <address> <type> <duration>\r\n", ch );
send_to_char( "Syntax: ban race <race> <type> <duration>\r\n", ch );
send_to_char( "Syntax: ban class <class> <type> <duration>\r\n", ch );
send_to_char( "Syntax: ban show <field> <number>\r\n", ch );
send_to_char( "Ban site lists current bans.\r\n", ch );
send_to_char( "Duration is the length of the ban in days.\r\n", ch );
send_to_char( "Type can be: newbie, mortal, all, warn or level.\r\n", ch );
send_to_char( "In ban show, the <field> is site, race or class,", ch );
send_to_char( " and the <number> is the ban number.\r\n", ch );
return;
}
/*
* Sets the warn flag on bans.
*/
void do_warn( CHAR_DATA* ch, const char* argument)
{
char arg1[MAX_STRING_LENGTH];
char arg2[MAX_STRING_LENGTH];
char *name;
int count = -1, type;
BAN_DATA *pban;
/*
* Don't want mobs or link-deads doing this.
*/
if( IS_NPC( ch ) )
{
send_to_char( "Monsters are too dumb to do that!\r\n", ch );
return;
}
if( !ch->desc )
{
bug( "%s", "do_warn: no descriptor" );
return;
}
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
if( arg1[0] == '\0' || arg2[0] == '\0' )
goto syntax_message;
if( arg2[0] == '#' )
{
name = arg2;
name++;
if( !is_number( name ) )
goto syntax_message;
count = atoi( name );
if( count < 1 )
{
send_to_char( "The number has to be above 0.\r\n", ch );
return;
}
}
/*
* We simply set up which ban list we will be looking at here.
*/
if( !str_cmp( arg1, "class" ) )
type = BAN_CLASS;
else if( !str_cmp( arg1, "race" ) )
type = BAN_RACE;
else if( !str_cmp( arg1, "site" ) )
type = BAN_SITE;
else
type = -1;
if( type == BAN_CLASS )
{
pban = first_ban_class;
arg2[0] = toupper( arg2[0] );
}
else if( type == BAN_RACE )
{
pban = first_ban_race;
arg2[0] = toupper( arg2[0] );
}
else if( type == BAN_SITE )
{
pban = first_ban;
}
else
goto syntax_message;
for( ; pban && count != 0; count--, pban = pban->next )
if( count == -1 && !str_cmp( pban->name, arg2 ) )
break;
if( pban )
{
/*
* If it is just a warn delete it, otherwise remove the warn flag.
*/
if( pban->warn )
{
if( pban->level == BAN_WARN )
{
dispose_ban( pban, type );
send_to_char( "Warn has been deleted.\r\n", ch );
}
else
{
pban->warn = FALSE;
send_to_char( "Warn turned off.\r\n", ch );
}
}
else
{
pban->warn = TRUE;
send_to_char( "Warn turned on.\r\n", ch );
}
save_banlist( );
}
else
{
ch_printf( ch, "%s was not found in the ban list.\r\n", arg2 );
return;
}
return;
/*
* The above return has to stay in!
*/
syntax_message:
send_to_char( "Syntax: warn class <field>\r\n", ch );
send_to_char( "Syntax: warn race <field>\r\n", ch );
send_to_char( "Syntax: warn site <field>\r\n", ch );
send_to_char( "Field is either #(ban_number) or the site/class/race.\r\n", ch );
send_to_char( "Example: warn class #1\r\n", ch );
return;
}
//Command Status: Installed, fairly well tested, near completetion.
void do_prayer( CHAR_DATA *ch, char *argument )
{
char arg[MIL];
AFFECT_DATA af;
one_argument( argument, arg );
if ( IS_NPC( ch ) )
return;
if ( IS_AFFECTED( ch, AFF_CHARM ) )
return;
if ( !arg || arg[0] == '\0' ) {
send_to_char( "Syntax: Prayer start\r\nSyntax: Prayer stop\r\n", ch );
return;
}
if ( !IS_AWAKE( ch ) ) {
send_to_char( "You cant pray while asleep.", ch );
return;
}
if ( ch->position == POS_MEDITATING ) {
send_to_char( "You are already meditating!\r\n", ch );
return;
}
if ( IS_AFFECTED( ch, AFF_PRAYER ) && !str_cmp( arg, "start" ) ) {
send_to_char( "But you're already praying.\r\n", ch );
return;
}
if ( !str_cmp( arg, "start" ) ) {
if ( can_use_skill( ch, number_percent( ), gsn_prayer ) ) {
if ( ch->fighting ) {
send_to_char( "You cannot start a prayer during combat.\r\n", ch );
return;
}
send_to_char( "You close your eyes and begin to pray.\r\n", ch );
af.type = gsn_prayer;
af.location = APPLY_NONE;
af.modifier = 0;
af.level = ch->level;
af.duration = -1;
af.bitvector = meb( AFF_PRAYER );
affect_to_char( ch, &af );
learn_from_success( ch, gsn_prayer );
}
else {
send_to_char( "You can't seem to concentrate enough to properly pray.\r\n", ch );
learn_from_failure( ch, gsn_prayer );
}
return;
}
if ( !str_cmp( arg, "stop" ) ) {
if ( !IS_AFFECTED( ch, AFF_PRAYER ) ) {
send_to_char( "But you're not praying.\r\n", ch );
return;
}
if ( ch->position != POS_STANDING )
set_position( ch, POS_STANDING );
send_to_char( "You come to an end in your prayer and slowly open your eyes.\r\n", ch );
affect_strip( ch, gsn_prayer );
xREMOVE_BIT( ch->affected_by, AFF_PRAYER );
return;
}
}
/**
* przekazywanie pieniêdzy
*/
bool money_from_char_to_char( CHAR_DATA *ch, CHAR_DATA *victim, long int amount, int nomination )
{
char buf [ MAX_INPUT_LENGTH ];
int multiplier = RATTING_NONE;
switch ( nomination )
{
case NOMINATION_COPPER:
if ( ch->copper < amount )
{
send_to_char( "Przecie¿ nie masz a¿ tylu miedzianych monet.\n\r", ch );
return FALSE;
}
ch->copper -= amount;
victim->copper += amount;
multiplier = RATTING_COPPER;
break;
case NOMINATION_SILVER:
if ( ch->silver < amount )
{
send_to_char( "Przecie¿ nie masz a¿ tylu srebrnych monet.\n\r", ch );
return FALSE;
}
ch->silver -= amount;
victim->silver += amount;
multiplier = RATTING_SILVER;
break;
case NOMINATION_GOLD:
if ( ch->gold < amount )
{
send_to_char( "Przecie¿ nie masz a¿ tylu z³otych monet.\n\r", ch );
return FALSE;
}
ch->gold -= amount;
victim->gold += amount;
multiplier = RATTING_GOLD;
break;
case NOMINATION_MITHRIL:
if ( ch-> mithril < amount )
{
send_to_char( "Przecie¿ nie masz a¿ tylu mithrilowych monet.\n\r", ch );
return FALSE;
}
ch->mithril -= amount;
victim->mithril += amount;
multiplier = RATTING_MITHRIL;
break;
default:
send_to_char( "Ale o co chodzi z tymi wszystkimi monetami?\n\r", ch );
return FALSE;
}
sprintf ( buf, "$n daje ci %s.", money_string_simple( amount, nomination, TRUE ) );
act( buf, ch, NULL, victim, TO_VICT );
act( "$n daje $X trochê monet.", ch, NULL, victim, TO_NOTVICT );
sprintf ( buf, "Dajesz $X %s.", money_string_simple( amount, nomination, TRUE ) );
act( buf, ch, NULL, victim, TO_CHAR );
amount *= multiplier;
append_file_format_daily
(
ch,
MONEY_LOG_FILE,
"-> S: %d %d (%d) - da³ kasê postaci %s",
money_count_copper( ch ) + amount,
money_count_copper( ch ),
-amount,
IS_NPC( victim ) ? victim->short_descr : victim->name
);
append_file_format_daily
(
victim,
MONEY_LOG_FILE,
"-> S: %d %d (%d) - dosta³ kasê od postaci %s",
money_count_copper( victim ) - amount,
money_count_copper( victim ),
amount,
IS_NPC( ch ) ? ch->short_descr : ch->name
);
return TRUE;
}
/*
* Stampa su scermo la scacchiera in grande
*/
void show_board( CHAR_DATA *ch, CHESSBOARD_DATA *board )
{
char buf[MSL*2];
int x;
int y;
if ( !ch )
{
send_log( NULL, LOG_BUG, "show_board: ch passato è NULL" );
return;
}
if ( !board )
{
send_log( NULL, LOG_BUG, "show_board: board passata è NULL" );
return;
}
send_to_char( ch, "&W 1 2 3 4 5 6 7 8\r\n" );
buf[0] = '\0';
for ( x = 0; x < 8; x++ )
{
/* Prima linea */
sprintf( buf+strlen(buf), " " );
for ( y = 0; y < 8; y++ )
{
if ( (x%2) == 0 )
strcat( buf, (y%2 == 0) ? WHITE_BACK : BLACK_BACK );
else
strcat( buf, (y%2 == 0) ? BLACK_BACK : WHITE_BACK );
strcat( buf, table_pieces[PIECE_NONE].wgraph1 );
}
sprintf( buf+strlen(buf), "%s\r\n", BLACK_BACK );
/* Seconda linea */
sprintf( buf+strlen(buf), "&W%c ", 'A' + x );
for ( y = 0; y < 8; y++ )
{
if ( (x%2) == 0 )
strcat( buf, (y%2 == 0) ? WHITE_BACK : BLACK_BACK );
else
strcat( buf, (y%2 == 0) ? BLACK_BACK : WHITE_BACK );
strcat( buf, (board->color[x][y] == COLOR_WHITE) ? WHITE_FORE : BLACK_FORE );
strcat( buf, (board->color[x][y] == COLOR_WHITE) ? table_pieces[board->piece[x][y]].wgraph1 : table_pieces[board->piece[x][y]].bgraph1 );
}
sprintf( buf+strlen(buf), "%s\r\n", BLACK_BACK );
/* Terza linea */
sprintf( buf+strlen(buf), " " );
for ( y = 0; y < 8; y++ )
{
if ( (x%2) == 0 )
strcat( buf, (y%2 == 0) ? WHITE_BACK : BLACK_BACK );
else
strcat( buf, (y%2 == 0) ? BLACK_BACK : WHITE_BACK );
strcat( buf, (board->color[x][y] == COLOR_WHITE) ? WHITE_FORE : BLACK_FORE );
strcat( buf, (board->color[x][y] == COLOR_WHITE) ? table_pieces[board->piece[x][y]].wgraph2 : table_pieces[board->piece[x][y]].bgraph2 );
}
sprintf( buf+strlen(buf), "%s\r\n", BLACK_BACK );
}
ch_printf( ch, "%s&w", buf );
}
/*
* Controlla e ritorna il tipo di mossa effettuata
*/
int is_valid_move( CHAR_DATA *ch, CHESSBOARD_DATA *board, int x, int y, int dx, int dy )
{
if ( !ch )
{
send_log( NULL, LOG_BUG, "is_valid_move: ch è NULL" );
return MOVE_INVALID;
}
if ( !board )
{
send_log( NULL, LOG_BUG, "is_valid_move: board è NULL" );
return MOVE_INVALID;
}
if ( x < 0 || y < 0 || x >= 8 || y >= 8 )
{
send_log( NULL, LOG_BUG, "is_valid_move: coordinate passate errate: x=%d y =%d", x, y );
return MOVE_INVALID;
}
if ( dx < 0 || dy < 0 || dx >= 8 || dy >= 8 )
{
send_log( NULL, LOG_BUG, "is_valid_move: coordinate passate errate: dx=%d dy =%d", dx, dy );
return MOVE_OFFBOARD;
}
if ( board->piece[x][y] == PIECE_NONE )
{
send_to_char( ch, "Non trovo nessun pezzo in quella casella.\r\n" );
return MOVE_INVALID;
}
if ( x == dx && y == dy )
{
send_to_char( ch, "La sorgente e l'arrivo della mossa sono identiche.\r\n" );
return MOVE_INVALID;
}
if ( (board->color[x][y] == COLOR_WHITE && ch == board->player1)
|| (board->color[x][y] == COLOR_BLACK && ch == board->player2) )
{
send_to_char( ch, "Sto cercando di muovere un pezzo che non è del mio colore.\r\n" );
return MOVE_WRONGCOLOR;
}
switch ( board->piece[x][y] )
{
default:
send_log( NULL, LOG_BUG, "is_valid_move():chess.c invaild piece: %d", board->piece[x][y] );
send_to_char( ch, "-> Mossa sbagliata, avverti i Coder <-" );
return MOVE_INVALID;
break;
case PIECE_PAWN:
if ( board->color[x][y] == COLOR_WHITE && dx == x+2 && x == 1 && dy == y
&& board->piece[dx][dy] == PIECE_NONE && board->piece[x+1][dy] == PIECE_NONE )
return MOVE_OK;
if ( board->color[x][y] == COLOR_BLACK && dx == x-2 && x == 6 && dy == y
&& board->piece[dx][dy] == PIECE_NONE && board->piece[x-1][dy] == PIECE_NONE )
return MOVE_OK;
if ( (board->color[x][y] == COLOR_WHITE && dx != x+1)
|| (board->color[x][y] == COLOR_BLACK && dx != x-1) )
{
send_to_char( ch, "Debbo muovere il pedone di un passo per volta, solo dalle caselle di partenza del pedone è consentito una mossa da 2.\r\n" );
return MOVE_INVALID;
}
if ( dy != y && dy != y-1 && dy != y+1 )
{
send_to_char( ch, "Debbo muovere il pedone sempre in avanti, oppure in diagonale di una casella quando può fare gambetto.\r\n" );
return MOVE_INVALID;
}
if ( dy == y )
{
if ( board->piece[dx][dy] == PIECE_NONE )
return MOVE_OK;
if ( SAME_COLOR(x, y, dx, dy) )
{
send_to_char( ch, "Non posso muovere dove c'è un'altro pezzo del mio stesso colore.\r\n" );
return MOVE_SAMECOLOR;
}
send_to_char( ch, "Non posso eseguire questa mossa.\r\n" );
return MOVE_BLOCKED;
}
else
{
if ( board->piece[dx][dy] == PIECE_NONE )
{
/* (FF) (bb) Bisognerebbe gestire anche il gambetto */
send_to_char( ch, "Non c'è nessun pezzo da mangiare in quella casella.\r\n" );
return MOVE_INVALID;
}
if ( SAME_COLOR(x, y, dx, dy) )
{
send_to_char( ch, "Non posso mangiare un pezzo del mio stesso colore.\r\n" );
return MOVE_SAMECOLOR;
}
if ( board->piece[dx][dy] != PIECE_KING )
return MOVE_TAKEN;
send_to_char( ch, "Non posso fare questa mossa.\r\n" );
return MOVE_INVALID;
}
break;
case PIECE_ROOK:
{
int cnt;
if ( dx != x && dy != y )
{
send_to_char( ch, "Devo muovere la torre verticalmente o orizzontalmente dalla propria posizione.\r\n" );
return MOVE_INVALID;
}
if ( dx == x )
{
for ( cnt = y; cnt != dy; )
{
if ( cnt != y && board->piece[x][cnt] != PIECE_NONE )
{
send_to_char( ch, "Non posso spostare la torre fino a lì, qualche pezzo blocca la strada" );
return MOVE_BLOCKED;
}
if ( dy > y )
cnt++;
else
cnt--;
}
}
else if ( dy == y )
{
for ( cnt = x; cnt != dx; )
{
if ( cnt != x && board->piece[cnt][y] != PIECE_NONE )
{
send_to_char( ch, "Non posso spostare la torre fino a lì, qualche pezzo blocca la strada" );
return MOVE_BLOCKED;
}
if ( dx > x )
cnt++;
else
cnt--;
}
}
if ( board->piece[dx][dy] == PIECE_NONE )
return MOVE_OK;
if ( SAME_COLOR(x, y, dx, dy) )
{
send_to_char( ch, "Non posso mangiare un pezzo del mio stesso colore.\r\n" );
return MOVE_SAMECOLOR;
}
return MOVE_TAKEN;
}
break;
case PIECE_KNIGHT:
if ( (dx == x - 2 && dy == y - 1)
|| (dx == x - 2 && dy == y + 1)
|| (dx == x - 1 && dy == y - 2)
|| (dx == x - 1 && dy == y + 2)
|| (dx == x + 1 && dy == y - 2)
|| (dx == x + 1 && dy == y + 2)
|| (dx == x + 2 && dy == y - 1)
|| (dx == x + 2 && dy == y + 1) )
{
if ( board->piece[dx][dy] == PIECE_NONE )
return MOVE_OK;
if ( SAME_COLOR(x, y, dx, dy) )
{
send_to_char( ch, "Non posso mangiare un pezzo del mio stesso colore.\r\n" );
return MOVE_SAMECOLOR;
}
return MOVE_TAKEN;
}
send_to_char( ch, "Devo posso muovere il mio cavallo così.\r\n" );
return MOVE_INVALID;
break;
case PIECE_BISHOP:
{
int l;
int m;
int blocked = FALSE;
if ( dx == x || dy == y )
{
send_to_char( ch, "Devo muovere l'alfiere diagonalmente dalla sua posizione.\r\n" );
return MOVE_INVALID;
}
l = x;
m = y;
while ( 1 )
{
if ( dx > x )
l++;
else
l--;
if ( dy > y )
m++;
else
m--;
if ( l > 7 || m > 7 || l < 0 || m < 0 )
{
send_to_char( ch, "Non posso uscire dalla scacchiera.\r\n" );
return MOVE_INVALID;
}
if ( l == dx && m == dy )
break;
if ( board->piece[l][m] != PIECE_NONE )
blocked = TRUE;
}
if ( l != dx || m != dy )
{
send_to_char( ch, "Devo muovere l'alfiere diagonalmente dalla sua posizione.\r\n" );
return MOVE_INVALID;
}
if ( blocked )
{
send_to_char( ch, "Non posso spostare il mio alfiere lì, qualche pezzo blocca la strada" );
return MOVE_BLOCKED;
}
if ( board->piece[dx][dy] == PIECE_NONE )
return MOVE_OK;
if ( SAME_COLOR(x, y, dx, dy) )
{
send_to_char( ch, "Non posso mangaire un pezzo del mio stesso colore.\r\n" );
return MOVE_SAMECOLOR;
}
return MOVE_TAKEN;
}
break;
case PIECE_QUEEN:
{
int l;
int m;
int blocked = FALSE;
l = x;
m = y;
while ( 1 )
{
if ( dx > x )
l++;
else if ( dx < x )
l--;
if ( dy > y )
m++;
else if ( dy < y )
m--;
if ( l > 7 || m > 7 || l < 0 || m < 0 )
{
send_to_char( ch, "Non posso muovere fuori dalla scacchiera.\r\n" );
return MOVE_INVALID;
}
if ( l == dx && m == dy )
break;
if ( board->piece[l][m] != PIECE_NONE )
blocked = TRUE;
}
if ( l != dx || m != dy )
{
send_to_char( ch, "Devo muovere la regina orizzonalmente, verticalmente o in diagonale dalla sua posizione.\r\n" );
return MOVE_INVALID;
}
if ( blocked )
{
send_to_char( ch, "Non posso spostare la mia regina lì, qualche pezzo blocca la strada" );
return MOVE_BLOCKED;
}
if ( board->piece[dx][dy] == PIECE_NONE )
return MOVE_OK;
if ( SAME_COLOR (x, y, dx, dy) )
{
send_to_char( ch, "Non posso mangiare un pezzo del mio stesso colore.\r\n" );
return MOVE_SAMECOLOR;
}
return MOVE_TAKEN;
}
break;
case PIECE_KING:
{
int sp;
int spc;
int sk;
int skc;
bool incheck = FALSE;;
if ( dx > x+1 || dx < x-1 || dy > y+1 || dy < y-1 )
{
send_to_char( ch, "Posso muovere il re di un solo passo attorno a sè, non oltre.\r\n" );
return MOVE_INVALID;
}
if ( SAME_COLOR(x, y, dx, dy) )
{
send_to_char( ch, "Non posso mangiare un pezzo del mio stesso colore.\r\n" );
return MOVE_SAMECOLOR;
}
sk = board->piece[x][y];
skc = board->color[x][y];
sp = board->piece[dx][dy];
spc = board->color[dx][dy];
board->piece[x][y] = PIECE_NONE;
board->piece[x][y] = COLOR_NONE;
board->piece[dx][dy] = sk;
board->color[dx][dy] = skc;
if ( king_in_check(board, sk, skc) > 0 )
incheck = TRUE;
board->piece[x][y] = sk;
board->color[x][y] = skc;
board->piece[dx][dy] = sp;
board->color[dx][dy] = spc;
if ( incheck )
{
send_to_char( ch, "Non posso muovere il re in quella casella, sarebbe sotto scacco.\r\n" );
return MOVE_CHECK;
}
if ( board->piece[dx][dy] == PIECE_NONE )
return MOVE_OK;
return MOVE_TAKEN;
}
break;
}
send_log( NULL, LOG_BUG, "is_valid_move: shouldn't get here" );
send_to_char( ch, "-> Mossa sbagliata, avverti i Coder <-" );
return MOVE_INVALID;
}
void build_save_rooms()
{
ROOM_INDEX_DATA *pRoomIndex;
EXTRA_DESCR_DATA *pEd;
int d;
EXIT_DATA *pexit;
int locks=0;
if (Pointer==NULL) /* Start */
{
if (CurSaveArea->first_area_room==NULL)
{
Section++;
return;
}
send_to_char("Saving rooms.\n",CurSaveChar);
fprintf(SaveFile,"#ROOMS\n");
Pointer=CurSaveArea->first_area_room;
}
pRoomIndex=Pointer->data;
fprintf(SaveFile,"#%i\n",pRoomIndex->vnum);
fprintf(SaveFile,"%s~\n",pRoomIndex->name);
fprintf(SaveFile,"%s~\n",pRoomIndex->description);
fprintf(SaveFile,"%i %i\n",pRoomIndex->room_flags,pRoomIndex->sector_type);
/* Now do doors. */
for (d=0;d<6;d++)
{
if (pRoomIndex->exit[d] )
{
fprintf(SaveFile,"D%i\n",d);
pexit=pRoomIndex->exit[d];
fprintf(SaveFile,"%s~\n",pexit->description);
fprintf(SaveFile,"%s~\n",pexit->keyword);
/* Deal with locks */
/* -S- Mod: Filter out EX_LOCKED and EX_CLOSED and save exit_info */
locks=pexit->exit_info;
if ( IS_SET( locks, EX_CLOSED ) )
REMOVE_BIT( locks, EX_CLOSED );
if ( IS_SET( locks, EX_LOCKED ) )
REMOVE_BIT( locks, EX_LOCKED );
#if 0
/* BUG: before, an isdoor OR pickproof flag alone would give locks=1 */
if (pexit->exit_info & EX_ISDOOR)
locks++;
if (pexit->exit_info & EX_PICKPROOF)
locks++;
#endif
fprintf(SaveFile,"%i %i %i\n",locks,pexit->key,pexit->vnum);
}
}
/* Now do extra descripts.. */
pEd=pRoomIndex->first_exdesc;
while (pEd)
{
fprintf(SaveFile,"E\n");
fprintf(SaveFile,"%s~\n",pEd->keyword);
fprintf(SaveFile,"%s~\n",pEd->description);
pEd=pEd->next;
}
/* End of one room */
fprintf(SaveFile,"S\n");
Pointer=Pointer->next;
if (Pointer==NULL) /* End */
{
fprintf(SaveFile,"#0\n");
Section++;
}
return;
}
void show_char_to_char(struct char_data *i, struct char_data *ch, int mode)
{
char buffer[MAX_STRING_LENGTH];
int j, found, percent;
struct obj_data *tmp_obj;
if (mode == 0) {
if (IS_AFFECTED(i, AFF_HIDE) || !CAN_SEE(ch,i)) {
if (IS_AFFECTED(ch, AFF_SENSE_LIFE))
send_to_char("You sense a hidden life form in the room.\n\r", ch);
return;
}
if (!(i->player.long_descr)||(GET_POS(i) != i->specials.default_pos)) {
/* A player char or a mobile without long descr, or not in default pos. */
if (!IS_NPC(i)) {
strcpy(buffer,GET_NAME(i));
strcat(buffer," ");
strcat(buffer,GET_TITLE(i));
} else {
strcpy(buffer, i->player.short_descr);
CAP(buffer);
}
if ( IS_AFFECTED(i,AFF_INVISIBLE))
strcat(buffer," (invisible)");
switch(GET_POS(i)) {
case POSITION_STUNNED :
strcat(buffer," is lying here, stunned.");
break;
case POSITION_INCAP :
strcat(buffer," is lying here, incapacitated.");
break;
case POSITION_MORTALLYW:
strcat(buffer," is lying here, mortally wounded.");
break;
case POSITION_DEAD :
strcat(buffer," is lying here, dead.");
break;
case POSITION_STANDING :
strcat(buffer," is standing here.");
break;
case POSITION_SITTING :
strcat(buffer," is sitting here.");
break;
case POSITION_RESTING :
strcat(buffer," is resting here.");
break;
case POSITION_SLEEPING :
strcat(buffer," is sleeping here.");
break;
case POSITION_FIGHTING :
if (i->specials.fighting) {
strcat(buffer," is here, fighting ");
if (i->specials.fighting == ch)
strcat(buffer," YOU!");
else {
if (i->in_room == i->specials.fighting->in_room)
if (IS_NPC(i->specials.fighting))
strcat(buffer, i->specials.fighting->player.short_descr);
else
strcat(buffer, GET_NAME(i->specials.fighting));
else
strcat(buffer, "someone who has already left.");
}
} else /* NIL fighting pointer */
strcat(buffer," is here struggling with thin air.");
break;
default :
strcat(buffer," is floating here.");
break;
}
if (IS_AFFECTED(ch, AFF_DETECT_EVIL)) {
if (IS_EVIL(i))
strcat(buffer, " (Red Aura)");
}
strcat(buffer,"\n\r");
send_to_char(buffer, ch);
}
else /* npc with long */
{
if (IS_AFFECTED(i,AFF_INVISIBLE))
strcpy(buffer,"*");
else
*buffer = '\0';
if (IS_AFFECTED(ch, AFF_DETECT_EVIL)) {
if (IS_EVIL(i))
strcat(buffer, " (Red Aura)");
}
strcat(buffer, i->player.long_descr);
send_to_char(buffer, ch);
}
if (IS_AFFECTED(i,AFF_SANCTUARY))
act("$n glows with a bright light!", FALSE, i, 0, ch, TO_VICT);
} else if (mode == 1) {
if (i->player.description)
send_to_char(i->player.description, ch);
else {
act("You see nothing special about $m.", FALSE, i, 0, ch, TO_VICT);
}
/* Show a character to another */
if (GET_MAX_HIT(i) > 0)
percent = (100*GET_HIT(i))/GET_MAX_HIT(i);
else
percent = -1; /* How could MAX_HIT be < 1?? */
if (IS_NPC(i))
strcpy(buffer, i->player.short_descr);
else
strcpy(buffer, GET_NAME(i));
if (percent >= 100)
strcat(buffer, " is in an excellent condition.\n\r");
else if (percent >= 90)
strcat(buffer, " has a few scratches.\n\r");
else if (percent >= 75)
strcat(buffer, " has some small wounds and bruises.\n\r");
else if (percent >= 50)
strcat(buffer, " has quite a few wounds.\n\r");
else if (percent >= 30)
strcat(buffer, " has some big nasty wounds and scratches.\n\r");
else if (percent >= 15)
strcat(buffer, " looks pretty hurt.\n\r");
else if (percent >= 0)
strcat(buffer, " is in an awful condition.\n\r");
else
strcat(buffer, " is bleeding awfully from big wounds.\n\r");
send_to_char(buffer, ch);
found = FALSE;
for (j=0; j< MAX_WEAR; j++) {
if (i->equipment[j]) {
if (CAN_SEE_OBJ(ch,i->equipment[j])) {
found = TRUE;
}
}
}
if (found) {
act("\n\r$n is using:", FALSE, i, 0, ch, TO_VICT);
for (j=0; j< MAX_WEAR; j++) {
if (i->equipment[j]) {
if (CAN_SEE_OBJ(ch,i->equipment[j])) {
send_to_char(where[j],ch);
show_obj_to_char(i->equipment[j],ch,1);
}
}
}
}
if ((GET_CLASS(ch) == CLASS_THIEF) && (ch != i)) {
found = FALSE;
send_to_char("\n\rYou attempt to peek at the inventory:\n\r", ch);
for(tmp_obj = i->carrying; tmp_obj; tmp_obj = tmp_obj->next_content) {
if (CAN_SEE_OBJ(ch, tmp_obj) && (number(0,20) < GET_LEVEL(ch))) {
show_obj_to_char(tmp_obj, ch, 1);
found = TRUE;
}
}
if (!found)
send_to_char("You can't see anything.\n\r", ch);
}
} else if (mode == 2) {
/* Lists inventory */
act("$n is carrying:", FALSE, i, 0, ch, TO_VICT);
list_obj_to_char(i->carrying,ch,1,TRUE);
}
}
void build_save_mobs()
{
MOB_INDEX_DATA *pMobIndex;
MPROG_DATA* mprg;
int finish_progs;
if (Pointer==NULL) /* Start */
{
if (CurSaveArea->first_area_mobile==NULL)
{
Section++;
return;
}
send_to_char("Saving mobs.\n",CurSaveChar);
fprintf(SaveFile,"#MOBILES\n");
Pointer=CurSaveArea->first_area_mobile;
}
pMobIndex=Pointer->data;
fprintf(SaveFile,"#%i\n",pMobIndex->vnum);
fprintf(SaveFile,"%s~\n",pMobIndex->player_name);
fprintf(SaveFile,"%s~\n",pMobIndex->short_descr);
fprintf(SaveFile,"%s~\n",pMobIndex->long_descr);
fprintf(SaveFile,"%s~\n",pMobIndex->description);
fprintf(SaveFile,"%i %i %i S\n",pMobIndex->act,
pMobIndex->affected_by,pMobIndex->alignment);
fprintf(SaveFile,"%i %i\n",pMobIndex->level,pMobIndex->sex);
fprintf(SaveFile,"%i %i %i\n",pMobIndex->ac_mod, pMobIndex->hr_mod,
pMobIndex->dr_mod);
/* Save in Envy format.... */
/* fprintf(Envy,"#%i\n",((pMobIndex->vnum)+offset) ); */
/* fprintf(Envy,"%s~\n",pMobIndex->player_name); */
/* fprintf(Envy,"%s~\n",pMobIndex->short_descr); */
/* fprintf(Envy,"%s~\n",pMobIndex->long_descr); */
/* fprintf(Envy,"%s~\n",pMobIndex->description); */
/* fprintf(Envy,"%i %i %i S\n",pMobIndex->act, */
/* pMobIndex->affected_by,pMobIndex->alignment); */
/* fprintf(Envy,"%i 0 0 0d0+0 0d0+0\n0 0\n0 0 */
/* %i\n",convert(pMobIndex->level),pMobIndex->sex); */
/* Write out new details - clan, class, race and skills
* The '!' signifies new section to load_mobiles() in db.c
*/
fprintf( SaveFile, "! %i %i %i %i %i %i %i\n",
pMobIndex->class,
pMobIndex->clan,
pMobIndex->race,
pMobIndex->position,
pMobIndex->skills,
pMobIndex->cast,
pMobIndex->def );
mprg=pMobIndex->first_mprog;
finish_progs=0;
while (mprg)
{
if (mprg->filename == NULL)
{
fprintf(SaveFile,">%s ",mprog_type_to_name(mprg->type));
fprintf(SaveFile,"%s~\n",mprg->arglist);
fprintf(SaveFile,"%s~\n",mprg->comlist);
finish_progs=1;
}
mprg=mprg->next;
}
if (finish_progs)
{
fprintf(SaveFile,"|\n");
}
Pointer=Pointer->next;
if (Pointer==NULL) /* End */
{
fprintf(SaveFile,"#0\n");
Section++;
}
return;
}
void build_save_objects()
{
OBJ_INDEX_DATA *pObject;
AFFECT_DATA * pAf;
EXTRA_DESCR_DATA *pEd;
int val0,val1,val2,val3;
if (Pointer==NULL) /* Start */
{
if (CurSaveArea->first_area_object==NULL)
{
Section++;
return;
}
send_to_char("Saving objects.\n",CurSaveChar);
fprintf(SaveFile,"#OBJECTS\n");
Pointer=CurSaveArea->first_area_object;
}
pObject=Pointer->data;
fprintf(SaveFile,"#%i\n",pObject->vnum);
fprintf(SaveFile,"%s~\n",pObject->name);
fprintf(SaveFile,"%s~\n",pObject->short_descr);
fprintf(SaveFile,"%s~\n",pObject->description);
fprintf(SaveFile,"%i %i %i %i\n",pObject->item_type,pObject->extra_flags,
pObject->wear_flags,pObject->item_apply);
/* Check for pills, potions, scrolls, staffs and wands. */
val0=pObject->value[0];
val1=pObject->value[1];
val2=pObject->value[2];
val3=pObject->value[3];
switch ( pObject->item_type )
{
case ITEM_PILL:
case ITEM_POTION:
case ITEM_SCROLL:
val1=val1<0 ? -1 : skill_table[val1].slot;
val2=val2<0 ? -1 : skill_table[val2].slot;
val3=val3<0 ? -1 : skill_table[val3].slot;
break;
case ITEM_STAFF:
case ITEM_WAND:
val3=val3<0 ? -1 : skill_table[val3].slot;
break;
}
fprintf(SaveFile,"%i %i %i %i\n",val0,val1,val2,val3);
fprintf(SaveFile,"%i\n",pObject->weight);
pAf=pObject->first_apply;
while (pAf)
{
fprintf(SaveFile,"A\n");
fprintf(SaveFile,"%i %i\n",pAf->location,pAf->modifier);
pAf=pAf->next;
}
pEd=pObject->first_exdesc;
while (pEd)
{
fprintf(SaveFile,"E\n");
fprintf(SaveFile,"%s~\n",pEd->keyword);
fprintf(SaveFile,"%s~\n",pEd->description);
pEd=pEd->next;
}
if ( ( pObject->level > 1 ) && (pObject->level < 130 ) )
{
fprintf(SaveFile, "L\n");
fprintf(SaveFile,"%d\n",pObject->level);
}
else
{
fprintf(SaveFile, "L\n");
fprintf(SaveFile,"%d\n", 1);
}
/* Now for Envy... taken from my OLC :P */
Pointer=Pointer->next;
if (Pointer==NULL) /* End */
{
fprintf(SaveFile,"#0\n");
Section++;
}
return;
}
/* does aliasing and other fun stuff */
void substitute_alias(DESCRIPTOR_DATA *d, const char *argument)
{
CHAR_DATA *ch;
char buf[MAX_STRING_LENGTH],prefix[MAX_INPUT_LENGTH],name[MAX_INPUT_LENGTH];
const char *point;
char* lines;
int alias;
ch = d->original ? d->original : d->character;
/* check for prefix */
if (ch->prefix[0] != '\0' && str_prefix("prefix",argument)) {
if (strlen(ch->prefix) + strlen(argument) > MAX_INPUT_LENGTH)
send_to_char("Line to long, prefix not processed.\r\n",ch);
else {
sprintf(prefix,"%s %s",ch->prefix,argument);
argument = prefix;
}
}
if ( IS_NPC(ch)
|| ch->pcdata->alias[0] == NULL
|| !str_prefix("alias",argument) || !str_prefix("una",argument)
|| !str_prefix("prefix",argument)) {
interpret(d->character,argument);
return;
}
strcpy(buf,argument);
for (alias = 0; alias < MAX_ALIAS; alias++) { /* go through the aliases */
if (ch->pcdata->alias[alias] == NULL)
break;
if (!str_prefix(ch->pcdata->alias[alias],argument)) {
point = one_argument(argument,name);
if (!strcmp(ch->pcdata->alias[alias],name)) {
buf[0] = '\0';
strcat(buf,ch->pcdata->alias_sub[alias]);
if (*point != 0) {
strcat(buf," ");
strcat(buf,point);
}
break;
}
if (strlen(buf) > MAX_INPUT_LENGTH) {
send_to_char("Alias substitution too long. Truncated.\r\n",ch);
buf[MAX_INPUT_LENGTH -1] = '\0';
}
}
}
/* ';' is now command separator... By Oxtal 1997*/
if ( (lines = strchr(buf,';')) == NULL )
interpret(d->character,buf); // A single command : just play it
else {
// Process 1st cmd; delay others
char *sep;
int lineslen;
*lines = 0; // Truncate buf; lines = rest and lineslen... its length!
lines++;
lineslen = strlen(lines);
// replace ; by LF
for (sep = strchr(lines,';'); sep != NULL; sep = strchr(sep,';'))
*sep = '\n';
// Just put lines into the desc. buffer!
if ( lineslen + strlen(d->inbuf) + 1 >= sizeof(d->inbuf) - 10 ) {
send_to_char("Do you know that you've just failed to crash the mud?\n\r",ch);
return; // That's for spam's kings
}
else {
memmove(d->inbuf+lineslen+1,d->inbuf,strlen(d->inbuf)+1);
memcpy(d->inbuf,lines,lineslen);
d->inbuf[lineslen] = '\n';
//send_to_charf(ch,"Buf %s\n\r",d->inbuf);
}
// Then play 1st cmd
interpret(d->character,buf);
}
}
void do_alias(CHAR_DATA *ch, const char *argument)
{
CHAR_DATA *rch;
char arg[MAX_INPUT_LENGTH],buf[MAX_STRING_LENGTH];
// Modified by SinaC 2001 int before
unsigned int pos;
// smash_tilde(argument);
if (ch->desc == NULL)
rch = ch;
else
rch = ch->desc->original ? ch->desc->original : ch;
if (IS_NPC(rch))
return;
argument = one_argument(argument,arg);
if (arg[0] == '\0') {
if (rch->pcdata->alias[0] == NULL) {
send_to_char("You have no aliases defined.\n\r",ch);
return;
}
send_to_char("Your current aliases are:\n\r",ch);
for (pos = 0; pos < MAX_ALIAS; pos++) {
if (rch->pcdata->alias[pos] == NULL
|| rch->pcdata->alias_sub[pos] == NULL)
break;
sprintf(buf," %s: %s\n\r",rch->pcdata->alias[pos],
rch->pcdata->alias_sub[pos]);
send_to_char(buf,ch);
}
return;
}
if (!str_prefix("una",arg) || !str_cmp("alias",arg)) {
send_to_char("Sorry, that word is reserved.\n\r",ch);
return;
}
if (argument[0] == '\0') {
for (pos = 0; pos < MAX_ALIAS; pos++) {
if (rch->pcdata->alias[pos] == NULL
|| rch->pcdata->alias_sub[pos] == NULL)
break;
if (!str_cmp(arg,rch->pcdata->alias[pos])) {
sprintf(buf,"%s aliases to '%s'.\n\r",rch->pcdata->alias[pos],
rch->pcdata->alias_sub[pos]);
send_to_char(buf,ch);
return;
}
}
send_to_char("That alias is not defined.\n\r",ch);
return;
}
// Added by SinaC 2000
for ( pos = 0; pos < strlen(arg); pos++ )
if ( arg[pos]=='\'' || arg[pos]=='"' ) {
send_to_char("Aliases with that kind of character are not allowed!\n\r", ch);
return;
}
/*
for ( pos = 0; pos < strlen(argument); pos++ )
if ( argument[pos]=='\'' || argument[pos]=='"' ) {
send_to_char("Aliases with that kind of character are not allowed!\n\r", ch);
return;
}
*/
if (!str_prefix(argument,"delete") || !str_prefix(argument,"prefix")) {
send_to_char("That shall not be done!\n\r",ch);
return;
}
for (pos = 0; pos < MAX_ALIAS; pos++) {
if (rch->pcdata->alias[pos] == NULL)
break;
if (!str_cmp(arg,rch->pcdata->alias[pos])) {/* redefine an alias */
rch->pcdata->alias_sub[pos] = str_dup(argument);
sprintf(buf,"%s is now realiased to '%s'.\n\r",arg,argument);
send_to_char(buf,ch);
return;
}
}
if (pos >= MAX_ALIAS) {
send_to_char("Sorry, you have reached the alias limit.\n\r",ch);
return;
}
/* make a new alias */
rch->pcdata->alias[pos] = str_dup(arg);
rch->pcdata->alias_sub[pos] = str_dup(argument);
sprintf(buf,"%s is now aliased to '%s'.\n\r",arg,argument);
send_to_char(buf,ch);
}
void do_alia(CHAR_DATA *ch, const char *argument)
{
send_to_char("I'm sorry, alias must be entered in full.\n\r",ch);
return;
}
/*
* Invia i messaggi delle mosse ai giocatori e a quelli della stanza
*/
void board_move_messages( CHAR_DATA *ch, int ret, char *extra )
{
CHESSBOARD_DATA *board;
CHAR_DATA *opp;
if ( !ch )
{
send_log( NULL, LOG_BUG, "board_move_messages: ch passato è NULL" );
return;
}
if ( ret < 0 || ret >= MAX_MOVE )
{
send_log( NULL, LOG_BUG, "board_move_messages: ret passato errato: %d", ret );
return;
}
if ( IS_MOB(ch) )
{
send_to_char( ch, "I mob non possono giocare a scacchi.\r\n" );
return;
}
board = get_chessboard( ch );
if ( !board )
{
send_to_char( ch, "Non sto giocando a nessuna partita di scacchi.\r\n" );
return;
}
if ( ch == board->player1 )
opp = board->player2;
else
opp = board->player1;
if ( !opp )
{
send_log( NULL, LOG_BUG, "board_move_messages: %s non ha nessun avversario", ch->name );
return;
}
show_board( ch, board );
show_board( opp, board );
switch ( ret )
{
case MOVE_OK:
ch_printf( ch, "Muovo, %s.\r\n", extra );
act( AT_ACTION, "$n muove, $t.\r\n", ch, extra, NULL, TO_ROOM );
break;
case MOVE_CASTLE:
ch_printf( ch, "Arrocco, %s.\r\n", extra );
act( AT_ACTION, "$n arrocca, $t.", ch, extra, NULL, TO_ROOM );
break;
case MOVE_PROMOTE:
ch_printf( ch, "Promuovo un pedone a %s.\r\n", extra );
act( AT_ACTION, "$n promuove un pedone a $t.", ch, extra, NULL, TO_ROOM );
break;
case MOVE_INVALID:
send_to_char( ch, "Non posso effettuare questa mossa.\r\n" );
break;
case MOVE_BLOCKED:
send_to_char( ch, "Sono bloccato in quella direzione.\r\n" );
break;
case MOVE_TAKEN:
send_to_char( ch, "Hai catturato un pezzo nemico!\r\n" );
act( AT_ACTION, "$n muove, $t, e cattura uno dei tuoi pezzi!", ch, extra, NULL, TO_ROOM );
break;
case MOVE_OFFBOARD:
send_to_char( ch, "Questa mossa mi porterebbe fuori la scacchiera.\r\n" );
break;
case MOVE_SAMECOLOR:
send_to_char( ch, "Uno dei miei stessi pezzi mi blocca la via.\r\n" );
break;
case MOVE_CHECK:
act( AT_ACTION, "Con questa mossa metto sotto scacco il re di $N.\r\n", ch, NULL, opp, TO_CHAR );
act( AT_ACTION, "$n prova una mossa e il re di $N è sotto scacco.", ch, NULL, opp, TO_NOVICT );
act( AT_ACTION, "$n prova una mossa e il tuo re è sotto scacco.", ch, NULL, opp, TO_VICT );
break;
case MOVE_WRONGCOLOR:
send_to_char( ch, "Questo non è uno dei miei pezzi.\r\n" );
break;
case MOVE_INCHECK:
send_to_char( ch, "Con questa mossa il mio re sarebbe sotto scacco, non posso eseguirla.\r\n" );
break;
}
}
void do_look(struct char_data *ch, char *argument, int cmd)
{
char buffer[MAX_STRING_LENGTH];
char arg1[MAX_STRING_LENGTH];
char arg2[MAX_STRING_LENGTH];
int keyword_no;
int j, bits, temp;
bool found;
struct obj_data *tmp_object, *found_object;
struct char_data *tmp_char;
char *tmp_desc;
static char *keywords[]= {
"north",
"east",
"south",
"west",
"up",
"down",
"in",
"at",
"", /* Look at '' case */
"\n"
};
if (!ch->desc)
return;
if (GET_POS(ch) < POSITION_SLEEPING)
send_to_char("You can't see anything but stars!\n\r", ch);
else if (GET_POS(ch) == POSITION_SLEEPING)
send_to_char("You can't see anything, you're sleeping!\n\r", ch);
else if ( IS_AFFECTED(ch, AFF_BLIND) )
send_to_char("You can't see a damn thing, you're blinded!\n\r", ch);
else if ( IS_DARK(ch->in_room) )
send_to_char("It is pitch black...\n\r", ch);
else {
argument_split_2(argument,arg1,arg2);
keyword_no = search_block(arg1, keywords, FALSE); /* Partiel Match */
if ((keyword_no == -1) && *arg1) {
keyword_no = 7;
strcpy(arg2, arg1); /* Let arg2 become the target object (arg1) */
}
found = FALSE;
tmp_object = 0;
tmp_char = 0;
tmp_desc = 0;
switch(keyword_no) {
/* look <dir> */
case 0 :
case 1 :
case 2 :
case 3 :
case 4 :
case 5 : {
if (EXIT(ch, keyword_no)) {
if (EXIT(ch, keyword_no)->general_description) {
send_to_char(EXIT(ch, keyword_no)->
general_description, ch);
} else {
send_to_char("You see nothing special.\n\r", ch);
}
if (IS_SET(EXIT(ch, keyword_no)->exit_info, EX_CLOSED) &&
(EXIT(ch, keyword_no)->keyword)) {
sprintf(buffer, "The %s is closed.\n\r",
fname(EXIT(ch, keyword_no)->keyword));
send_to_char(buffer, ch);
} else {
if (IS_SET(EXIT(ch, keyword_no)->exit_info, EX_ISDOOR) &&
EXIT(ch, keyword_no)->keyword) {
sprintf(buffer, "The %s is open.\n\r",
fname(EXIT(ch, keyword_no)->keyword));
send_to_char(buffer, ch);
}
}
} else {
send_to_char("Nothing special there...\n\r", ch);
}
}
break;
/* look 'in' */
case 6: {
if (*arg2) {
/* Item carried */
bits = generic_find(arg2, FIND_OBJ_INV | FIND_OBJ_ROOM |
FIND_OBJ_EQUIP, ch, &tmp_char, &tmp_object);
if (bits) { /* Found something */
if (GET_ITEM_TYPE(tmp_object)== ITEM_DRINKCON)
{
if (tmp_object->obj_flags.value[1] <= 0) {
act("It is empty.", FALSE, ch, 0, 0, TO_CHAR);
} else {
temp=((tmp_object->obj_flags.value[1]*3)/tmp_object->obj_flags.value[0]);
sprintf(buffer,"It's %sfull of a %s liquid.\n\r",
fullness[temp],color_liquid[tmp_object->obj_flags.value[2]]);
send_to_char(buffer, ch);
}
} else if (GET_ITEM_TYPE(tmp_object) == ITEM_CONTAINER) {
if (!IS_SET(tmp_object->obj_flags.value[1],CONT_CLOSED)) {
send_to_char(fname(tmp_object->name), ch);
switch (bits) {
case FIND_OBJ_INV :
send_to_char(" (carried) : \n\r", ch);
break;
case FIND_OBJ_ROOM :
send_to_char(" (here) : \n\r", ch);
break;
case FIND_OBJ_EQUIP :
send_to_char(" (used) : \n\r", ch);
break;
}
list_obj_to_char(tmp_object->contains, ch, 2, TRUE);
}
else
send_to_char("It is closed.\n\r", ch);
} else {
send_to_char("That is not a container.\n\r", ch);
}
} else { /* wrong argument */
send_to_char("You do not see that item here.\n\r", ch);
}
} else { /* no argument */
send_to_char("Look in what?!\n\r", ch);
}
}
break;
/* look 'at' */
case 7 : {
if (*arg2) {
bits = generic_find(arg2, FIND_OBJ_INV | FIND_OBJ_ROOM |
FIND_OBJ_EQUIP | FIND_CHAR_ROOM, ch, &tmp_char, &found_object);
if (tmp_char) {
show_char_to_char(tmp_char, ch, 1);
if (ch != tmp_char) {
act("$n looks at you.", TRUE, ch, 0, tmp_char, TO_VICT);
act("$n looks at $N.", TRUE, ch, 0, tmp_char, TO_NOTVICT);
}
return;
}
/* Search for Extra Descriptions in room and items */
/* Extra description in room?? */
if (!found) {
tmp_desc = find_ex_description(arg2,
world[ch->in_room].ex_description);
if (tmp_desc) {
page_string(ch->desc, tmp_desc, 0);
return; /* RETURN SINCE IT WAS A ROOM DESCRIPTION */
/* Old system was: found = TRUE; */
}
}
/* Search for extra descriptions in items */
/* Equipment Used */
if (!found) {
for (j = 0; j< MAX_WEAR && !found; j++) {
if (ch->equipment[j]) {
if (CAN_SEE_OBJ(ch,ch->equipment[j])) {
tmp_desc = find_ex_description(arg2,
ch->equipment[j]->ex_description);
if (tmp_desc) {
page_string(ch->desc, tmp_desc, 1);
found = TRUE;
}
}
}
}
}
/* In inventory */
if (!found) {
for(tmp_object = ch->carrying;
tmp_object && !found;
tmp_object = tmp_object->next_content) {
if CAN_SEE_OBJ(ch, tmp_object) {
tmp_desc = find_ex_description(arg2,
tmp_object->ex_description);
if (tmp_desc) {
page_string(ch->desc, tmp_desc, 1);
found = TRUE;
}
}
}
}
/* Object In room */
if (!found) {
for(tmp_object = world[ch->in_room].contents;
tmp_object && !found;
tmp_object = tmp_object->next_content) {
if CAN_SEE_OBJ(ch, tmp_object) {
tmp_desc = find_ex_description(arg2,
tmp_object->ex_description);
if (tmp_desc) {
page_string(ch->desc, tmp_desc, 1);
found = TRUE;
}
}
}
}
/* wrong argument */
if (bits) { /* If an object was found */
if (!found)
show_obj_to_char(found_object, ch, 5); /* Show no-description */
else
show_obj_to_char(found_object, ch, 6); /* Find hum, glow etc */
} else if (!found) {
send_to_char("You do not see that here.\n\r", ch);
}
} else {
/* no argument */
send_to_char("Look at what?\n\r", ch);
}
}
/*
* Comando per gestire il gioco degli scacchi
*/
void do_chess( CHAR_DATA *ch, char *argument )
{
CHESSBOARD_DATA *board;
char arg[MIL];
if ( !ch )
{
send_log( NULL, LOG_BUG, "do_chess: ch è NULL" );
return;
}
if ( IS_MOB(ch) )
{
send_to_char( ch, "I mob non possono giocare a scacchi.\r\n" );
return;
}
board = get_chessboard( ch );
if ( !VALID_STR(argument) || is_name(argument, "sintassi aiuto syntax help ?") )
{
char *cmd;
cmd = translate_command( ch, "chess" );
ch_printf( ch, "&YSintassi gioco&w: %s inizio|smetto|partecipo|forfeit\r\n", cmd );
ch_printf( ch, "&YSintassi info&w: %s pezzi\r\n", cmd );
ch_printf( ch, "&YSintassi mosse&w: %s muovo <sorgente> <destinazione> [comandi opzionali]\r\n", cmd );
ch_printf( ch, "&YSintassi extra&w: %s arrocco|promuovo\r\n", cmd );
if ( !VALID_STR(argument) && board )
{
send_to_char( ch, "\r\n" );
show_status( ch, board );
send_to_char( ch, "\r\n" );
show_board( ch, board );
}
return;
}
argument = one_argument( argument, arg );
if ( is_name_prefix(arg, "inizio inizia comincio comincia cominciare start") )
{
CHESSBOARD_DATA *newboard;
if ( board )
{
send_to_char( ch, "Sto già partecipando ad una partita di scacchi.\r\n" );
return;
}
CREATE( newboard, CHESSBOARD_DATA, 1 );
init_board( newboard );
newboard->player1 = ch;
newboard->turn = ch;
LINK( newboard, first_chessboard, last_chessboard, next, prev );
top_chessboard++;
send_to_char( ch, "Inizio una nuova partita di scacchi.\r\n" );
return;
}
if ( is_name_prefix(arg, "partecipa partecipo join") )
{
CHESSBOARD_DATA *vboard = NULL;
CHAR_DATA *vch;
char arg2[MIL];
if ( board )
{
send_to_char( ch, "Sto già partecipando ad una partita di scacchi.\r\n" );
return;
}
argument = one_argument( argument, arg2 );
if ( !VALID_STR(arg2) )
{
send_to_char( ch, "Con chi devo partecipare ad una partita di scacchi?\r\n" );
return;
}
vch = get_player_room( ch, arg2, TRUE );
if ( !vch )
{
ch_printf( ch, "Non vedo nessun %s nella stanza.\r\n", arg2 );
return;
}
vboard = get_chessboard( vch );
if ( !vboard )
{
send_to_char( ch, "Non sta giocando a scacchi.\r\n" );
return;
}
if ( vboard->player2 )
{
send_to_char( ch, "Questa scacchiera ha già due giocatori.\r\n" );
return;
}
vboard->player2 = ch;
vboard->turn = vboard->player2;
send_to_char( ch, "Mi unisco alla partita, è il mio turno.\r\n" );
ch_printf( vboard->player1, "%s si unisce alla tua partita.\r\n", ch->name );
return;
}
if ( is_name_prefix(arg, "pezzi pieces") )
{
int x; /* contatore dei colori */
int y; /* contatore dei pezzi */
for ( x = 0; x < COLOR_NONE; x++ )
{
if ( x == COLOR_BLACK )
send_to_char( ch, "\r\n\r\nPezzi neri:\r\n" );
else
send_to_char( ch, "Pezzi bianchi:\r\n" );
for ( y = PIECE_PAWN; y < PIECE_NONE; y++ )
ch_printf( ch, "%-7s", table_pieces[y].name );
send_to_char( ch, "\r\n" );
for ( y = PIECE_PAWN; y < PIECE_NONE; y++ )
send_to_char( ch, (x == COLOR_WHITE) ? table_pieces[y].wgraph1 : table_pieces[y].bgraph1 );
send_to_char( ch, "\r\n" );
for ( y = PIECE_PAWN; y < PIECE_NONE; y++ )
send_to_char( ch, (x == COLOR_WHITE) ? table_pieces[y].wgraph2 : table_pieces[y].bgraph2 );
}
send_to_char( ch, "\r\n" );
return;
}
if ( !board )
{
send_to_char( ch, "Non ho iniziato o non sto partecipando a nessuna partita di scacchi.\r\n" );
return;
}
if ( is_name_prefix(arg, "smetto fermo stop") )
{
free_chessboard( board );
return;
}
if ( is_name_prefix(arg, "forfeit") )
{
send_to_char( ch, "Dò forfeit così perdendo.\r\n" );
free_chessboard( board );
return;
}
if ( !board->player1 || !board->player2 )
{
send_to_char( ch, "C'è solo un giocatore.\r\n" );
return;
}
if ( board->moves < 0 )
{
send_to_char( ch, "Il gioco non è ancora iniziato.\r\n" );
return;
}
if ( is_name_prefix(arg, "promuovo promuovi promote") )
{
int piece = board->piece[board->lastx][board->lasty];
char extra[MIL];
if ( !((piece == PIECE_PAWN && board->player1 == ch)
|| (piece == PIECE_PAWN && board->player2 == ch)) )
{
send_to_char( ch, "Non posso promuovere questo pezzo.\r\n" );
return;
}
if ( (piece == PIECE_PAWN && board->lastx != 0)
|| (piece == PIECE_PAWN && board->lastx != 7) )
{
send_to_char( ch, "Puoi promuovere solamente i pedoni che hanno raggiunto l'altro lato della scacchiera.\r\n" );
return;
}
if ( !VALID_STR(argument) )
{
send_to_char( ch, "Vorrei promuovere il pedone in che cosa?\r\n" );
return;
}
if ( is_name_prefix(argument, "regina queen" ) ) piece = PIECE_QUEEN;
else if ( is_name_prefix(argument, "alfiere bishop") ) piece = PIECE_BISHOP;
else if ( is_name_prefix(argument, "cavallo knight") ) piece = PIECE_KNIGHT;
else if ( is_name_prefix(argument, "torre rook" ) ) piece = PIECE_ROOK;
else
{
ch_printf( ch, "Non posso promuoverlo a %s.\r\n", argument );
return;
}
board->piece[board->lastx][board->lasty] = piece;
sprintf( extra, "%s (%c%d)", table_pieces[piece].name, board->lastx+'a', board->lasty+1 );
board_move_messages( ch, MOVE_PROMOTE, extra );
return;
}
if ( board->turn != ch )
{
send_to_char( ch, "Non è il mio turno.\r\n" );
return;
}
if ( is_name_prefix(arg, "arrocco") )
{
int myx;
int rooky;
int kdy;
int rdy;
bool fRookShort;
if ( king_in_check(board, PIECE_KING, (board->player1 == ch) ? COLOR_BLACK : COLOR_WHITE) > 0 )
{
send_to_char( ch, "Non posso eseguire un arrocco mentre sono sotto scacco.\r\n" );
return;
}
if ( (board->player1 == ch && HAS_BIT(board->flags1, CHESSFLAG_MOVEDKING))
|| (board->player2 == ch && HAS_BIT(board->flags2, CHESSFLAG_MOVEDKING)) )
{
send_to_char( ch, "Non posso effettuare un arrocco quando ho già mosso il mio re.\r\n" );
return;
}
myx = (board->player1 == ch) ? 7 : 0;
if ( !VALID_STR(argument) )
{
ch_printf( ch, "Utilizzo: %s arrocco corto|lungo\r\n", translate_command(ch, "chess") );
return;
}
if ( is_name_prefix(argument, "corto short") )
fRookShort = TRUE;
else if ( is_name_prefix(argument, "lungo long") )
fRookShort = FALSE;
else
{
send_command( ch, "chess arrocco", CO );
return;
}
if ( (board->player1 == ch && HAS_BIT(board->flags1, fRookShort ? CHESSFLAG_MOVEDKROOK : CHESSFLAG_MOVEDQROOK))
|| (board->player2 == ch && HAS_BIT(board->flags2, fRookShort ? CHESSFLAG_MOVEDKROOK : CHESSFLAG_MOVEDQROOK)) )
{
ch_printf( ch, "Non posso effettuare l'arrocco %s perchè ho già mosso la torre prima.\r\n",
fRookShort ? "corto" : "lungo" );
return;
}
rooky = fRookShort ? 7 : 0;
if ( ( fRookShort && (board->piece[myx][6] != PIECE_NONE || board->piece[myx][5] != PIECE_NONE))
|| (!fRookShort && (board->piece[myx][1] != PIECE_NONE || board->piece[myx][2] != PIECE_NONE || board->piece[myx][3] != PIECE_NONE)) )
{
send_to_char( ch, "L'arrocco è bloccato dalla presenza di pezzi tra il re e la torre.\r\n" );
return;
}
/* castling succeeded */
if ( fRookShort )
{
kdy = 6;
rdy = 5;
}
else
{
kdy = 2;
rdy = 3;
}
/* (FF) (TT) (RR) (bb) ricordo che una qualsiasi delle caselle, in cui avveniva l'arrocco
* non dovevano essere sotto scacco, mi sa che qui non è così, o forse ricordo sbagliato */
/* check for 'move across check' rule */
board->piece[myx][rdy] = board->piece[myx][4];
board->piece[myx][4] = PIECE_NONE;
if ( king_in_check(board, board->piece[myx][rdy], board->color[myx][rdy]) > 0 )
{
send_to_char( ch, "Il mio re si troverebbe sotto scacco dopo l'arrocco.\r\n" );
board->piece[myx][4] = board->piece[myx][rdy];
board->piece[myx][rdy] = PIECE_NONE;
return;
}
board->piece[myx][kdy] = board->piece[myx][rdy];
board->piece[myx][rdy] = board->piece[myx][rooky];
board->piece[myx][rooky] = PIECE_NONE;
/* check for 'check' after castled */
if ( king_in_check(board, board->piece[myx][kdy], board->color[myx][kdy]) > 0 )
{
send_to_char( ch, "Il mio re si troverebbe sotto scacco dopo l'arrocco.\r\n" );
board->piece[myx][4] = board->piece[myx][kdy];
board->piece[myx][kdy] = PIECE_NONE;
board->piece[myx][rooky] = board->piece[myx][rdy];
board->piece[myx][rdy] = PIECE_NONE;
return;
}
/* Basta indicare che è stato mosso il re per evitare un altro arrocco */
if ( board->player1 == ch )
SET_BIT( board->flags1, CHESSFLAG_MOVEDKING );
else
SET_BIT( board->flags2, CHESSFLAG_MOVEDKING );
board_move_stuff( board );
board_move_messages( ch, MOVE_CASTLE, rooky == 7 ? "corto" : "lungo" );
}
if ( is_name_prefix(arg, "muovo move") )
{
char coord1[MIL];
char coord2[MIL];
char extra[MIL];
int x, y, dx, dy;
int ret;
if ( !VALID_STR(argument) )
{
ch_printf( ch, "Utilizzo: %s muovo <sorgente> <destinazione>\r\n", translate_command(ch, "chess") );
return;
}
argument = one_argument( argument, coord1 );
argument = one_argument( argument, coord2 );
if ( !VALID_STR(coord1) || !VALID_STR(coord2) )
{
ch_printf( ch, "Utilizzo: %s muovo <sorgente> <destinazione>\r\n", translate_command(ch, "chess") );
return;
}
get_coord( coord1, &x, &y );
get_coord( coord2, &dx, &dy );
if ( x < 0 || x >= 8 || dx < 0 || dx >= 8
|| y < 0 || y >= 8 || dy < 0 || dy >= 8 )
{
send_to_char( ch, "Mossa non valida, utilizza a-h e 1-8 (esempio: a4 b4).\r\n" );
return;
}
extra[0] = '\0';
ret = is_valid_move( ch, board, x, y, dx, dy );
if ( ret == MOVE_OK || ret == MOVE_TAKEN )
{
int piece;
int color;
int destpiece;
int destcolor;
piece = board->piece[x][y];
color = board->color[x][y];
destpiece = board->piece[dx][dy];
destcolor = board->color[dx][dy];
board->piece[dx][dy] = piece;
board->color[dx][dy] = color;
board->piece[x][y] = PIECE_NONE;
board->color[x][y] = COLOR_NONE;
if ( king_in_check(board, PIECE_KING, board->color[dx][dy]) > 0 )
{
board->piece[dx][dy] = destpiece;
board->color[dx][dy] = destcolor;
board->piece[x][y] = piece;
board->color[x][y] = color;
ret = MOVE_INCHECK;
}
else
{
if ( destpiece == PIECE_NONE )
sprintf( extra, "%c%d (%s) alle coordinate %c%d", x+'a', y+1, table_pieces[piece].name, y+'a', dy+1 );
else
sprintf( extra, "%c%d (%s) alle coordinate %c%d (%s)", x+'a', y+1, table_pieces[piece].name, y+'a', dy+1, table_pieces[destpiece].name );
board_move_stuff( board );
board->lastx = dx;
board->lasty = dy;
/* Imposta le flag per evitare gli arrocchi */
if ( piece == PIECE_ROOK )
{
if ( color == COLOR_WHITE )
{
if ( y == 0 && x == 0 )
SET_BIT( board->flags1, CHESSFLAG_MOVEDKROOK );
else if ( y == 0 && x == 7 )
SET_BIT( board->flags1, CHESSFLAG_MOVEDQROOK );
}
else
{
if ( y == 7 && x == 0 )
SET_BIT( board->flags2, CHESSFLAG_MOVEDKROOK );
else if ( y == 7 && x == 7 )
SET_BIT( board->flags2, CHESSFLAG_MOVEDQROOK );
}
}
else if ( piece == PIECE_KING )
{
if ( color == COLOR_WHITE )
SET_BIT( board->flags1, CHESSFLAG_MOVEDKING );
else
SET_BIT( board->flags2, CHESSFLAG_MOVEDKING );
}
}
board_move_messages( ch, ret, extra );
}
/* Così qui gestisce i comandi opzionali, come il promote */
if ( VALID_STR(argument) )
{
do_chess( ch, argument );
return;
}
return;
}
send_command( ch, "chess aiuto", CO );
}
void Crash_listrent(struct char_data * ch, char *name)
{
FILE *fl;
char fname[MAX_INPUT_LENGTH];
char buf[MAX_STRING_LENGTH];
char input[MAX_INPUT_LENGTH + 1];
char tag[MAX_INPUT_LENGTH + 1];
char tag_arguments[MAX_INPUT_LENGTH + 1];
char *p;
struct obj_data *obj;
int val = 0;
time_t rent_time;
int d;
int h;
int m;
if (!get_filename(name, fname, CRASH_FILE)) {
return;
}
if (!(fl = fopen(fname, "r"))) {
sprintf(buf, "%s has no rent file.\r\n", name);
send_to_char(buf, ch);
return;
}
sprintf(buf, "%s\r\n", fname);
while (get_line(fl, input)) {
parse_pline(input, tag, tag_arguments);
while ((p = strrchr(tag_arguments, '\n')) != NULL) {
*p = '\0';
}
val = atoi(tag_arguments);
switch (tag[0]) {
case 'o':
case 'O':
if (strcasecmp(tag, "obj_number") == 0) {
if (real_object(val) > -1) {
obj = read_object_q(val, VIRTUAL);
sprintf(buf, "%s [%5d] %-20s\r\n", buf, val, obj->short_description);
extract_obj_q(obj);
}
}
break;
case 'r':
case 'R':
if (strcasecmp(tag, "rent_version") == 0) {
sprintf(buf, "%sVersion: %d\r\n", buf, val);
} else if (strcasecmp(tag, "rent_time") == 0) {
rent_time = time(0) - val;
d = rent_time / 86400;
h = (rent_time / 3600) % 24;
m = (rent_time / 60) % 60;
sprintf(buf, "%sRented %d day%s, %d hour%s, %d minute%s ago.\r\n", buf, d, ((d == 1) ? "" : "s"), h, ((h == 1) ? "" : "s"), m, ((m == 1) ? "" : "s"));
} else if (strcasecmp(tag, "rent_type") == 0)
switch (val) {
case RENT_RENTED:
sprintf(buf, "%sType: Rent\r\n", buf);
break;
case RENT_CRASH:
sprintf(buf, "%sType: Crash\r\n", buf);
break;
case RENT_CRYO:
sprintf(buf, "%sType: Cryo\r\n", buf);
break;
case RENT_TIMEDOUT:
case RENT_FORCED:
sprintf(buf, "%sType: TimedOut\r\n", buf);
break;
case RENT_CAMPED:
sprintf(buf, "%sType: Camped\r\n", buf);
break;
default:
sprintf(buf, "%sType: Undef\r\n", buf);
break;
}
break;
}
}
page_string(ch->desc, buf, 1);
fclose(fl);
}
/*
* stampa al pg il suo stato attuale di gioco
*/
void show_status( CHAR_DATA *ch, CHESSBOARD_DATA *board )
{
if ( !ch )
{
send_log( NULL, LOG_BUG, "print_status: ch passato è NULL" );
return;
}
if ( !board )
{
send_to_char( ch, "Non sto giocando a nessuna partita di scacchi.\r\n" );
return;
}
if ( !board->player1 )
send_to_char( ch, "Non ho nessun giocatore per i pezzi neri con cui gareggiare.\r\n" );
else if ( board->player1 == ch )
send_to_char( ch, "Sono io il giocatore dei pezzi neri.\r\n" );
else
ch_printf( ch, "%s è il giocatore che tiene i pezzi neri.\r\n", board->player1->name );
if ( king_in_possible_checkmate(board, PIECE_KING, COLOR_BLACK) )
send_to_char( ch, "Il re nero potrebbe essere sotto scacco matto.\r\n" );
else if ( king_in_check(board, PIECE_KING, COLOR_BLACK) > 0 )
send_to_char( ch, "Il re nero è sotto scacco.\r\n" );
if ( !board->player2 )
send_to_char( ch, "Non ho nessun giocatore per i pezzi bianchi con cui gareggiare.\r\n" );
else if ( board->player2 == ch )
send_to_char( ch, "Sono io il giocatore dei pezzi bianchi.\r\n" );
else
ch_printf( ch, "%s è il giocatore che tiene i pezzi bianchi.\r\n", board->player2->name );
if ( king_in_possible_checkmate(board, PIECE_KING, COLOR_WHITE) )
send_to_char( ch, "Il re bianco potrebbe essere sotto scacco matto.\r\n" );
else if ( king_in_check(board, PIECE_KING, COLOR_WHITE) > 0 )
send_to_char( ch, "Il re bianco è sotto scacco.\r\n" );
if ( !board->player2 || !board->player1 )
return;
if ( board->moves < 0 )
send_to_char( ch, "Il gioco non è ancora iniziato.\r\n" );
else
ch_printf( ch, "%d turni.\r\n", board->moves );
if ( board->turn == ch )
send_to_char( ch, "E' il mio turno.\r\n" );
else
ch_printf( ch, "E' il turno di %s.\r\n", board->turn->name );
}
void load_text(struct char_data * ch)
{
FILE *fil = NULL;
char fname[MAX_INPUT_LENGTH];
struct alias *al;
int i, cnt;
void free_alias(struct alias * a);
if (IS_NPC(ch))
return;
if (!get_filename(GET_NAME(ch), fname, ETEXT_FILE))
return;
if (!(fil = fopen(fname, "r"))) {
if (errno != ENOENT) { /* if it fails, NOT because of no file */
sprintf(buf1, "SYSERR: READING TEXT FILE %s (5)", fname);
perror(buf1);
send_to_char("\r\n***** NOTICE - THERE WAS A PROBLEM READING YOUR ALIAS FILE *****\r\n", ch);
return;
}
return;
}
while ((al = GET_ALIASES(ch)) != NULL) { /* get rid of alias multiplying problem */
GET_ALIASES(ch) = (GET_ALIASES(ch))->next;
free_alias(al);
}
cnt = 200; /* security counter to make memory alloc bombing impossible :) */
fscanf(fil, "%d\n", &i); /* get first type */
while (i != -1 && cnt != 0) {
CREATE(al, struct alias, 1);
al->type = i;
fgets(buf, MAX_INPUT_LENGTH, fil);
buf[strlen(buf) - 1] = '\0';
al->alias = strdup(buf);
fgets(buf, MAX_INPUT_LENGTH, fil);
buf[strlen(buf) - 1] = '\0';
al->replacement = strdup(buf);
al->next = ch->player_specials->aliases;
ch->player_specials->aliases = al;
fscanf(fil, "%d\n", &i);
cnt--;
}
/* aliases has been loaded */
if (WHOSPEC(ch)) {
FREE(WHOSPEC(ch));
}
if (POOFIN(ch)) {
FREE(POOFIN(ch));
}
if (POOFOUT(ch)) {
FREE(POOFOUT(ch));
}
if (WHOSTR(ch)) {
FREE(WHOSTR(ch));
}
if (NAMECOLOR(ch)) {
FREE(NAMECOLOR(ch));
}
fgets(buf, MAX_INPUT_LENGTH, fil);
buf[strlen(buf) - 1] = '\0';
if (str_cmp("!UNUSED!", buf)) {
WHOSPEC(ch) = strdup(buf);
}
fgets(buf, SMALL_BUFSIZE, fil);
buf[strlen(buf) - 1] = '\0';
if (str_cmp("!UNUSED!", buf)) {
POOFIN(ch) = strdup(buf);
}
fgets(buf, SMALL_BUFSIZE, fil);
buf[strlen(buf) - 1] = '\0';
if (str_cmp("!UNUSED!", buf)) {
POOFOUT(ch) = strdup(buf);
}
fgets(buf, MAX_INPUT_LENGTH, fil);
buf[strlen(buf) - 1] = '\0';
if (str_cmp("!UNUSED!", buf)) {
WHOSTR(ch) = strdup(buf);
}
if (fgets(buf, SMALL_BUFSIZE, fil) > (char*) NULL) {
buf[strlen(buf) - 1] = '\0';
if (str_cmp("!UNUSED!", buf)) {
NAMECOLOR(ch) = strdup(buf);
}
}
if (cnt == 0) {
send_to_char("Undetermined error when reading your alias file ...\r\n", ch);
sprintf(buf, "ERROR when reading %s's alias file.", GET_NAME(ch));
mudlog(buf, 'W', COM_IMMORT, TRUE);
plog(buf, ch, 0);
}
fclose(fil);
return;
}
/* Display a nicely formatted map with a legend */
static void perform_map( struct char_data *ch, char *argument, bool worldmap )
{
int size = DEFAULT_MAP_SIZE;
int centre, x, y, min, max;
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH], buf[MAX_STRING_LENGTH], buf1[MAX_STRING_LENGTH], buf2[MAX_STRING_LENGTH];
int count = 0;
int ew_size=0, ns_size=0;
int mapshape = MAP_CIRCLE;
two_arguments( argument, arg1 , arg2 );
if(*arg1)
{
size = atoi(arg1);
}
if (*arg2)
{
if (is_abbrev(arg2, "normal")) worldmap=FALSE;
else if (is_abbrev(arg2, "world")) worldmap=TRUE;
else {
send_to_char(ch, "Usage: \tymap <distance> [ normal | world ]\tn");
return;
}
}
if(size<0) {
size = -size;
mapshape = MAP_RECTANGLE;
}
size = URANGE(1,size,MAX_MAP_SIZE);
centre = MAX_MAP/2;
if(worldmap) {
min = centre - 2*size;
max = centre + 2*size;
} else {
min = centre - size;
max = centre + size;
}
/* Blank the map */
for (x = 0; x < MAX_MAP; ++x)
for (y = 0; y < MAX_MAP; ++y)
map[x][y]= (!(y%2) && !worldmap) ? DOOR_NONE : SECT_EMPTY;
/* starts the mapping with the centre room */
MapArea(IN_ROOM(ch), ch, centre, centre, min, max, ns_size/2, ew_size/2, worldmap);
/* marks the center, where ch is */
map[centre][centre] = SECT_HERE;
/* Feel free to put your own MUD name or header in here */
send_to_char(ch, " \tY-\tytbaMUD Map System\tY-\tn\r\n"
"\tD .-.__--.,--.__.-.\tn\r\n" );
count += sprintf(buf + count, "\tn\tn\tn%s Up\\\\", door_info[NUM_DOOR_TYPES + DOOR_UP].disp);
count += sprintf(buf + count, "\tn\tn\tn%s Down\\\\", door_info[NUM_DOOR_TYPES + DOOR_DOWN].disp);
count += sprintf(buf + count, "\tn%s You\\\\", map_info[SECT_HERE].disp);
count += sprintf(buf + count, "\tn%s Inside\\\\", map_info[SECT_INSIDE].disp);
count += sprintf(buf + count, "\tn%s City\\\\", map_info[SECT_CITY].disp);
count += sprintf(buf + count, "\tn%s Field\\\\", map_info[SECT_FIELD].disp);
count += sprintf(buf + count, "\tn%s Forest\\\\", map_info[SECT_FOREST].disp);
count += sprintf(buf + count, "\tn%s Hills\\\\", map_info[SECT_HILLS].disp);
count += sprintf(buf + count, "\tn%s Mountain\\\\", map_info[SECT_MOUNTAIN].disp);
count += sprintf(buf + count, "\tn%s Swim\\\\", map_info[SECT_WATER_SWIM].disp);
count += sprintf(buf + count, "\tn%s Boat\\\\", map_info[SECT_WATER_NOSWIM].disp);
count += sprintf(buf + count, "\tn%s Flying\\\\", map_info[SECT_FLYING].disp);
count += sprintf(buf + count, "\tn%s Underwater\\\\", map_info[SECT_UNDERWATER].disp);
strcpy(buf, strfrmt(buf, LEGEND_WIDTH, CANVAS_HEIGHT + 2, FALSE, TRUE, TRUE));
/* Start with an empty column */
strcpy(buf1, strfrmt("",0, CANVAS_HEIGHT + 2, FALSE, FALSE, TRUE));
/* Paste the legend */
strcpy(buf2, strpaste(buf1, buf, "\tD | \tn"));
/* Set up the map */
memset(buf, ' ', CANVAS_WIDTH);
count = (CANVAS_WIDTH);
if(worldmap)
count += sprintf(buf + count , "\r\n%s", WorldMap(centre, size, mapshape, MAP_NORMAL));
else
count += sprintf(buf + count , "\r\n%s", StringMap(centre, size));
memset(buf + count, ' ', CANVAS_WIDTH);
strcpy(buf + count + CANVAS_WIDTH, "\r\n");
/* Paste it on */
strcpy(buf2, strpaste(buf2, buf, "\tD | \tn"));
/* Paste on the right border */
strcpy(buf2, strpaste(buf2, buf1, " "));
/* Print it all out */
send_to_char(ch, "%s", buf2);
send_to_char(ch, "\tD `.-.__--.,-.__.-.-'\tn\r\n");
return;
}
/* return values:
0 - successful load, keep char in rent room.
1 - load failure or load of crash items -- put char in temple.
2 - rented equipment lost (no $)
*/
int Crash_load(struct char_data * ch)
{
void Crash_save(struct char_data * ch, int type);
FILE *fl;
char fname[MAX_STRING_LENGTH];
char buf[MAX_STRING_LENGTH];
char input[MAX_INPUT_LENGTH + 1];
char tag[MAX_INPUT_LENGTH + 1];
char tag_arguments[MAX_INPUT_LENGTH + 1];
int val;
struct obj_data *tmpobj = NULL;
struct obj_data *tmpobj2;
struct obj_data *next_obj;
int found_begin = 0;
int affect_counter = 0;
int found;
char *p;
struct corpse_obj_save *crash_load_stack = NULL;
struct corpse_obj_save *temp_stack = NULL;
struct corpse_obj_save *temp_stack_next = NULL;
int chg;
int ovnum = 0;
int j;
if (!get_filename(GET_NAME(ch), fname, CRASH_FILE)) {
return 1;
}
if (!(fl = fopen(fname, "r"))) {
if (errno != ENOENT) { /* if it fails, NOT because of no file */
sprintf(buf1, "SYSERR: READING OBJECT FILE %s (5)", fname);
perror(buf1);
send_to_char("\r\n********************* NOTICE *********************\r\n"
"There was a problem loading your objects from disk.\r\n"
"Contact a God for assistance.\r\n", ch);
}
sprintf(buf, "%s entering game with no equipment.", GET_NAME(ch));
mudlog(buf, 'R', COM_IMMORT, TRUE);
plog(buf, ch, 0);
return 1;
}
while (get_line(fl, input)) {
parse_pline(input, tag, tag_arguments);
while ((p = strrchr(tag_arguments, '\n')) != NULL) {
*p = '\0';
}
val = atoi(tag_arguments);
switch (tag[4]) {
case 'a':
case 'A':
if (strcasecmp(tag, "obj_affect_loc") == 0 && affect_counter < MAX_OBJ_AFFECT) {
tmpobj->affected[affect_counter].location = val;
} else if (strcasecmp(tag, "obj_affect_mod") == 0 && affect_counter < MAX_OBJ_AFFECT) {
tmpobj->affected[affect_counter].modifier = val;
affect_counter++;
} else {
sprintf(buf, "Unknown Rent-File Tag: %s", tag);
stderr_log(buf);
}
break;
case 'b':
case 'B':
if (strcasecmp(tag, "obj_begin") == 0) {
if (found_begin) {
send_to_char("\r\n********************* NOTICE *********************\r\n"
"There was a problem loading your objects from disk.\r\n"
"Contact a God for assistance.\r\n", ch);
return 1;
}
found_begin = 1;
} else if (strcasecmp(tag, "obj_bitvector") == 0) {
GET_OBJ_BITV(tmpobj) = asciiflag_conv(tag_arguments);
} else if (strcasecmp(tag, "obj_bitvector2") == 0) {
GET_OBJ_BITV2(tmpobj) = asciiflag_conv(tag_arguments);
} else {
sprintf(buf, "Unknown Rent-File Tag: %s", tag);
stderr_log(buf);
}
break;
case 'e':
case 'E':
if (strcasecmp(tag, "obj_extra_flags") == 0) {
GET_OBJ_EXTRA(tmpobj) = asciiflag_conv(tag_arguments);
} else if (strcasecmp(tag, "obj_end") == 0) {
if (ovnum >= 0) {
if (!found_begin) {
send_to_char("\r\n********************* NOTICE *********************\r\n"
"There was a problem loading your objects from disk.\r\n"
"Contact a God for assistance.\r\n", ch);
return 1;
}
found_begin = 0;
affect_counter = 0;
CREATE(crash_load_stack, struct corpse_obj_save, 1);
crash_load_stack->level = 0;
crash_load_stack->prev = NULL;
for (tmpobj2 = ch->carrying, found = 0; tmpobj2 && !found; tmpobj2 = next_obj) {
next_obj = tmpobj2->next_content;
if (tmpobj2->objnum == tmpobj->inobj) {
obj_to_obj(tmpobj, tmpobj2);
found = 1;
}
if (tmpobj2->contains) {
crash_load_stack->next_obj = next_obj;
CREATE(temp_stack, struct corpse_obj_save, 1);
temp_stack->level = crash_load_stack->level + 1;
temp_stack->prev = crash_load_stack;
crash_load_stack = temp_stack;
next_obj = tmpobj2->contains;
if (tmpobj2 == next_obj) {
/* infinite loop */
next_obj = NULL;
continue;
}
} else if (next_obj == NULL && crash_load_stack->level > 0) {
temp_stack = crash_load_stack;
crash_load_stack = crash_load_stack->prev;
FREE(temp_stack);
next_obj = crash_load_stack->next_obj;
}
}
for (temp_stack = crash_load_stack; temp_stack; temp_stack = temp_stack_next) {
temp_stack_next = temp_stack->prev;
FREE(temp_stack);
}
if (!found) {
obj_to_char(tmpobj, ch);
}
} else {
extract_obj(tmpobj);
found_begin = 0;
affect_counter = 0;
ovnum = 0;
}
} else {
/**
* dzielenie siê pieniêdzmi
*/
void money_split( CHAR_DATA *ch, long int amount, int nomination, bool show_message, bool is_split_all, bool is_autosplit )
{
int multiplier = RATTING_NONE;
CHAR_DATA *gch;
long int members = 0, share, extra;
char buf[ MAX_INPUT_LENGTH ];
char buf_amount[ MAX_INPUT_LENGTH ];
switch ( nomination )
{
case NOMINATION_COPPER:
if ( ch->copper < amount )
{
if ( show_message || is_autosplit )
{
send_to_char( "Nie masz tylu miedzianych monet.\n\r", ch );
}
return;
}
break;
case NOMINATION_SILVER:
if ( ch->silver < amount )
{
if ( show_message || is_autosplit )
{
send_to_char( "Nie masz tylu srebrnych monet.\n\r", ch );
}
return;
}
break;
case NOMINATION_GOLD:
if ( ch->gold < amount )
{
if ( show_message || is_autosplit )
{
send_to_char( "Nie masz tylu zlotych monet.\n\r", ch );
}
return;
}
break;
case NOMINATION_MITHRIL:
if ( ch->mithril < amount )
{
if ( show_message || is_autosplit )
{
send_to_char( "Nie masz tylu mithrilowych monet.\n\r", ch );
}
return;
}
break;
}
for ( gch = ch->in_room->people; gch != NULL; gch = gch->next_in_room )
{
if ( can_see( ch, gch ) && is_same_group( gch, ch ) && !IS_AFFECTED( gch, AFF_CHARM ) )
{
members++;
}
}
if ( members < 2 )
{
if ( show_message && ! is_autosplit )
{
send_to_char( "Dzielisz siê piêniedzmi sam ze sob±.\n\r", ch );
}
return;
}
if ( amount < members )
{
if ( show_message && ! is_split_all && ! is_autosplit )
{
send_to_char( "Nawet siê nie trud¼ <&sk±pcu/sk±pa kobieto/sk±pirad³o>.\n\r", ch );
}
return;
}
share = amount;
share /= members;
if ( share < 1 )
{
share = 0;
}
extra = amount;
extra %= members;
if ( extra < 1 )
{
extra = 0;
}
if ( share < 1 )
{
if ( show_message && ! is_split_all && ! is_autosplit )
{
send_to_char( "Nawet siê nie trud¼ <&sk±pcu/sk±pa kobieto/sk±pirad³o>.\n\r", ch );
}
return;
}
append_file_format_daily
(
ch,
MONEY_LOG_FILE,
"-> S: before split /%d/%d/%d/%d/",
ch->copper,
ch->silver,
ch->gold,
ch->mithril
);
switch ( nomination )
{
case NOMINATION_COPPER:
ch->copper += share + extra - amount;
multiplier = RATTING_COPPER;
break;
case NOMINATION_SILVER:
ch->silver += share + extra - amount;
multiplier = RATTING_SILVER;
break;
case NOMINATION_GOLD:
ch->gold += share + extra - amount;
multiplier = RATTING_GOLD;
break;
case NOMINATION_MITHRIL:
ch->mithril += share + extra - amount;
multiplier = RATTING_MITHRIL;
break;
}
append_file_format_daily
(
ch,
MONEY_LOG_FILE,
"-> S: %ld %ld (%ld) - splitn±³ kasê w wysoko¶ci %s (%d/%d) nominal: %d /%d/%d/%d/%d/",
money_count_copper( ch ) + ( extra + share - amount ) * multiplier,
money_count_copper( ch ),
( share + extra - amount ) * multiplier,
money_string_simple( amount, nomination, FALSE ),
share,
extra,
nomination,
ch->copper,
ch->silver,
ch->gold,
ch->mithril
);
if ( show_message || is_autosplit )
{
sprintf ( buf_amount, "%s", money_string_simple ( amount, nomination, TRUE ) );
sprintf( buf, "Rozdzielasz %s. Dostajesz %s.\n\r", buf_amount, money_string_simple ( share + extra, nomination, TRUE ) );
send_to_char( buf, ch );
sprintf ( buf, "%s rozdziela %s. Dostajesz swoj± czê¶æ, %s.\n\r", ch->name, buf_amount, money_string_simple ( share, nomination, TRUE) );
}
for ( gch = ch->in_room->people; gch != NULL; gch = gch->next_in_room )
{
if ( gch != ch && can_see( ch, gch ) && is_same_group( gch, ch ) && !IS_AFFECTED( gch, AFF_CHARM ) )
{
if ( show_message || is_autosplit )
{
/* act( buf, ch, NULL, gch, TO_VICT );*/
send_to_char( buf, gch );
}
append_file_format_daily
(
gch,
MONEY_LOG_FILE,
"-> S: %ld %ld (%ld) - dosta³ kasê ze splita od %s",
money_count_copper( gch ) - share * multiplier,
money_count_copper( gch ),
share * multiplier,
ch->name
);
switch ( nomination )
{
case NOMINATION_COPPER:
gch->copper += share;
break;
case NOMINATION_SILVER:
gch->silver += share;
break;
case NOMINATION_GOLD:
gch->gold += share;
break;
case NOMINATION_MITHRIL:
gch->mithril += share;
break;
}
}
}
}
void oedit_parse(struct descriptor_data *d, char *arg)
{
int number, max_val, min_val;
char *oldtext = NULL;
struct board_info *tmp;
struct obj_data *obj;
obj_rnum robj;
switch (OLC_MODE(d)) {
case OEDIT_CONFIRM_SAVESTRING:
switch (*arg) {
case 'y':
case 'Y':
oedit_save_internally(d);
mudlog(CMP, MAX(LVL_BUILDER, GET_INVIS_LEV(d->character)), TRUE,
"OLC: %s edits obj %d", GET_NAME(d->character), OLC_NUM(d));
if (CONFIG_OLC_SAVE) {
oedit_save_to_disk(real_zone_by_thing(OLC_NUM(d)));
write_to_output(d, "Object saved to disk.\r\n");
} else
write_to_output(d, "Object saved to memory.\r\n");
if (GET_OBJ_TYPE(OLC_OBJ(d)) == ITEM_BOARD) {
if ((tmp=locate_board(GET_OBJ_VNUM(OLC_OBJ(d)))) != NULL) {
save_board(tmp);
} else {
tmp = create_new_board(GET_OBJ_VNUM(OLC_OBJ(d)));
BOARD_NEXT(tmp) = bboards;
bboards = tmp;
}
}
/* Fall through. */
case 'n':
case 'N':
cleanup_olc(d, CLEANUP_ALL);
return;
case 'a': /* abort quit */
case 'A':
oedit_disp_menu(d);
return;
default:
write_to_output(d, "Invalid choice!\r\n");
write_to_output(d, "Do you wish to save your changes? : \r\n");
return;
}
case OEDIT_MAIN_MENU:
/*
* Throw us out to whichever edit mode based on user input.
*/
switch (*arg) {
case 'q':
case 'Q':
if (STATE(d) != CON_IEDIT) {
if (OLC_VAL(d)) { /* Something has been modified. */
write_to_output(d, "Do you wish to save your changes? : ");
OLC_MODE(d) = OEDIT_CONFIRM_SAVESTRING;
} else
cleanup_olc(d, CLEANUP_ALL);
} else {
send_to_char(d->character, "\r\nCommitting iedit changes.\r\n");
obj = OLC_IOBJ(d);
*obj = *(OLC_OBJ(d));
GET_ID(obj) = max_obj_id++;
/* find_obj helper */
add_to_lookup_table(GET_ID(obj), (void *)obj);
if (GET_OBJ_VNUM(obj) != NOTHING) {
/* remove any old scripts */
if (SCRIPT(obj)) {
extract_script(obj, OBJ_TRIGGER);
SCRIPT(obj) = NULL;
}
free_proto_script(obj, OBJ_TRIGGER);
robj = real_object(GET_OBJ_VNUM(obj));
copy_proto_script(&obj_proto[robj], obj, OBJ_TRIGGER);
assign_triggers(obj, OBJ_TRIGGER);
}
SET_BIT_AR(GET_OBJ_EXTRA(obj), ITEM_UNIQUE_SAVE);
/* Xap - ought to save the old pointer, free after assignment I suppose */
mudlog(CMP, MAX(LVL_BUILDER, GET_INVIS_LEV(d->character)), TRUE,
"OLC: %s iedit a unique #%d", GET_NAME(d->character), GET_OBJ_VNUM(obj));
if (d->character) {
REMOVE_BIT_AR(PLR_FLAGS(d->character), PLR_WRITING);
STATE(d) = CON_PLAYING;
act("$n stops using OLC.", TRUE, d->character, 0, 0, TO_ROOM);
}
free(d->olc);
d->olc = NULL;
}
return;
case '1':
write_to_output(d, "Enter namelist : ");
OLC_MODE(d) = OEDIT_EDIT_NAMELIST;
break;
case '2':
write_to_output(d, "Enter short desc : ");
OLC_MODE(d) = OEDIT_SHORTDESC;
break;
case '3':
write_to_output(d, "Enter long desc :-\r\n| ");
OLC_MODE(d) = OEDIT_LONGDESC;
break;
case '4':
OLC_MODE(d) = OEDIT_ACTDESC;
send_editor_help(d);
write_to_output(d, "Enter action description:\r\n\r\n");
if (OLC_OBJ(d)->action_description) {
write_to_output(d, "%s", OLC_OBJ(d)->action_description);
oldtext = strdup(OLC_OBJ(d)->action_description);
}
string_write(d, &OLC_OBJ(d)->action_description, MAX_MESSAGE_LENGTH, 0, oldtext);
OLC_VAL(d) = 1;
break;
case '5':
oedit_disp_type_menu(d);
OLC_MODE(d) = OEDIT_TYPE;
break;
case '6':
oedit_disp_extra_menu(d);
OLC_MODE(d) = OEDIT_EXTRAS;
break;
case '7':
oedit_disp_wear_menu(d);
OLC_MODE(d) = OEDIT_WEAR;
break;
case '8':
write_to_output(d, "Enter weight : ");
OLC_MODE(d) = OEDIT_WEIGHT;
break;
case '9':
write_to_output(d, "Enter cost : ");
OLC_MODE(d) = OEDIT_COST;
break;
case 'a':
case 'A':
write_to_output(d, "Enter cost per day : ");
OLC_MODE(d) = OEDIT_COSTPERDAY;
break;
case 'b':
case 'B':
write_to_output(d, "Enter timer : ");
OLC_MODE(d) = OEDIT_TIMER;
break;
case 'c':
case 'C':
/*
* Clear any old values
*/
GET_OBJ_VAL(OLC_OBJ(d), 0) = 0;
GET_OBJ_VAL(OLC_OBJ(d), 1) = 0;
GET_OBJ_VAL(OLC_OBJ(d), 2) = 0;
GET_OBJ_VAL(OLC_OBJ(d), 3) = 0;
OLC_VAL(d) = 1;
oedit_disp_val1_menu(d);
break;
case 'd':
case 'D':
oedit_disp_prompt_apply_menu(d);
break;
case 'e':
case 'E':
/*
* If extra descriptions don't exist.
*/
if (OLC_OBJ(d)->ex_description == NULL) {
CREATE(OLC_OBJ(d)->ex_description, struct extra_descr_data, 1);
OLC_OBJ(d)->ex_description->next = NULL;
}
OLC_DESC(d) = OLC_OBJ(d)->ex_description;
oedit_disp_extradesc_menu(d);
break;
case 'm':
case 'M':
write_to_output(d, "Enter new minimum level: ");
OLC_MODE(d) = OEDIT_LEVEL;
break;
case 'p':
case 'P':
oedit_disp_perm_menu(d);
OLC_MODE(d) = OEDIT_PERM;
break;
case 's':
case 'S':
if (STATE(d) != CON_IEDIT) {
OLC_SCRIPT_EDIT_MODE(d) = SCRIPT_MAIN_MENU;
dg_script_menu(d);
} else {
write_to_output(d, "\r\nScripts cannot be modified on individual objects.\r\nEnter choice : ");
}
return;
default:
oedit_disp_menu(d);
break;
}
return; /*
* end of OEDIT_MAIN_MENU
*/
case OLC_SCRIPT_EDIT:
if (dg_script_edit_parse(d, arg)) return;
break;
case OEDIT_EDIT_NAMELIST:
if (!genolc_checkstring(d, arg))
break;
if (OLC_OBJ(d)->name)
free(OLC_OBJ(d)->name);
OLC_OBJ(d)->name = str_udup(arg);
break;
case OEDIT_SHORTDESC:
if (!genolc_checkstring(d, arg))
break;
if (OLC_OBJ(d)->short_description)
free(OLC_OBJ(d)->short_description);
OLC_OBJ(d)->short_description = str_udup(arg);
break;
case OEDIT_LONGDESC:
if (!genolc_checkstring(d, arg))
break;
if (OLC_OBJ(d)->description)
free(OLC_OBJ(d)->description);
OLC_OBJ(d)->description = str_udup(arg);
break;
case OEDIT_TYPE:
number = atoi(arg);
if ((number < 1) || (number >= NUM_ITEM_TYPES)) {
write_to_output(d, "Invalid choice, try again : ");
return;
} else
GET_OBJ_TYPE(OLC_OBJ(d)) = number;
/* what's the boundschecking worth if we don't do this ? -- Welcor */
GET_OBJ_VAL(OLC_OBJ(d), 0) = GET_OBJ_VAL(OLC_OBJ(d), 1) =
GET_OBJ_VAL(OLC_OBJ(d), 2) = GET_OBJ_VAL(OLC_OBJ(d), 3) = 0;
break;
case OEDIT_EXTRAS:
number = atoi(arg);
if ((number < 0) || (number > NUM_ITEM_FLAGS)) {
oedit_disp_extra_menu(d);
return;
} else if (number == 0)
break;
else {
TOGGLE_BIT_AR(GET_OBJ_EXTRA(OLC_OBJ(d)), number - 1);
oedit_disp_extra_menu(d);
return;
}
case OEDIT_WEAR:
number = atoi(arg);
if ((number < 0) || (number > NUM_ITEM_WEARS)) {
write_to_output(d, "That's not a valid choice!\r\n");
oedit_disp_wear_menu(d);
return;
} else if (number == 0) /* Quit. */
break;
else {
TOGGLE_BIT_AR(GET_OBJ_WEAR(OLC_OBJ(d)), (number - 1));
oedit_disp_wear_menu(d);
return;
}
case OEDIT_WEIGHT:
GET_OBJ_WEIGHT(OLC_OBJ(d)) = LIMIT(atoi(arg), 0, MAX_OBJ_WEIGHT);
break;
case OEDIT_COST:
GET_OBJ_COST(OLC_OBJ(d)) = LIMIT(atoi(arg), 0, MAX_OBJ_COST);
break;
case OEDIT_COSTPERDAY:
GET_OBJ_RENT(OLC_OBJ(d)) = LIMIT(atoi(arg), 0, MAX_OBJ_RENT);
break;
case OEDIT_TIMER:
switch (GET_OBJ_TYPE(OLC_OBJ(d))) {
case ITEM_PORTAL:
GET_OBJ_TIMER(OLC_OBJ(d)) = LIMIT(atoi(arg), -1, MAX_OBJ_TIMER);
break;
default:
GET_OBJ_TIMER(OLC_OBJ(d)) = LIMIT(atoi(arg), 0, MAX_OBJ_TIMER);
break;
}
break;
case OEDIT_LEVEL:
GET_OBJ_LEVEL(OLC_OBJ(d)) = LIMIT(atoi(arg), 0, LVL_IMPL);
break;
case OEDIT_PERM:
if ((number = atoi(arg)) == 0)
break;
if (number > 0 && number <= NUM_AFF_FLAGS) {
/* Setting AFF_CHARM on objects like this is dangerous. */
if (number != AFF_CHARM) {
TOGGLE_BIT_AR(GET_OBJ_PERM(OLC_OBJ(d)), number);
}
}
oedit_disp_perm_menu(d);
return;
case OEDIT_VALUE_1:
/*
* Lucky, I don't need to check any of these for out of range values.
* Hmm, I'm not so sure - Rv
*/
switch (GET_OBJ_TYPE(OLC_OBJ(d))) {
case ITEM_WEAPON:
GET_OBJ_VAL(OLC_OBJ(d), 0) = MIN(MAX(atoi(arg), -50), 50);
break;
case ITEM_CONTAINER:
GET_OBJ_VAL(OLC_OBJ(d), 0) = LIMIT(atoi(arg), -1, MAX_CONTAINER_SIZE);
break;
default:
GET_OBJ_VAL(OLC_OBJ(d), 0) = atoi(arg);
}
/*
* proceed to menu 2
*/
oedit_disp_val2_menu(d);
return;
case OEDIT_VALUE_2:
/*
* Here, I do need to check for out of range values.
*/
number = atoi(arg);
switch (GET_OBJ_TYPE(OLC_OBJ(d))) {
case ITEM_SCROLL:
case ITEM_POTION:
if (number == 0 || number == -1)
GET_OBJ_VAL(OLC_OBJ(d), 1) = -1;
else
GET_OBJ_VAL(OLC_OBJ(d), 1) = LIMIT(number, 1, NUM_SPELLS-1);
oedit_disp_val3_menu(d);
break;
case ITEM_CONTAINER:
case ITEM_VEHICLE:
case ITEM_HATCH:
case ITEM_WINDOW:
case ITEM_PORTAL:
/*
* Needs some special handling since we are dealing with flag values
* here.
*/
if (number < 0 || number > 4)
oedit_disp_container_flags_menu(d);
else if (number != 0) {
TOGGLE_BIT(GET_OBJ_VAL(OLC_OBJ(d), 1), 1 << (number - 1));
OLC_VAL(d) = 1;
oedit_disp_val2_menu(d);
} else
oedit_disp_val3_menu(d);
break;
case ITEM_WEAPON:
GET_OBJ_VAL(OLC_OBJ(d), 1) = LIMIT(number, 1, MAX_WEAPON_NDICE);
oedit_disp_val3_menu(d);
break;
default:
GET_OBJ_VAL(OLC_OBJ(d), 1) = number;
oedit_disp_val3_menu(d);
}
return;
case OEDIT_VALUE_3:
number = atoi(arg);
/*
* Quick'n'easy error checking.
*/
switch (GET_OBJ_TYPE(OLC_OBJ(d))) {
case ITEM_SCROLL:
case ITEM_POTION:
if (number == 0 || number == -1) {
GET_OBJ_VAL(OLC_OBJ(d), 2) = -1;
oedit_disp_val4_menu(d);
return;
}
min_val = 1;
max_val = NUM_SPELLS - 1;
break;
case ITEM_WEAPON:
min_val = 1;
max_val = MAX_WEAPON_SDICE;
break;
case ITEM_WAND:
case ITEM_STAFF:
min_val = 0;
max_val = 20;
break;
case ITEM_DRINKCON:
case ITEM_FOUNTAIN:
min_val = 0;
max_val = NUM_LIQ_TYPES - 1;
break;
case ITEM_KEY:
min_val = 0;
max_val = 32099;
break;
default:
min_val = -32000;
max_val = 32000;
}
GET_OBJ_VAL(OLC_OBJ(d), 2) = LIMIT(number, min_val, max_val);
oedit_disp_val4_menu(d);
return;
case OEDIT_VALUE_4:
number = atoi(arg);
switch (GET_OBJ_TYPE(OLC_OBJ(d))) {
case ITEM_SCROLL:
case ITEM_POTION:
if (number == 0 || number == -1) {
GET_OBJ_VAL(OLC_OBJ(d), 3) = -1;
oedit_disp_menu(d);
return;
}
min_val = 1;
max_val = NUM_SPELLS - 1;
break;
case ITEM_WAND:
case ITEM_STAFF:
min_val = 1;
max_val = NUM_SPELLS - 1;
break;
case ITEM_WEAPON:
min_val = 0;
max_val = NUM_ATTACK_TYPES - 1;
break;
default:
min_val = -32000;
max_val = 32000;
break;
}
GET_OBJ_VAL(OLC_OBJ(d), 3) = LIMIT(number, min_val, max_val);
break;
case OEDIT_PROMPT_APPLY:
if ((number = atoi(arg)) == 0)
break;
else if (number < 0 || number > MAX_OBJ_AFFECT) {
oedit_disp_prompt_apply_menu(d);
return;
}
OLC_VAL(d) = number - 1;
OLC_MODE(d) = OEDIT_APPLY;
oedit_disp_apply_menu(d);
return;
case OEDIT_APPLY:
if ((number = atoi(arg)) == 0) {
OLC_OBJ(d)->affected[OLC_VAL(d)].location = 0;
OLC_OBJ(d)->affected[OLC_VAL(d)].modifier = 0;
oedit_disp_prompt_apply_menu(d);
} else if (number < 0 || number >= NUM_APPLIES)
oedit_disp_apply_menu(d);
else {
int counter;
/* add in check here if already applied.. deny builders another */
if (GET_LEVEL(d->character) < LVL_IMPL) {
for (counter = 0; counter < MAX_OBJ_AFFECT; counter++) {
if (OLC_OBJ(d)->affected[counter].location == number) {
write_to_output(d, "Object already has that apply.");
return;
}
}
}
OLC_OBJ(d)->affected[OLC_VAL(d)].location = number;
write_to_output(d, "Modifier : ");
OLC_MODE(d) = OEDIT_APPLYMOD;
}
return;
case OEDIT_APPLYMOD:
OLC_OBJ(d)->affected[OLC_VAL(d)].modifier = atoi(arg);
oedit_disp_prompt_apply_menu(d);
return;
case OEDIT_EXTRADESC_KEY:
if (genolc_checkstring(d, arg)) {
if (OLC_DESC(d)->keyword)
free(OLC_DESC(d)->keyword);
OLC_DESC(d)->keyword = str_udup(arg);
}
oedit_disp_extradesc_menu(d);
return;
case OEDIT_EXTRADESC_MENU:
switch ((number = atoi(arg))) {
case 0:
if (!OLC_DESC(d)->keyword || !OLC_DESC(d)->description) {
struct extra_descr_data *temp;
if (OLC_DESC(d)->keyword)
free(OLC_DESC(d)->keyword);
if (OLC_DESC(d)->description)
free(OLC_DESC(d)->description);
/*
* Clean up pointers
*/
REMOVE_FROM_LIST(OLC_DESC(d), OLC_OBJ(d)->ex_description, next);
free(OLC_DESC(d));
OLC_DESC(d) = NULL;
}
break;
case 1:
OLC_MODE(d) = OEDIT_EXTRADESC_KEY;
write_to_output(d, "Enter keywords, separated by spaces :-\r\n| ");
return;
case 2:
OLC_MODE(d) = OEDIT_EXTRADESC_DESCRIPTION;
send_editor_help(d);
write_to_output(d, "Enter the extra description:\r\n\r\n");
if (OLC_DESC(d)->description) {
write_to_output(d, "%s", OLC_DESC(d)->description);
oldtext = strdup(OLC_DESC(d)->description);
}
string_write(d, &OLC_DESC(d)->description, MAX_MESSAGE_LENGTH, 0, oldtext);
OLC_VAL(d) = 1;
return;
case 3:
/*
* Only go to the next description if this one is finished.
*/
if (OLC_DESC(d)->keyword && OLC_DESC(d)->description) {
struct extra_descr_data *new_extra;
if (OLC_DESC(d)->next)
OLC_DESC(d) = OLC_DESC(d)->next;
else { /* Make new extra description and attach at end. */
CREATE(new_extra, struct extra_descr_data, 1);
OLC_DESC(d)->next = new_extra;
OLC_DESC(d) = OLC_DESC(d)->next;
}
}
/*
* No break - drop into default case.
*/
default:
oedit_disp_extradesc_menu(d);
return;
}
break;
default:
mudlog(BRF, LVL_BUILDER, TRUE, "SYSERR: OLC: Reached default case in oedit_parse()!");
write_to_output(d, "Oops...\r\n");
break;
}
/* olc editnews command */
void do_editnews( CHAR_DATA *ch, char *argument )
{
char arg[MAX_INPUT_LENGTH];
if(IS_NPC(ch) || !IS_IMMORTAL(ch))
{
send_to_char( "Huh?\n\r", ch );
return;
}
set_char_color( AT_GREEN, ch );
switch( ch->substate )
{
default:
break;
case SUB_NEWS_POST:
{
NEWS *news = NULL;
news = ch->dest_buf;
STRFREE(news->post);
news->post = copy_buffer(ch);
stop_editing( ch );
ch->substate = ch->tempnum;
renumber_news();
save_news();
return;
}
break;
case SUB_NEWS_EDIT:
{
NEWS *news = NULL;
news = ch->dest_buf;
STRFREE(news->post);
news->post = copy_buffer(ch);
stop_editing( ch );
ch->substate = ch->tempnum;
renumber_news();
save_news();
return;
}
break;
}
argument = one_argument(argument, arg);
if(arg[0] == '\0' )
{
send_to_char( "Syntax: editnews addtype <name>\n\r"
" editnews addnews <type> <subject>\n\r"
" editnews removetype <number>\n\r"
" editnews removenews <type> <number>\n\r"
" editnews edittype <field> <value>\n\r"
" editnews editnews <type> <number> <new subject [optional]>\n\r"
" Fields being one of the following:\n\r"
" name header cmd_name level\n\r", ch);
return;
}
if( !str_cmp(arg, "save"))
{
renumber_news();
save_news();
send_to_char( "News saved.\n\r", ch );
return;
}
if(!str_cmp(arg, "addtype"))
{
NEWS_TYPE *type = NULL;
if(argument[0] == '\0')
{
send_to_char("Syntax: editnews addtype <name>\n\r", ch);
return;
}
if(top_news_type >= NEWS_MAX_TYPES)
{
send_to_char("There are too many news types.\n\r", ch);
return;
}
CREATE(type, NEWS_TYPE, 1);
type->name = STRALLOC(argument);
type->cmd_name = STRALLOC(argument);
type->vnum = top_news_type++;
type->level = -1;
news_command_table[type->vnum] = STRALLOC(type->cmd_name);
LINK(type, first_news_type, last_news_type, next, prev);
ch_printf( ch, "Newstype '%s' created.\n\r", argument );
return;
}
if(!str_cmp(arg, "removetype"))
{
NEWS_TYPE *type = NULL;
if(argument[0] == '\0')
{
send_to_char("Syntax: editnews removetype <name>\n\r", ch);
return;
}
if((type = figure_type(argument)) == NULL)
{
send_to_char("Invaild newstype.\n\r", ch);
return;
}
UNLINK(type, first_news_type, last_news_type, next, prev);
if(type->name)
STRFREE(type->name);
if(type->header)
STRFREE(type->header);
if(type->cmd_name)
STRFREE(type->cmd_name);
if(news_command_table[type->vnum])
STRFREE(news_command_table[type->vnum]);
if(news_command_table[type->level])
STRFREE(news_command_table[type->level]);
{
NEWS *news = NULL;
void *next;
for(news = type->first_news; news; news = next)
{
next = news->next;
UNLINK( news, type->first_news, type->last_news, next, prev );
if(news->name)
STRFREE(news->name);
if(news->title)
STRFREE(news->title);
if(news->date)
STRFREE( news->date );
if(news->post)
STRFREE( news->post );
DISPOSE(news);
}
}
DISPOSE(type);
top_news_type--;
renumber_news();
save_news();
ch_printf( ch, "Newstype '%s' removed.\n\r", argument );
return;
}
if(!str_cmp(arg, "edittype"))
{
char arg2[MAX_INPUT_LENGTH];
char arg3[MAX_INPUT_LENGTH];
NEWS_TYPE *type = NULL;
argument = one_argument(argument, arg2);
argument = one_argument(argument, arg3);
if(arg2[0] == '\0' || arg3[0] == '\0')
{
send_to_char("Syntax: editnews edittype <type> <field> <value>\n\r", ch);
send_to_char("Fields being one of the following:\n\r"
"name header cmd_name level\n\r", ch );
return;
}
if((type = figure_type(arg2)) == NULL)
{
send_to_char("Invalid newstype.\n\r", ch);
return;
}
if(!str_cmp(arg3, "cmd_name"))
{
type->cmd_name = STRALLOC(argument);
news_command_table[type->vnum] = STRALLOC(type->cmd_name);
send_to_char("Cmd_name set.\n\r", ch);
save_news();
return;
}
else if(!str_cmp(arg3, "name"))
{
type->name = STRALLOC(argument);
send_to_char("Name set.\n\r", ch);
save_news();
return;
}
else if(!str_cmp(arg3, "level"))
{
if ( argument[0] == '\0' )
{
ch_printf( ch, "%d\n\r", type->level );
return;
}
else
type->level = atoi(argument);
send_to_char("Level set.\n\r", ch);
save_news();
return;
}
else
{
send_to_char("Syntax: editnews edittype <type> <field> <value>\n\r", ch);
send_to_char("Fields being one of the following:\n\r"
"name header cmd_name level\n\r", ch );
return;
}
}
if( !str_cmp(arg, "addnews" ))
{
char arg[MAX_INPUT_LENGTH];
NEWS_TYPE *type = NULL;
NEWS *news = NULL;
argument = one_argument(argument, arg);
if(arg[0] == '\0' || argument[0] == '\0')
{
send_to_char( "Syntax: editnews addnews <type> <subject>\n\r", ch );
return;
}
if((type = figure_type(arg)) == NULL)
{
send_to_char("Invaild newstype. Use 'newstypes' to get a valid listing.\n\r", ch);
return;
}
CREATE( news, NEWS, 1 );
news->title = STRALLOC(argument);
news->name = STRALLOC(ch->name);
news->date = STRALLOC(stamp_time( ));
news->post = STRALLOC("");
/* pop character into a writing buffer */
if( ch->substate == SUB_REPEATCMD )
ch->tempnum = SUB_REPEATCMD;
else
ch->tempnum = SUB_NONE;
ch->substate = SUB_NEWS_POST;
ch->dest_buf = news;
start_editing( ch, news->post );
LINK(news, type->first_news, type->last_news, next, prev);
return;
}
if( !str_cmp(arg, "editnews"))
{
char arg2[MAX_INPUT_LENGTH];
char arg3[MAX_INPUT_LENGTH];
NEWS *news = NULL;
NEWS_TYPE *type = NULL;
argument = one_argument(argument, arg2);
argument = one_argument(argument, arg3);
if(arg2[0] == '\0')
{
send_to_char( "Syntax: editnews editnews <type> <number> <new subject [optional]>\n\r", ch );
return;
}
/* changed for new -newstype- indexing - 5/5/02 */
if((type = figure_type(arg2)) == NULL)
{
send_to_char("Invalid newstype. Use 'newstypes' to get a valid listing.\n\r", ch);
return;
}
if((news = grab_news(type, arg3)) == NULL)
{
pager_printf_color(ch, "That's not a valid news number.\n\rUse '%s' to view the valid numbers.\n\r", type->cmd_name );
return;
}
/* a changed title */
if( argument[0] != '\0' )
news->title = STRALLOC( argument );
/* new date news was edited */
news->date = STRALLOC(stamp_time( ));
/* pop character into a writing buffer */
if( ch->substate == SUB_REPEATCMD )
ch->tempnum = SUB_REPEATCMD;
else
ch->tempnum = SUB_NONE;
ch->substate = SUB_NEWS_EDIT;
ch->dest_buf = news;
start_editing( ch, news->post );
return;
}
if( !str_cmp(arg, "removenews"))
{
char arg2[MAX_INPUT_LENGTH];
NEWS *news = NULL;
NEWS_TYPE *type = NULL;
argument = one_argument(argument, arg2);
if(argument[0] == '\0' || arg2[0] == '\0')
{
send_to_char("Syntax: editnews remove <number>\n\r", ch );
return;
}
/* changed for new -newstype- indexing - 5/5/02 */
if((type = figure_type(arg2)) == NULL)
{
send_to_char("Invalid newstype. Use 'newstypes' to get a valid listing.\n\r", ch);
return;
}
if((news = grab_news(type, argument)) == NULL)
{
send_to_char( "Type 'news' to gain a list of the news numbers.\n\r", ch );
return;
}
UNLINK( news, type->first_news, type->last_news, next, prev );
if(news->name)
STRFREE( news->name );
if(news->title)
STRFREE( news->title );
if(news->date)
STRFREE( news->date );
if(news->post)
STRFREE( news->post );
DISPOSE( news );
renumber_news();
save_news();
send_to_char("News item removed.\n\r", ch );
return;
}
}
void cast_bless( byte level, struct char_data *ch, char *arg, int type,
struct char_data *tar_ch, struct obj_data *tar_obj )
{
struct affected_type af;
switch (type) {
case SPELL_TYPE_SPELL:
if (tar_obj) { /* It's an object */
if ( IS_SET(tar_obj->obj_flags.extra_flags, ITEM_BLESS) ) {
send_to_char("Nothing seems to happen.\n\r", ch);
return;
}
spell_bless(level,ch,0,tar_obj);
} else { /* Then it is a PC | NPC */
if ( affected_by_spell(tar_ch, SPELL_BLESS) ||
(GET_POS(tar_ch) == POSITION_FIGHTING)) {
send_to_char("Nothing seems to happen.\n\r", ch);
return;
}
spell_bless(level,ch,tar_ch,0);
}
break;
case SPELL_TYPE_POTION:
if ( affected_by_spell(ch, SPELL_BLESS) ||
(GET_POS(ch) == POSITION_FIGHTING))
return;
spell_bless(level,ch,ch,0);
break;
case SPELL_TYPE_SCROLL:
if (tar_obj) { /* It's an object */
if ( IS_SET(tar_obj->obj_flags.extra_flags, ITEM_BLESS) )
return;
spell_bless(level,ch,0,tar_obj);
} else { /* Then it is a PC | NPC */
if (!tar_ch) tar_ch = ch;
if ( affected_by_spell(tar_ch, SPELL_BLESS) ||
(GET_POS(tar_ch) == POSITION_FIGHTING))
return;
spell_bless(level,ch,tar_ch,0);
}
break;
case SPELL_TYPE_WAND:
if (tar_obj) { /* It's an object */
if ( IS_SET(tar_obj->obj_flags.extra_flags, ITEM_BLESS) )
return;
spell_bless(level,ch,0,tar_obj);
} else { /* Then it is a PC | NPC */
if ( affected_by_spell(tar_ch, SPELL_BLESS) ||
(GET_POS(tar_ch) == POSITION_FIGHTING))
return;
spell_bless(level,ch,tar_ch,0);
}
break;
default :
log("Serious screw-up in bless!");
break;
}
}
void do_allow( CHAR_DATA* ch, const char* argument)
{
BAN_DATA *pban;
char arg1[MAX_INPUT_LENGTH];
char arg2[MAX_INPUT_LENGTH];
char *temp = NULL;
bool fMatch = FALSE;
int value = 0;
if( IS_NPC( ch ) ) /* No mobs allowing sites */
{
send_to_char( "Monsters are too dumb to do that!\r\n", ch );
return;
}
if( !ch->desc ) /* No desc is a bad thing */
{
bug( "%s", "do_allow: no descriptor" );
return;
}
argument = one_argument( argument, arg1 );
argument = one_argument( argument, arg2 );
set_char_color( AT_IMMORT, ch );
if( arg1[0] == '\0' || arg2[0] == '\0' )
goto syntax_message;
if( arg2[0] == '#' ) /* Use #1 to ban the first ban in the list specified */
{
temp = arg2;
temp++;
if( !is_number( temp ) )
{
send_to_char( "Which ban # to allow?\r\n", ch );
return;
}
value = atoi( temp );
}
if( !str_cmp( arg1, "site" ) )
{
if( !value )
{
if( strlen( arg2 ) < 2 )
{
send_to_char( "You have to have at least 2 chars for a ban\r\n", ch );
send_to_char( "If you are trying to allow by number use #\r\n", ch );
return;
}
temp = arg2;
if( arg2[0] == '*' )
temp++;
if( temp[strlen( temp ) - 1] == '*' )
temp[strlen( temp ) - 1] = '\0';
}
for( pban = first_ban; pban; pban = pban->next )
{
/*
* Need to make sure we dispose properly of the ban_data
* * Or memory problems will be created.
* * Shaddai
*/
if( value == 1 || !str_cmp( pban->name, temp ) )
{
fMatch = TRUE;
dispose_ban( pban, BAN_SITE );
break;
}
if( value > 1 )
value--;
}
}
else if( !str_cmp( arg1, "race" ) )
{
arg2[0] = toupper( arg2[0] );
for( pban = first_ban_race; pban; pban = pban->next )
{
/*
* Need to make sure we dispose properly of the ban_data
* * Or memory problems will be created.
* * Shaddai
*/
if( value == 1 || !str_cmp( pban->name, arg2 ) )
{
fMatch = TRUE;
dispose_ban( pban, BAN_RACE );
break;
}
if( value > 1 )
value--;
}
}
else if( !str_cmp( arg1, "class" ) )
{
arg2[0] = toupper( arg2[0] );
for( pban = first_ban_class; pban; pban = pban->next )
{
/*
* Need to make sure we dispose properly of the ban_data
* * Or memory problems will be created.
* * Shaddai
*/
if( value == 1 || !str_cmp( pban->name, arg2 ) )
{
fMatch = TRUE;
dispose_ban( pban, BAN_CLASS );
break;
}
if( value > 1 )
value--;
}
}
else
goto syntax_message;
if( fMatch )
{
save_banlist( );
ch_printf( ch, "%s is now allowed.\r\n", arg2 );
}
else
ch_printf( ch, "%s was not banned.\r\n", arg2 );
return;
/*
* Make sure that return above stays in!
*/
syntax_message:
send_to_char( "Syntax: allow site <address>\r\n", ch );
send_to_char( "Syntax: allow race <race>\r\n", ch );
send_to_char( "Syntax: allow class <class>\r\n", ch );
return;
}
/* toss $n $dice $table for $face */
void
char__do_toss (CHAR_DATA * ch, char *argument, int cmd)
{
register short int nArg = 0;
register short int nDiceArg = 0;
register short int nTableArg = 0;
register short int nFaceArg = 0;
register short int nFacet = 0;
register short int nMaxFacet = 0;
size_t nIndex = 0;
register int nCount = 0;
char *p = NULL;
char buf[AVG_STRING_LENGTH * 10] = "";
char arg[5][AVG_STRING_LENGTH / 5] = { "", "", "", "", "" };
char key[AVG_STRING_LENGTH] = "";
char strFacet[AVG_STRING_LENGTH] = "";
char strFacetList[AVG_STRING_LENGTH] = "";
OBJ_DATA *dice = NULL;
OBJ_DATA *table = NULL;
nArg =
sscanf (argument, "%s %s %s %s %s", arg[0], arg[1], arg[2], arg[3],
arg[4]);
if (nArg <= 0)
{
send_to_char ("Toss what?\n", ch);
return;
}
nCount = strtol (arg[0], &p, 10);
if (errno == ERANGE || nCount == 0 || strlen (p) != 0)
{
nCount = 0;
}
else
{
nDiceArg = 1;
}
switch (nArg - nDiceArg)
{
case 3:
nFaceArg = (strcmp ("for", arg[nDiceArg + 1]) == 0) ? nDiceArg + 2 : -1;
break;
case 4:
nFaceArg = (strcmp ("for", arg[nDiceArg + 2]) == 0) ? nDiceArg + 3 : -1; /* NO BREAK HERE goes to next case */
case 2:
nTableArg = nDiceArg + 1;
break;
default:
break;
}
if (nFaceArg < 0)
{
send_to_char ("Toss them how?\n", ch);
return;
}
if (!(dice = get_obj_in_dark (ch, arg[nDiceArg], ch->right_hand)) &&
!(dice = get_obj_in_dark (ch, arg[nDiceArg], ch->left_hand)))
{
sprintf (buf, "You don't have a '%s'.\n", arg[nDiceArg]);
send_to_char (buf, ch);
return;
}
if (dice->obj_flags.type_flag != ITEM_TOSSABLE
&& dice->obj_flags.type_flag != ITEM_MONEY)
{
send_to_char ("Did you mean to #6throw#0 that object?\n", ch);
return;
}
if (dice->count > 12 && (nCount == 0 || nCount > 12))
{
send_to_char ("You can't toss that many at once.\n", ch);
return;
}
if (nTableArg && arg[nTableArg][0] &&
(!(table = get_obj_in_list_vis (ch, arg[nTableArg], ch->room->contents))
|| !IS_TABLE(table)))
{
sprintf (buf, "You don't see any furniture like '%s'.\n",
arg[nTableArg]);
send_to_char (buf, ch);
return;
}
obj_from_char (&dice, nCount);
if (dice->obj_flags.type_flag == ITEM_MONEY)
{
strcpy (key, " obverse reverse ");
nMaxFacet = 2;
}
else if (dice->desc_keys)
{
sprintf (key, " %s ", dice->desc_keys);
}
else
{
strcpy (key,
" one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen twenty ");
}
if (nFaceArg && dice->o.od.value[1])
{
/*
nFacet = strtol(arg[nFaceArg],&p,10);
if ( errno == ERANGE || nFacet == 0 || strlen(p) != 0 ) {
strcpy(strFacet,strstr(key,arg[nFaceArg]));
if () {
}
else {
nFacet = 0;
}
}
else {
}
*/
}
nMaxFacet = (nMaxFacet) ? nMaxFacet : dice->o.od.value[0];
for (nCount = 0; nCount < dice->count; nCount++)
{
nFacet = number (1, nMaxFacet);
for (nIndex = 0; nIndex < strlen (key); nIndex++)
{
if (key[nIndex] == ' ' && --nFacet <= 0)
break;
}
sscanf (key + nIndex + 1, "%s %s", strFacet, buf);
sprintf (strFacetList + strlen (strFacetList), "#6%s%s#0%s",
(nMaxFacet == 2) ? "the " : "a ", strFacet,
(nCount ==
dice->count - 2) ? " and " : ((nCount !=
dice->count - 1) ? ", " : ""));
}
sprintf (buf, "You toss $p onto %s%s%s%s. The upright face%s show%s: %s.\n",
(nTableArg) ? "$P" : "the ground",
(nFaceArg) ? ", trying for #6a " : "",
(nFaceArg) ? arg[nFaceArg] : "", (nFaceArg) ? "#0" : "",
(nCount > 1) ? "s" : "", (nCount > 1) ? "" : "s", strFacetList);
act (buf, true, ch, dice, table, TO_CHAR | _ACT_FORMAT);
sprintf (buf, "$n tosses $p onto %s. The upright face%s show%s: %s.\n",
(nTableArg) ? "$P" : "the ground", (nCount > 1) ? "s" : "",
(nCount > 1) ? "" : "s", strFacetList);
act (buf, true, ch, dice, table, TO_ROOM | _ACT_FORMAT);
if (nTableArg)
{
obj_to_obj (dice, table);
}
else
{
obj_to_room (dice, ch->in_room);
}
}
/*
* This actually puts the new ban into the proper linked list and
* initializes its data. Shaddai
*/
int add_ban( CHAR_DATA * ch, const char *arg1, const char *arg2, int btime, int type )
{
char arg[MAX_STRING_LENGTH];
char buf[MAX_STRING_LENGTH];
BAN_DATA *pban, *temp;
struct tm *tms;
char *name;
int level, i, value;
/*
* Should we check to see if they have dropped link sometime in between
* * writing the note and now? Not sure but for right now we won't since
* * do_ban checks for that. Shaddai
*/
switch ( ch->substate )
{
default:
bug( "%s", "add_ban: illegal substate" );
return 0;
case SUB_RESTRICTED:
send_to_char( "You cannot use this command from within another command.\r\n", ch );
return 0;
case SUB_NONE:
{
one_argument( arg1, arg );
smash_tilde( arg ); /* Make sure the immortals don't put a ~ in it. */
if( arg[0] == '\0' || arg2[0] == '\0' )
return 0;
if( is_number( arg2 ) )
{
level = atoi( arg2 );
if( level < 0 || level > LEVEL_SUPREME )
{
ch_printf( ch, "Level range is from 0 to %d.\r\n", LEVEL_SUPREME );
return 0;
}
}
else if( !str_cmp( arg2, "all" ) )
level = LEVEL_SUPREME;
else if( !str_cmp( arg2, "newbie" ) )
level = 1;
else if( !str_cmp( arg2, "mortal" ) )
level = LEVEL_AVATAR;
else if( !str_cmp( arg2, "warn" ) )
level = BAN_WARN;
else
{
bug( "%s", "Bad string for flag in add_ban." );
return 0;
}
switch ( type )
{
case BAN_CLASS:
if( arg[0] == '\0' )
return 0;
if( is_number( arg ) )
value = atoi( arg );
else
{
for( i = 0; i < MAX_CLASS; i++ )
if( !str_cmp( class_table[i]->who_name, arg ) )
break;
value = i;
}
if( value < 0 || value >= MAX_CLASS )
{
send_to_char( "Unknown class.\r\n", ch );
return 0;
}
for( temp = first_ban_class; temp; temp = temp->next )
{
if( temp->flag == value )
{
if( temp->level == level )
{
send_to_char( "That entry already exists.\r\n", ch );
return 0;
}
else
{
temp->level = level;
if( temp->level == BAN_WARN )
temp->warn = TRUE;
snprintf( buf, MAX_STRING_LENGTH, "%24.24s", ctime( ¤t_time ) );
temp->ban_time = str_dup( buf );
if( btime > 0 )
{
temp->duration = btime;
tms = localtime( ¤t_time );
tms->tm_mday += btime;
temp->unban_date = mktime( tms );
}
else
{
temp->duration = -1;
temp->unban_date = -1;
}
if( temp->ban_by )
DISPOSE( temp->ban_by );
temp->ban_by = str_dup( ch->name );
send_to_char( "Updated entry.\r\n", ch );
return 1;
}
}
}
CREATE( pban, BAN_DATA, 1 );
pban->name = str_dup( class_table[value]->who_name );
pban->flag = value;
pban->level = level;
pban->ban_by = str_dup( ch->name );
LINK( pban, first_ban_class, last_ban_class, next, prev );
break;
case BAN_RACE:
if( is_number( arg ) )
value = atoi( arg );
else
{
for( i = 0; i < MAX_RACE; i++ )
if( !str_cmp( race_table[i]->race_name, arg ) )
break;
value = i;
}
if( value < 0 || value >= MAX_RACE )
{
send_to_char( "Unknown race.\r\n", ch );
return 0;
}
for( temp = first_ban_race; temp; temp = temp->next )
{
if( temp->flag == value )
{
if( temp->level == level )
{
send_to_char( "That entry already exists.\r\n", ch );
return 0;
}
else
{
temp->level = level;
if( temp->level == BAN_WARN )
temp->warn = TRUE;
snprintf( buf, MAX_STRING_LENGTH, "%24.24s", ctime( ¤t_time ) );
temp->ban_time = str_dup( buf );
if( btime > 0 )
{
temp->duration = btime;
tms = localtime( ¤t_time );
tms->tm_mday += btime;
temp->unban_date = mktime( tms );
}
else
{
temp->duration = -1;
temp->unban_date = -1;
}
if( temp->ban_by )
DISPOSE( temp->ban_by );
temp->ban_by = str_dup( ch->name );
send_to_char( "Updated entry.\r\n", ch );
return 1;
}
}
}
CREATE( pban, BAN_DATA, 1 );
pban->name = str_dup( race_table[value]->race_name );
pban->flag = value;
pban->level = level;
pban->ban_by = str_dup( ch->name );
LINK( pban, first_ban_race, last_ban_race, next, prev );
break;
case BAN_SITE:
{
bool prefix = FALSE, suffix = FALSE, user_name = FALSE;
char *temp_host = NULL, *temp_user = NULL;
size_t x;
for( x = 0; x < strlen( arg ); x++ )
{
if( arg[x] == '@' )
{
user_name = TRUE;
temp_host = str_dup( &arg[x + 1] );
arg[x] = '\0';
temp_user = str_dup( arg );
break;
}
}
if( !user_name )
name = arg;
else
name = temp_host;
if( !name ) /* Double check to make sure name isnt null */
{
/*
* Free this stuff if its there
*/
if( user_name )
{
DISPOSE( temp_host );
DISPOSE( temp_user );
}
send_to_char( "Name was null.\r\n", ch );
return 0;
}
if( name[0] == '*' )
{
prefix = TRUE;
name++;
}
if( name[strlen( name ) - 1] == '*' )
{
suffix = TRUE;
name[strlen( name ) - 1] = '\0';
}
for( temp = first_ban; temp; temp = temp->next )
{
if( !str_cmp( temp->name, name ) )
{
if( temp->level == level && ( prefix && temp->prefix ) && ( suffix && temp->suffix ) )
{
/*
* Free this stuff if its there
*/
if( user_name )
{
DISPOSE( temp_host );
DISPOSE( temp_user );
}
send_to_char( "That entry already exists.\r\n", ch );
return 0;
}
else
{
temp->suffix = suffix;
temp->prefix = prefix;
if( temp->level == BAN_WARN )
temp->warn = TRUE;
temp->level = level;
snprintf( buf, MAX_STRING_LENGTH, "%24.24s", ctime( ¤t_time ) );
temp->ban_time = str_dup( buf );
if( btime > 0 )
{
temp->duration = btime;
tms = localtime( ¤t_time );
tms->tm_mday += btime;
temp->unban_date = mktime( tms );
}
else
{
temp->duration = -1;
temp->unban_date = -1;
}
if( temp->ban_by )
DISPOSE( temp->ban_by );
if( user_name )
{
DISPOSE( temp_host );
DISPOSE( temp_user );
}
temp->ban_by = str_dup( ch->name );
send_to_char( "Updated entry.\r\n", ch );
return 1;
}
}
}
CREATE( pban, BAN_DATA, 1 );
pban->ban_by = str_dup( ch->name );
pban->suffix = suffix;
pban->prefix = prefix;
pban->name = str_dup( name );
pban->level = level;
LINK( pban, first_ban, last_ban, next, prev );
if( user_name )
{
DISPOSE( temp_host );
DISPOSE( temp_user );
}
break;
}
default:
bug( "Bad type in add_ban: %d.", type );
return 0;
}
snprintf( buf, MAX_STRING_LENGTH, "%24.24s", ctime( ¤t_time ) );
pban->ban_time = str_dup( buf );
if( btime > 0 )
{
pban->duration = btime;
tms = localtime( ¤t_time );
tms->tm_mday += btime;
pban->unban_date = mktime( tms );
}
else
{
pban->duration = -1;
pban->unban_date = -1;
}
if( pban->level == BAN_WARN )
pban->warn = TRUE;
ch->substate = SUB_BAN_DESC;
ch->dest_buf = pban;
if( !pban->note )
pban->note = STRALLOC( "" );;
start_editing( ch, pban->note );
return 1;
}
case SUB_BAN_DESC:
pban = ( BAN_DATA * ) ch->dest_buf;
if( !pban )
{
bug( "%s", "do_ban: sub_ban_desc: NULL ch->dest_buf" );
ch->substate = SUB_NONE;
return 0;
}
if( pban->note )
STRFREE( pban->note );
pban->note = copy_buffer( ch );
stop_editing( ch );
ch->substate = ch->tempnum;
save_banlist( );
if( pban->duration > 0 )
{
ch_printf( ch, "%s banned for %d days.\r\n", pban->name, pban->duration );
}
else
{
ch_printf( ch, "%s banned forever.\r\n", pban->name );
}
return 1;
}
}
/* Warm reboot stuff, gotta make sure to thank Erwin for this :) */
void do_hotboot( CHAR_DATA * ch, const char *argument )
{
FILE *fp;
CHAR_DATA *victim = NULL;
DESCRIPTOR_DATA *d, *de_next;
char buf[100], buf2[100], buf3[100];
extern int control;
int count = 0;
bool found = FALSE;
for( d = first_descriptor; d; d = d->next )
{
if( ( d->connected == CON_PLAYING
|| d->connected == CON_EDITING )
&& ( victim = d->character ) != NULL && !IS_NPC( victim )
&& victim->in_room && victim->fighting && victim->top_level >= 1 && victim->top_level <= MAX_LEVEL )
{
found = TRUE;
count++;
}
}
if( found )
{
ch_printf( ch, "Cannot hotboot at this time. There are %d combats in progress.\r\n", count );
return;
}
found = FALSE;
for( d = first_descriptor; d; d = d->next )
{
if( d->connected == CON_EDITING && d->character )
{
found = TRUE;
break;
}
}
if( found )
{
send_to_char( "Cannot hotboot at this time. Someone is using the line editor.\r\n", ch );
return;
}
sprintf( log_buf, "Hotboot initiated by %s.", ch->name );
log_string( log_buf );
fp = fopen( HOTBOOT_FILE, "w" );
if( !fp )
{
send_to_char( "Hotboot file not writeable, aborted.\r\n", ch );
bug( "Could not write to hotboot file: %s. Hotboot aborted.", HOTBOOT_FILE );
perror( "do_copyover:fopen" );
return;
}
/*
* And this one here will save the status of all objects and mobs in the game.
* * This really should ONLY ever be used here. The less we do stuff like this the better.
*/
save_world( ch );
#ifdef OLC_SHUTTLE
{
SHUTTLE_DATA *tshuttle;
for( tshuttle = first_shuttle; tshuttle; tshuttle = tshuttle->next )
save_shuttle( tshuttle );
}
#endif
log_string( "Saving player files and connection states...." );
if( ch && ch->desc )
write_to_descriptor( ch->desc, "\033[0m", 0 );
sprintf( buf, "\r\nYou feel a great disturbance in the Force." );
/*
* For each playing descriptor, save its state
*/
for( d = first_descriptor; d; d = de_next )
{
CHAR_DATA *och = CH( d );
de_next = d->next; /* We delete from the list , so need to save this */
if( !d->character || d->connected < CON_PLAYING ) /* drop those logging on */
{
write_to_descriptor( d, "\r\nSorry, we are rebooting. Come back in a few minutes.\r\n", 0 );
close_socket( d, FALSE ); /* throw'em out */
}
else
{
/* For test purposes
flush_buffer(d, TRUE);*/
fprintf( fp, "%d %d %d %d %d %s %s\n", d->can_compress, d->descriptor, och->in_room->vnum, d->port, d->idle, och->name, d->host );
/*
* One of two places this gets changed
*/
och->pcdata->hotboot = TRUE;
save_char_obj( och );
write_to_descriptor( d, buf, 0 );
compressEnd( d );
}
}
fprintf( fp, "%s", "-1" );
FCLOSE( fp );
#ifdef IMC
imc_hotboot( );
#endif
/*
* added this in case there's a need to debug the contents of the various files
*/
if( argument && !str_cmp( argument, "debug" ) )
{
log_string( "Hotboot debug - Aborting before execl" );
return;
}
log_string( "Executing hotboot...." );
/*
* exec - descriptors are inherited
*/
snprintf( buf, 100, "%d", port );
snprintf( buf2, 100, "%d", control );
#ifdef IMC
if( this_imcmud )
snprintf( buf3, 100, "%d", this_imcmud->desc );
else
strncpy( buf3, "-1", 100 );
#else
strncpy( buf3, "-1", 100 );
#endif
dlclose( sysdata.dlHandle );
execl( EXE_FILE, "swreality", buf, "hotboot", buf2, buf3, ( char * )NULL );
/*
* Failed - sucessful exec will not return
*/
perror( "do_hotboot: execl" );
sysdata.dlHandle = dlopen( NULL, RTLD_LAZY );
if( !sysdata.dlHandle )
{
bug( "%s", "FATAL ERROR: Unable to reopen system executable handle!" );
exit( 1 );
}
bug( "%s", "Hotboot execution failed!!" );
send_to_char( "Hotboot FAILED!\r\n", ch );
}