void foogodRepaint(void)
{
screen_erase(&Foogod.screenRect);
switch (Foogod.mode) {
default:
case FOOGOD_DEFAULT:
if (Session) {
foogodPaintSessionInfo();
}
screen_print(&Foogod.combatRect, SP_RIGHTJUSTIFIED,
"Combat: %c", combatGetState());
break;
case FOOGOD_HINT:
screen_print(&Foogod.screenRect, 0, Foogod.hintText);
break;
case FOOGOD_PROGRESS_BAR:
foogod_progress_bar_paint();
break;
}
foogod_repaint_title();
screen_update(&Foogod.screenRect);
}
extern "C" int syscall_main(int command, int arg1, int arg2, int arg3, IRETState iret) {
(void)arg3;
switch(command) {
case SYSCALL_COMMAND_FORK: {
auto task = Task::Create("one.elf");
task->next = _kernel_state.task->next;
_kernel_state.task->next = task;
return 0;
return -1;
break;
}
case SYSCALL_COMMAND_OPEN:
return 5;
break;
case SYSCALL_COMMAND_GET:
if(arg1 == STDIN_FILENO) {
__asm__ ("sti");
while(!stdin_available) {
__asm__ ("hlt");
}
__asm__ ("cli");
stdin_available = false;
// POSIX -> 11. General Terminal Interface -> Canonical Mode Input Processing
screen_put(stdin_char, SCREEN_COLOR_USER);
return stdin_char;
} else {
if(pos > sizeof(buffer)) { return EOF; }
return buffer[pos++];
}
case SYSCALL_COMMAND_PUT:
switch(arg2) {
case STDOUT_FILENO:
screen_put(arg1, SCREEN_COLOR_USER);
break;
case STDERR_FILENO:
//screen_put(arg1, SCREEN_COLOR_ERROR); // XXX: too messy for now
screen_put(arg1, SCREEN_COLOR_USER);
break;
default:
screen_print("SYSCALL_COMMAND_PUT: unsupported fileno\n");
break;
}
break;
default:
screen_print("unrecognized syscall command\n");
break;
}
return 0;
}
void ztats_container_pane_paint(struct ztats_pane *pane)
{
struct ztats_container_pane *zcp = (struct ztats_container_pane*)pane;
SDL_Rect rect = pane->dims;
int top = zcp->top_line;
class Container *container = pane->party->getInventory();
struct inv_entry *ie;
int line = 0;
if (! container) {
screen_print(&rect, 0, "No inventory!");
return;
}
rect.h = ASCII_H;
for (ie = container->first(zcp->filter); ie != NULL; ie = container->next(ie, zcp->filter)) {
if (top) {
top--;
continue;
}
zcp->ops->paint_item(ie, &rect);
line++;
/* Don't print outside the status window. */
if (line >= zcp->num_lines) {
break;
}
}
}
static void foogodPaintSessionInfo()
{
screen_print(&Foogod.turnRect, 0, "Turn: %d", session_get_turn_count());
foogodPaintEffects();
if (player_party) {
screen_print(&Foogod.foodRect, 0, "Food: %d",
player_party->food);
screen_print(&Foogod.goldRect, SP_RIGHTJUSTIFIED, "Gold: %d",
player_party->gold);
if (player_party->getVehicle()) {
screen_print(&Foogod.hullRect, 0, "Hull: %d",
player_party->getVehicle()->getHp());
}
}
}
void task_entry(const char *exe_name) {
__asm__ ("sti");
screen_print("spawned new task\n");
screen_print("loading ");
screen_print(exe_name);
screen_put('\n');
const char *paths[] = {"bin", exe_name};
auto mData = _kernel_state.fs.GetInode(2, paths);
if(mData.IsNothing()) { kernel_panic("failed to get inode"); }
auto data = mData.FromJust();
_kernel_state.pager->Enable(_kernel_state.task->context);
ELF elf(data);
user_enter(elf.entry(), &_kernel_state.task->stack[PAGE_ALLOCATOR_PAGE_SIZE * Task::STACK_PAGES]);
for(;;) { __asm__ ("hlt"); } // unreachable
}
void ztats_container_paint_item_generic(struct inv_entry *ie, SDL_Rect *rect)
{
if (ie->type->getSprite()) {
sprite_paint(ie->type->getSprite(), 0, rect->x, rect->y);
}
/* Indent past the sprite column. */
rect->x += TILE_W;
/* This is a single-line entry in a two-line rect, so center it
* vertically. */
rect->y += TILE_H / 4;
screen_print(rect, 0, "%2d %s", ie->count - ie->ref, ie->type->getName());
/* Carriage-return line-feed */
rect->y += (TILE_H * 3) / 4;
rect->x -= TILE_W;
}
static void foogod_progress_bar_paint()
{
int i;
int ticks;
int max_ticks;
SDL_Rect rect = Foogod.screenRect;
/* title */
rect.h = ASCII_H;
screen_print(&rect, SP_CENTERED, Foogod.progress_bar_title);
/* bar */
rect.y += ASCII_H;
rect.w = ASCII_W;
/* (ticks : maxTicks) = (steps : totalSteps) */
max_ticks = (Foogod.screenRect.w / ASCII_W);
/* Subtract two for the edges pieces of the progress bar. */
max_ticks -= 2;
ticks = (Foogod.progress_bar_steps * max_ticks)
/ Foogod.progress_bar_max_steps;
/* Paint the left edge. */
sprite_paint(Foogod.progress_bar_sprites[0], 0, rect.x, rect.y);
rect.x += ASCII_W;
/* Paint the center. */
for (i = 0; i < ticks; i++) {
sprite_paint(Foogod.progress_bar_sprites[1], 0, rect.x, rect.y);
//screen_print(&rect, 0, ".");
rect.x += ASCII_W;
}
/* Paint the right edge. */
sprite_paint(Foogod.progress_bar_sprites[2], 0, rect.x, rect.y);
}
static void foogod_repaint_title(void)
{
screen_erase(&Foogod.titleRect);
screen_print(&Foogod.titleRect, SP_CENTERED | SP_ONBORDER, "%s", Foogod.title);
screen_update(&Foogod.titleRect);
}
//
// syscall entry point
//
long int syscall(unsigned long int command,...){
int ret;
va_list ap;
ret = 0;
va_start(ap,command);
switch (command) {
// SYS
case SYS_INIT: {
tick_init(); // raw-handler
int_init(); // raw-handler
syscall(SYS_TIMER_INIT);
syscall(SYS_DMA_INIT);
syscall(SYS_VRAM_INIT);
syscall(SYS_SCREEN_INIT);
syscall(SYS_UART_INIT);
ret = 0;
} break;
// TIMER
case SYS_TIMER_INIT: {
timer_init(&timer);
ret = 0;
} break;
case SYS_TIMER_GET_COUNT: {
ret = timer_get_count(&timer);
} break;
// DMA
case SYS_DMA_INIT: {
unsigned long int base;
unsigned long int irq;
base = va_arg(ap,unsigned long int);
irq = va_arg(ap,unsigned long int);
dma.ch = dma_channel;
dma.ch_size = DMA_CH_SIZE;
dma.ch[0].buf = dma_buffer_ch0;
dma.ch[0].buf_size = DMA_BUF_SIZE;
dma_init(&dma,DMA_BASE,DMA_IRQ);
ret = 0;
} break;
case SYS_DMA_ADD: {
unsigned long int ch;
void *src;
void *dst;
unsigned long int size;
ch = va_arg(ap,unsigned long int);
src = va_arg(ap,void *);
dst = va_arg(ap,void *);
size = va_arg(ap,unsigned long int);
dma_add(&dma,ch,src,dst,size);
ret = 0;
} break;
case SYS_DMA_ADD_FULL: {
unsigned long int ch;
ch = va_arg(ap,unsigned long int);
ret = (long int)dma_add_full(&dma,ch);
} break;
case SYS_DMA_GET_HANDLE: {
ret = (long int)&dma;
} break;
case SYS_DMA_GET_CH: {
ret = 0;
} break;
// VRAM
case SYS_VRAM_INIT: {
vram_init(&vram,&dma,0);
ret = 0;
} break;
case SYS_VRAM_CLEAR: {
vram_clear(&vram);
ret = 0;
} break;
case SYS_VRAM_IMAGE_PASTE: {
IMAGE *img;
unsigned long int x;
unsigned long int y;
img = va_arg(ap,IMAGE *);
x = va_arg(ap,unsigned long int);
y = va_arg(ap,unsigned long int);
vram_image_paste(&vram,img,x,y);
ret = 0;
} break;
case SYS_VRAM_IMAGE_PASTE_FILTER: {
IMAGE *img;
unsigned long int x;
unsigned long int y;
img = va_arg(ap,IMAGE *);
x = va_arg(ap,unsigned long int);
y = va_arg(ap,unsigned long int);
vram_image_paste_filter(&vram,img,x,y);
ret = 0;
} break;
case SYS_VRAM_IMAGE_CLEAR: {
IMAGE *img;
unsigned long int x;
unsigned long int y;
img = va_arg(ap,IMAGE *);
x = va_arg(ap,unsigned long int);
y = va_arg(ap,unsigned long int);
vram_image_clear(&vram,img,x,y);
ret = 0;
} break;
// SCREEN
case SYS_SCREEN_INIT: {
screen_init(&scr,&vram);
ret = 0;
} break;
case SYS_SCREEN_CLEAR: {
screen_clear(&scr);
ret = 0;
} break;
case SYS_SCREEN_LOCATE: {
unsigned long int x;
unsigned long int y;
x = va_arg(ap,unsigned long int);
y = va_arg(ap,unsigned long int);
screen_locate(&scr,x,y);
ret = 0;
} break;
case SYS_SCREEN_SCROLL: {
unsigned long int height;
height = va_arg(ap,unsigned long int);
screen_scroll(&scr,height);
ret = 0;
} break;
case SYS_SCREEN_PUT_STRING: {
unsigned char *s;
s = va_arg(ap,unsigned char *);
screen_put_string(&scr,s);
ret = 0;
} break;
case SYS_SCREEN_PUT_CHAR: {
unsigned char c;
c = va_arg(ap,unsigned int); // usigned char
screen_put_char(&scr,c);
ret = 0;
} break;
case SYS_SCREEN_PRINT: {
unsigned char c;
c = va_arg(ap,unsigned int); // unsigned char
screen_print(&scr,c);
ret = 0;
} break;
//case SYS_SCREEN_IMAGE: {
// IMAGE *image;
// image = va_arg(ap,IMAGE *);
// screen_image(&scr,image);
// ret = 0;
//} break;
case SYS_SCREEN_SET_LOCATE_X: {
unsigned long int x;
x = va_arg(ap,unsigned long int);
screen_set_locate_x(&scr,x);
ret = 0;
} break;
case SYS_SCREEN_SET_LOCATE_Y: {
unsigned long int y;
y = va_arg(ap,unsigned long int);
screen_set_locate_y(&scr,y);
ret = 0;
} break;
case SYS_SCREEN_GET_LOCATE_X: {
ret = screen_get_locate_x(&scr);
} break;
case SYS_SCREEN_GET_LOCATE_Y: {
ret = screen_get_locate_y(&scr);
} break;
case SYS_SCREEN_SET_COLOR_FG: {
unsigned long int r,g,b;
r = va_arg(ap,unsigned long int);
g = va_arg(ap,unsigned long int);
b = va_arg(ap,unsigned long int);
screen_set_color_fg(&scr,r,g,b);
ret = 0;
} break;
case SYS_SCREEN_SET_COLOR_BG: {
unsigned long int r,g,b;
r = va_arg(ap,unsigned long int);
g = va_arg(ap,unsigned long int);
b = va_arg(ap,unsigned long int);
screen_set_color_bg(&scr,r,g,b);
ret = 0;
} break;
// UART
case SYS_UART_INIT: {
unsigned long int base;
unsigned long int irq;
base = va_arg(ap,unsigned long int);
irq = va_arg(ap,unsigned long int);
uart.tx.buf = uart_buffer_tx;
uart.tx.buf_size = UART_TX_BUF_SIZE;
uart.rx.buf = uart_buffer_rx;
uart.rx.buf_size = UART_RX_BUF_SIZE;
uart_init(&uart,UART_BASE,UART_IRQ);
ret = 0;
} break;
case SYS_UART_GET: {
ret = (long int)uart_get(&uart);
} break;
case SYS_UART_GET_EXIST: {
ret = (long int)uart_get_exist(&uart);
} break;
case SYS_UART_GET_CLEAR: {
uart_get_clear(&uart);
ret = 0;
} break;
case SYS_UART_PUT: {
unsigned int data;
data = va_arg(ap,unsigned int);
uart_put(&uart,(unsigned char)data);
ret = 0;
} break;
case SYS_UART_PUT_FULL: {
ret = uart_put_full(&uart);
} break;
case SYS_UART_PUT_CLEAR: {
uart_put_clear(&uart);
ret = 0;
} break;
case SYS_UART_PUT_STRING: {
unsigned char *string;
string = va_arg(ap,unsigned char *);
uart_put_string(&uart,string);
ret = 0;
} break;
case SYS_UART_IS_CTS: {
ret = uart_is_cts(&uart);
} break;
case SYS_UART_IS_DSR: {
ret = uart_is_dsr(&uart);
} break;
case SYS_UART_IS_RI: {
ret = uart_is_ri(&uart);
} break;
case SYS_UART_IS_DCD: {
ret = uart_is_dcd(&uart);
} break;
case SYS_UART_DTR: {
unsigned long int data;
data = va_arg(ap,unsigned long int);
uart_dtr(&uart,data);
ret = 0;
} break;
case SYS_UART_RTS: {
unsigned long int data;
data = va_arg(ap,unsigned long int);
uart_rts(&uart,data);
ret = 0;
} break;
}
va_end(ap);
return ret;
}
int main(int argc, char* argv[]) {
struct arguments arguments;
struct board board;
char buffer[256];
int format;
char input;
char* message;
int status; // Game status.
struct termios term_settings;
int valid;
// Parse arguments.
message = arguments_parse(&arguments, argc, argv);
if (message) {
usage_print(message);
}
// Apply arguments.
valid = 1; // Hack; overload to determine whether to play or quit.
if (arguments.flags & ARGUMENTS_VERSION) {
printf("%s\n", VERSION);
valid = 0;
}
if (arguments.flags & ARGUMENTS_LEGAL) {
printf("%s\n", legal);
valid = 0;
}
if (arguments.flags & ARGUMENTS_HELP) {
usage_print(NULL);
}
if (!valid) {
exit(EXIT_SUCCESS);
}
if (arguments.flags & ARGUMENTS_MODE) {
if (arguments.mode == mode_format) {
setup_signal_handlers();
enter_alternate_buffer();
enter_format_mode(&term_settings);
format = 1;
} else if (arguments.mode == mode_plain) {
format = 0;
}
} else if (isatty(STDOUT_FILENO) && isatty(STDIN_FILENO)) {
setup_signal_handlers();
enter_alternate_buffer();
enter_format_mode(&term_settings);
format = 1;
}
if (arguments.flags & ARGUMENTS_SEED) {
srand(arguments.seed);
} else {
srand(time(NULL));
}
// Set up the board.
board_init(&board);
if (!format) {
fputs(legal, stdout);
}
// Play the game.
play:
valid = 1;
while (!(status = board_done(&board))) {
// Set up screen for next move.
// Sorry about this ugly call.
screen_print(&board, valid ? (format ? "\n\n" : "") :
"\nInvalid move.\n", format);
// Get the player's move.
input = yoink(format);
// Process player's move.
if (input == 'w' || input == 'k') {
valid = board_move_up(&board);
} else if (input == 's' || input == 'j') {
valid = board_move_down(&board);
} else if (input == 'a' || input == 'h') {
valid = board_move_left(&board);
} else if (input == 'd' || input == 'l') {
valid = board_move_right(&board);
} else if (input == 'n') {
// Start a new game (or not) based on user input.
printf("Start a new game? [y/N] ");
input = yoink(format);
if (input == 'y' || input == 'Y') {
board_reset(&board);
}
continue;
} else if (input == '?') {
help_print();
if (format) {
printf("\nPress any key to continue.");
input = yoink(format);
}
continue;
} else {
valid = 0;
}
// End player's move.
if (valid) {
board_plop(&board);
}
}
// Print the final board.
snprintf(buffer, sizeof(buffer),
"\nGame over, you %s!\n\nPlay again? [y/n]\n",
(status < 0) ? "LOSE" : "WIN");
screen_print(&board, buffer, format);
// Check for new game.
while ((input = yoink(format)) != 'y' && input != 'Y' &&
input != 'n' && input != 'N') {
screen_print(&board, buffer, format);
}
if (input == 'y' || input == 'Y') {
board_reset(&board);
goto play;
}
// Restore the terminal.
if (format) {
restore_mode();
leave_alternate_buffer();
}
// Free the board.
board_free(&board);
// Return success.
return EXIT_SUCCESS;
}
