577 lines
12 KiB
C
577 lines
12 KiB
C
|
|
/* $Id: screen.c,v 1.3 2000/07/05 15:20:34 jholder Exp $
|
|
* --------------------------------------------------------------------
|
|
* see doc/License.txt for License Information
|
|
* --------------------------------------------------------------------
|
|
*
|
|
* File name: $Id: screen.c,v 1.3 2000/07/05 15:20:34 jholder Exp $
|
|
*
|
|
* Description:
|
|
*
|
|
* Modification history:
|
|
* $Log: screen.c,v $
|
|
* Revision 1.3 2000/07/05 15:20:34 jholder
|
|
* Updated code to remove warnings.
|
|
*
|
|
* Revision 1.2 2000/05/25 22:28:56 jholder
|
|
* changes routine names to reflect zmachine opcode names per spec 1.0
|
|
*
|
|
* Revision 1.1.1.1 2000/05/10 14:21:34 jholder
|
|
*
|
|
* imported
|
|
*
|
|
*
|
|
* --------------------------------------------------------------------
|
|
*/
|
|
|
|
/*
|
|
* screen.c
|
|
*
|
|
* Generic screen manipulation routines. Most of these routines call the machine
|
|
* specific routines to do the actual work.
|
|
*
|
|
*/
|
|
|
|
#include "ztypes.h"
|
|
|
|
/*
|
|
* z_set_window
|
|
*
|
|
* Put the cursor in the text or status window. The cursor is free to move in
|
|
* the status window, but is fixed to the input line in the text window.
|
|
*
|
|
*/
|
|
|
|
void z_set_window( zword_t w )
|
|
{
|
|
int row, col;
|
|
|
|
flush_buffer( FALSE );
|
|
|
|
screen_window = w;
|
|
|
|
if ( screen_window == STATUS_WINDOW )
|
|
{
|
|
|
|
/* Status window: disable formatting and select status window */
|
|
|
|
formatting = OFF;
|
|
scripting_disable = ON;
|
|
select_status_window( );
|
|
|
|
/* Put cursor at top of status area */
|
|
|
|
if ( h_type < V4 )
|
|
move_cursor( 2, 1 );
|
|
else
|
|
move_cursor( 1, 1 );
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
/* Text window: enable formatting and select text window */
|
|
|
|
select_text_window( );
|
|
scripting_disable = OFF;
|
|
formatting = ON;
|
|
|
|
/* Move cursor if it has been left in the status area */
|
|
|
|
get_cursor_position( &row, &col );
|
|
if ( row <= status_size )
|
|
move_cursor( status_size + 1, 1 );
|
|
|
|
}
|
|
|
|
/* Force text attribute to normal rendition */
|
|
|
|
set_attribute( NORMAL );
|
|
|
|
} /* z_set_window */
|
|
|
|
/*
|
|
* z_split_window
|
|
*
|
|
* Set the size of the status window. The default size for the status window is
|
|
* zero lines for both type 3 and 4 games. The status line is handled specially
|
|
* for type 3 games and always occurs the line immediately above the status
|
|
* window.
|
|
*
|
|
*/
|
|
|
|
void z_split_window( zword_t lines )
|
|
{
|
|
/* Maximum status window size is 255 */
|
|
|
|
lines &= 0xff;
|
|
|
|
/* The top line is always set for V1 to V3 games, so account for it here. */
|
|
|
|
if ( h_type < V4 )
|
|
lines++;
|
|
|
|
if ( lines )
|
|
{
|
|
|
|
/* If size is non zero the turn on the status window */
|
|
|
|
status_active = ON;
|
|
|
|
/* Bound the status size to one line less than the total screen height */
|
|
|
|
if ( lines > ( zword_t ) ( screen_rows - 1 ) )
|
|
status_size = ( zword_t ) ( screen_rows - 1 );
|
|
else
|
|
status_size = lines;
|
|
|
|
/* Create the status window, or resize it */
|
|
|
|
create_status_window( );
|
|
|
|
/* Need to clear the status window for type 3 games */
|
|
|
|
if ( h_type < V4 )
|
|
z_erase_window( STATUS_WINDOW );
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
/* Lines are zero so turn off the status window */
|
|
|
|
status_active = OFF;
|
|
|
|
/* Reset the lines written counter and status size */
|
|
|
|
lines_written = 0;
|
|
status_size = 0;
|
|
|
|
/* Delete the status window */
|
|
|
|
delete_status_window( );
|
|
|
|
/* Return cursor to text window */
|
|
|
|
select_text_window( );
|
|
}
|
|
|
|
} /* z_split_window */
|
|
|
|
/*
|
|
* z_erase_window
|
|
*
|
|
* Clear one or all windows on the screen.
|
|
*
|
|
*/
|
|
|
|
void z_erase_window( zword_t w )
|
|
{
|
|
flush_buffer( TRUE );
|
|
|
|
if ( ( zbyte_t ) w == ( zbyte_t ) Z_SCREEN )
|
|
{
|
|
clear_screen( );
|
|
}
|
|
else if ( ( zbyte_t ) w == TEXT_WINDOW )
|
|
{
|
|
clear_text_window( );
|
|
}
|
|
else if ( ( zbyte_t ) w == STATUS_WINDOW )
|
|
{
|
|
clear_status_window( );
|
|
return;
|
|
}
|
|
|
|
//if ( h_type > V4 )
|
|
// move_cursor( 1, 1 );
|
|
//else
|
|
move_cursor( screen_rows, 1 );
|
|
|
|
} /* z_erase_window */
|
|
|
|
/*
|
|
* z_erase_line
|
|
*
|
|
* Clear one line on the screen.
|
|
*
|
|
*/
|
|
|
|
void z_erase_line( zword_t flag )
|
|
{
|
|
if ( flag == TRUE )
|
|
clear_line( );
|
|
} /* z_erase_line */
|
|
|
|
/*
|
|
* z_set_cursor
|
|
*
|
|
* Set the cursor position in the status window only.
|
|
*
|
|
*/
|
|
|
|
void z_set_cursor( zword_t row, zword_t column )
|
|
{
|
|
/* Can only move cursor if format mode is off and in status window */
|
|
|
|
if ( formatting == OFF && screen_window == STATUS_WINDOW )
|
|
{
|
|
move_cursor( row, column );
|
|
}
|
|
#ifdef STRICTZ
|
|
else
|
|
{
|
|
report_strictz_error( STRZERR_MOV_CURSOR, "@set_cursor called outside the status window!" );
|
|
}
|
|
#endif
|
|
} /* z_set_cursor */
|
|
|
|
/*
|
|
* pad_line
|
|
*
|
|
* Pad the status line with spaces up to a column position.
|
|
*
|
|
*/
|
|
|
|
static void pad_line( int column )
|
|
{
|
|
int i;
|
|
|
|
for ( i = status_pos; i < column; i++ )
|
|
write_char( ' ' );
|
|
status_pos = column;
|
|
} /* pad_line */
|
|
|
|
/*
|
|
* z_show_status
|
|
*
|
|
* Format and output the status line for type 3 games only.
|
|
*
|
|
*/
|
|
|
|
void z_show_status( void )
|
|
{
|
|
int i, count = 0, end_of_string[3];
|
|
char *status_part[3];
|
|
|
|
/* Move the cursor to the top line of the status window, set the reverse
|
|
* rendition and print the status line */
|
|
|
|
z_set_window( STATUS_WINDOW );
|
|
move_cursor( 1, 1 );
|
|
set_attribute( REVERSE );
|
|
|
|
/* Redirect output to the status line buffer */
|
|
|
|
z_output_stream( 3, 0 );
|
|
|
|
/* Print the object description for global variable 16 */
|
|
|
|
pad_line( 1 );
|
|
status_part[count] = &status_line[status_pos];
|
|
if ( load_variable( 16 ) != 0 )
|
|
z_print_obj( load_variable( 16 ) );
|
|
end_of_string[count++] = status_pos;
|
|
status_line[status_pos++] = '\0';
|
|
|
|
if ( get_byte( H_CONFIG ) & CONFIG_TIME )
|
|
{
|
|
|
|
/* If a time display print the hours and minutes from global
|
|
* variables 17 and 18 */
|
|
|
|
pad_line( screen_cols - 21 );
|
|
status_part[count] = &status_line[status_pos];
|
|
write_string( " Time: " );
|
|
print_time( load_variable( 17 ), load_variable( 18 ) );
|
|
end_of_string[count++] = status_pos;
|
|
status_line[status_pos++] = '\0';
|
|
}
|
|
else
|
|
{
|
|
|
|
/* If a moves/score display print the score and moves from global
|
|
* variables 17 and 18 */
|
|
|
|
pad_line( screen_cols - 31 );
|
|
status_part[count] = &status_line[status_pos];
|
|
write_string( " Score: " );
|
|
z_print_num( load_variable( 17 ) );
|
|
end_of_string[count++] = status_pos;
|
|
status_line[status_pos++] = '\0';
|
|
|
|
pad_line( screen_cols - 15 );
|
|
status_part[count] = &status_line[status_pos];
|
|
write_string( " Moves: " );
|
|
z_print_num( load_variable( 18 ) );
|
|
end_of_string[count++] = status_pos;
|
|
status_line[status_pos++] = '\0';
|
|
}
|
|
|
|
/* Pad the end of status line with spaces then disable output redirection */
|
|
|
|
pad_line( screen_cols );
|
|
z_output_stream( ( zword_t ) - 3, 0 );
|
|
|
|
/* Try and print the status line for a proportional font screen. If this
|
|
* fails then remove embedded nulls in status line buffer and just output
|
|
* it to the screen */
|
|
|
|
if ( print_status( count, status_part ) == FALSE )
|
|
{
|
|
for ( i = 0; i < count; i++ )
|
|
status_line[end_of_string[i]] = ' ';
|
|
status_line[status_pos] = '\0';
|
|
write_string( status_line );
|
|
}
|
|
|
|
set_attribute( NORMAL );
|
|
z_set_window( TEXT_WINDOW );
|
|
|
|
} /* z_show_status */
|
|
|
|
/*
|
|
* blank_status_line
|
|
*
|
|
* Output a blank status line for type 3 games only.
|
|
*
|
|
*/
|
|
|
|
void blank_status_line( void )
|
|
{
|
|
|
|
/* Move the cursor to the top line of the status window, set the reverse
|
|
* rendition and print the status line */
|
|
|
|
z_set_window( STATUS_WINDOW );
|
|
move_cursor( 1, 1 );
|
|
set_attribute( REVERSE );
|
|
|
|
/* Redirect output to the status line buffer and pad the status line with
|
|
* spaces then disable output redirection */
|
|
|
|
z_output_stream( 3, 0 );
|
|
pad_line( screen_cols );
|
|
status_line[status_pos] = '\0';
|
|
z_output_stream( ( zword_t ) - 3, 0 );
|
|
|
|
/* Write the status line */
|
|
|
|
write_string( status_line );
|
|
|
|
/* Turn off attributes and return to text window */
|
|
|
|
set_attribute( NORMAL );
|
|
z_set_window( TEXT_WINDOW );
|
|
|
|
} /* blank_status_line */
|
|
|
|
/*
|
|
* output_string
|
|
*
|
|
* Output a string of characters.
|
|
*
|
|
*/
|
|
|
|
void output_string( const char *s )
|
|
{
|
|
while ( *s )
|
|
output_char( *s++ );
|
|
} /* output_string */
|
|
|
|
/*
|
|
* output_line
|
|
*
|
|
* Output a string of characters followed by a new line.
|
|
*
|
|
*/
|
|
|
|
void output_line( const char *s )
|
|
{
|
|
output_string( s );
|
|
output_new_line( );
|
|
} /* output_line */
|
|
|
|
/*
|
|
* output_char
|
|
*
|
|
* Output a character.
|
|
*
|
|
*/
|
|
|
|
void output_char( int c )
|
|
{
|
|
/* If output is enabled then either select the rendition attribute
|
|
* or just display the character */
|
|
|
|
if ( outputting == ON )
|
|
{
|
|
display_char( (unsigned int)(c & 0xff) );
|
|
}
|
|
} /* output_char */
|
|
|
|
/*
|
|
* output_new_line
|
|
*
|
|
* Scroll the text window up one line and pause the window if it is full.
|
|
*
|
|
*/
|
|
|
|
void output_new_line( void )
|
|
{
|
|
int row, col;
|
|
|
|
/* Don't print if output is disabled or replaying commands */
|
|
|
|
if ( outputting == ON )
|
|
{
|
|
|
|
if ( formatting == ON && screen_window == TEXT_WINDOW )
|
|
{
|
|
|
|
/* If this is the text window then scroll it up one line */
|
|
|
|
scroll_line( );
|
|
|
|
/* See if we have filled the screen. The spare line is for
|
|
* the [MORE] message
|
|
*/
|
|
|
|
if ( ++lines_written >= ( ( screen_rows - top_margin ) - status_size - 1 ) )
|
|
{
|
|
|
|
/* Display the new status line while the screen in paused */
|
|
|
|
if ( h_type < V4 )
|
|
z_show_status( );
|
|
|
|
/* Reset the line count and display the more message */
|
|
|
|
lines_written = 0;
|
|
|
|
if ( replaying == OFF )
|
|
{
|
|
get_cursor_position( &row, &col );
|
|
output_string( "[MORE]" );
|
|
( void ) input_character( 0 );
|
|
move_cursor( row, col );
|
|
output_string( " " );
|
|
move_cursor( row, col );
|
|
/* clear_line (); */
|
|
}
|
|
}
|
|
}
|
|
else
|
|
/* If this is the status window then just output a new line */
|
|
|
|
output_char( '\n' );
|
|
}
|
|
|
|
} /* output_new_line */
|
|
|
|
/*
|
|
* z_print_table
|
|
*
|
|
* Writes text into a rectangular window on the screen.
|
|
*
|
|
* argv[0] = start of text address
|
|
* argv[1] = rectangle width
|
|
* argv[2] = rectangle height (default = 1)
|
|
*
|
|
*/
|
|
|
|
void z_print_table( int argc, zword_t * argv )
|
|
{
|
|
unsigned long address;
|
|
unsigned int width, height;
|
|
unsigned int row, column;
|
|
|
|
/* Supply default arguments */
|
|
|
|
if ( argc < 3 )
|
|
argv[2] = 1;
|
|
|
|
/* Don't do anything if the window is zero high or wide */
|
|
|
|
if ( argv[1] == 0 || argv[2] == 0 )
|
|
return;
|
|
|
|
/* Get coordinates of top left corner of rectangle */
|
|
|
|
get_cursor_position( ( int * ) &row, ( int * ) &column );
|
|
|
|
address = argv[0];
|
|
|
|
/* Write text in width * height rectangle */
|
|
|
|
for ( height = 0; height < argv[2]; height++ )
|
|
{
|
|
|
|
for ( width = 0; width < argv[1]; width++ )
|
|
write_char( read_data_byte( &address ) );
|
|
|
|
/* Put cursor back to lefthand side of rectangle on next line */
|
|
|
|
if ( height != (unsigned)( argv[2] - 1 ) )
|
|
move_cursor( ++row, column );
|
|
|
|
}
|
|
|
|
} /* z_print_table */
|
|
|
|
/*
|
|
* z_set_font
|
|
*
|
|
* Set text or graphic font. 1 = text font, 3 = graphics font.
|
|
*
|
|
*/
|
|
|
|
void z_set_font( zword_t new_font )
|
|
{
|
|
zword_t old_font = font;
|
|
|
|
if ( new_font != old_font )
|
|
{
|
|
font = new_font;
|
|
set_font( font );
|
|
}
|
|
|
|
store_operand( old_font );
|
|
|
|
} /* z_set_font */
|
|
|
|
/*
|
|
* z_set_colour
|
|
*
|
|
* Set the colour of the screen. Colour can be set on four things:
|
|
* Screen background
|
|
* Text typed by player
|
|
* Text written by game
|
|
* Graphics characters
|
|
*
|
|
* Colors can be set to 1 of 9 values:
|
|
* 1 = machine default (IBM/PC = blue background, everything else white)
|
|
* 2 = black
|
|
* 3 = red
|
|
* 4 = green
|
|
* 5 = brown
|
|
* 6 = blue
|
|
* 7 = magenta
|
|
* 8 = cyan
|
|
* 9 = white
|
|
*
|
|
*/
|
|
|
|
void z_set_colour( zword_t foreground, zword_t background )
|
|
{
|
|
if ( ( ZINT16 ) foreground < -1 || ( ZINT16 ) foreground > 9 || ( ZINT16 ) background < -1 ||
|
|
( ZINT16 ) background > 9 )
|
|
fatal( "Bad colour!" );
|
|
|
|
|
|
flush_buffer( FALSE );
|
|
|
|
set_colours( foreground, background );
|
|
|
|
return;
|
|
} /* z_set_colour */
|