int main(void){
// Game Ticks to manage FPS (This code is Windows only )
int next_game_tick = GetTickCount();
int sleep time = 0;
int game_is_running = 1;
start_game(); //system_func.h?
while ( game_is_running = 1 ) { // Basic Game Loop
handle_input();
update_game();
draw_screen();
next_game_tick += SKIP_TICKS;
// Determine Sleep time (windows function!)
sleep_time = next_game_tick - GetTickCount();
if( sleep_time >= 0 )
Sleep( sleep_time );
if( terminal_read() == TK_CLOSE) {
// Some sort of Save/clean escape function?
terminal_close();
printf("\n Clean Exit. \n");
return 0;
}
}
}
/**
* Get raw byte from stdin.
* @return next byte from stdin
*/
static int get_raw_ch(void)
{
if (input_buffer.cur >= input_buffer.size) {
int fd = 0, ret;
struct timeval tv = { .tv_sec = 0, .tv_usec = 0 };
while (1) {
fd_set rset;
FD_ZERO(&rset);
FD_SET(STDIN_FILENO, &rset);
int nfds = 1;
if (fd > 0) {
FD_SET(fd, &rset);
nfds = fd + 1;
}
ret = select(nfds, &rset, NULL, NULL, &tv);
if (FD_ISSET(STDIN_FILENO, &rset)) {
#ifdef ENABLE_SSH
ret = channel_poll(ssh_chan, 0);
#endif
}
if (_schedule_exit || (ret < 0 && errno != EINTR))
abort_bbs(0);
if (ret <= 0) {
screen_flush();
} else {
if (fd > 0 && FD_ISSET(fd, &rset)) {
// TODO: handle notification
}
if (FD_ISSET(STDIN_FILENO, &rset)) {
session_set_idle_cached();
break;
}
}
tv.tv_sec = IDLE_TIMEOUT;
tv.tv_usec = 0;
}
while (1) {
ret = terminal_read(input_buffer.ptr, sizeof(input_buffer.ptr));
if (ret > 0)
break;
if (ret < 0 && (errno == EINTR))
continue;
abort_bbs(0);
}
input_buffer.cur = 0;
input_buffer.size = ret;
}
return input_buffer.ptr[input_buffer.cur++];
}
/* Check if MAGIC is valid and print the Multiboot information structure
pointed by ADDR. */
void
entry (unsigned long magic, unsigned long addr)
{
uint32_t fileptr;// start of file system
multiboot_info_t *mbi;
/* Initialize the screen. */
terminal_open();
/* Am I booted by a Multiboot-compliant boot loader? */
if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
{
printf ("Invalid magic number: 0x%#x\n", (unsigned) magic);
return;
}
/* Set MBI to the address of the Multiboot information structure. */
mbi = (multiboot_info_t *) addr;
/* Print out the flags. */
printf ("flags = 0x%#x\n", (unsigned) mbi->flags);
/* Are mem_* valid? */
if (CHECK_FLAG (mbi->flags, 0))
printf ("mem_lower = %uKB, mem_upper = %uKB\n",
(unsigned) mbi->mem_lower, (unsigned) mbi->mem_upper);
/* Is boot_device valid? */
if (CHECK_FLAG (mbi->flags, 1))
printf ("boot_device = 0x%#x\n", (unsigned) mbi->boot_device);
/* Is the command line passed? */
if (CHECK_FLAG (mbi->flags, 2))
printf ("cmdline = %s\n", (char *) mbi->cmdline);
if (CHECK_FLAG (mbi->flags, 3)) {
int mod_count = 0;
int i;
module_t* mod = (module_t*)mbi->mods_addr;
fileptr = mod->mod_start;
while(mod_count < mbi->mods_count) {
printf("Module %d loaded at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_start);
printf("Module %d ends at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_end);
printf("First few bytes of module:\n");
for(i = 0; i<16; i++) {
printf("0x%x ", *((char*)(mod->mod_start+i)));
}
printf("\n");
mod_count++;
}
}
/* Bits 4 and 5 are mutually exclusive! */
if (CHECK_FLAG (mbi->flags, 4) && CHECK_FLAG (mbi->flags, 5))
{
printf ("Both bits 4 and 5 are set.\n");
return;
}
/* Is the section header table of ELF valid? */
if (CHECK_FLAG (mbi->flags, 5))
{
elf_section_header_table_t *elf_sec = &(mbi->elf_sec);
printf ("elf_sec: num = %u, size = 0x%#x,"
" addr = 0x%#x, shndx = 0x%#x\n",
(unsigned) elf_sec->num, (unsigned) elf_sec->size,
(unsigned) elf_sec->addr, (unsigned) elf_sec->shndx);
}
/* Are mmap_* valid? */
if (CHECK_FLAG (mbi->flags, 6))
{
memory_map_t *mmap;
printf ("mmap_addr = 0x%#x, mmap_length = 0x%x\n",
(unsigned) mbi->mmap_addr, (unsigned) mbi->mmap_length);
for (mmap = (memory_map_t *) mbi->mmap_addr;
(unsigned long) mmap < mbi->mmap_addr + mbi->mmap_length;
mmap = (memory_map_t *) ((unsigned long) mmap
+ mmap->size + sizeof (mmap->size)))
printf (" size = 0x%x, base_addr = 0x%#x%#x\n"
" type = 0x%x, length = 0x%#x%#x\n",
(unsigned) mmap->size,
(unsigned) mmap->base_addr_high,
(unsigned) mmap->base_addr_low,
(unsigned) mmap->type,
(unsigned) mmap->length_high,
(unsigned) mmap->length_low);
}
/* Construct an LDT entry in the GDT */
{
seg_desc_t the_ldt_desc;
the_ldt_desc.granularity = 0;
the_ldt_desc.opsize = 1;
the_ldt_desc.reserved = 0;
the_ldt_desc.avail = 0;
the_ldt_desc.present = 1;
the_ldt_desc.dpl = 0x0;
the_ldt_desc.sys = 0;
the_ldt_desc.type = 0x2;
SET_LDT_PARAMS(the_ldt_desc, &ldt, ldt_size);
ldt_desc_ptr = the_ldt_desc;
lldt(KERNEL_LDT);
}
/* Construct a TSS entry in the GDT */
{
seg_desc_t the_tss_desc;
the_tss_desc.granularity = 0;
the_tss_desc.opsize = 0;
the_tss_desc.reserved = 0;
the_tss_desc.avail = 0;
the_tss_desc.seg_lim_19_16 = TSS_SIZE & 0x000F0000;
the_tss_desc.present = 1;
the_tss_desc.dpl = 0x0;
the_tss_desc.sys = 0;
the_tss_desc.type = 0x9;
the_tss_desc.seg_lim_15_00 = TSS_SIZE & 0x0000FFFF;
SET_TSS_PARAMS(the_tss_desc, &tss, tss_size);
tss_desc_ptr = the_tss_desc;
tss.ldt_segment_selector = KERNEL_LDT;
tss.ss0 = KERNEL_DS;
tss.esp0 = 0x800000;
ltr(KERNEL_TSS);
}
/* Mask all IRQs again*/
int j;
for(j=0;j<16;j++)
{
disable_irq(j);
}
/* Init the PIC */
i8259_init();
/* Init IDT vector 0-20*/
{
int i;
for(i=0;i<20;i++)
{
if(i!=15)
{
//Define an idt_desc_t structure
idt_desc_t idt_desc;
//populate w/ correct values
idt_desc.seg_selector=0x0010;
idt_desc.present=1;
idt_desc.size=1;
idt_desc.dpl=0x0;
idt_desc.reserved1=1;
idt_desc.reserved2=1;
idt_desc.reserved3=1;
SET_IDT_ENTRY(idt_desc, ehandlers[i]);
//Set new entry in table
idt[i]=idt_desc;
}
}
}
/* Init IRQ Interrupts*/
//Timer Chip
{
//Define an idt_desc_t structure
idt_desc_t idt_desc;
//populate w/ correct values
idt_desc.seg_selector=0x0010;
idt_desc.present=1;
idt_desc.size=1;
idt_desc.dpl=0x0;
idt_desc.reserved1=1;
idt_desc.reserved2=1;
SET_IDT_ENTRY(idt_desc, irqhandlers[0]);
//Set new entry in table
idt[32]=idt_desc;
//Disable IRQ masking
//enable_irq(0);
}
//Keyboard
{
//Define an idt_desc_t structure
idt_desc_t idt_desc;
//populate w/ correct values
idt_desc.seg_selector=0x0010;
idt_desc.present=1;
idt_desc.size=1;
idt_desc.dpl=0x0;
idt_desc.reserved1=1;
idt_desc.reserved2=1;
SET_IDT_ENTRY(idt_desc, irqhandlers[1]);
//Set new entry in table
idt[33]=idt_desc;
//Disable IRQ masking
//enable_irq(1);
}
//Real Time Clock
{
//Define an idt_desc_t structure
idt_desc_t idt_desc;
//populate w/ correct values
idt_desc.seg_selector=0x0010;
idt_desc.present=1;
idt_desc.size=1;
idt_desc.dpl=0x0;
idt_desc.reserved1=1;
idt_desc.reserved2=1;
SET_IDT_ENTRY(idt_desc, irqhandlers[2]);
//Set new entry in table
idt[40]=idt_desc;
//Disable IRQ masking
//enable_irq(8);
}
/* Init System Call 0x80 */
//Define an idt_desc_t structure
idt_desc_t idt_desc;
//populate w/ correct values
idt_desc.seg_selector=0x0010;
idt_desc.present=1;
idt_desc.size=1;
idt_desc.dpl=0x0;
idt_desc.reserved1=1;
idt_desc.reserved2=1;
SET_IDT_ENTRY(idt_desc, systemcall);
//Set new entry in table
idt[128]=idt_desc;
//Load new IDT
lidt(idt_desc_ptr);
/* Initialize devices, memory, filesystem, enable device interrupts on the
* PIC, any other initialization stuff... */
paging_init();
//Enable IRQ interrupts.
enable_irq(8);
enable_irq(2);
enable_irq(1);
/* Enable interrupts */
/* Do not enable the following until after you have set up your
* IDT correctly otherwise QEMU will triple fault and simple close
* without showing you any output */
printf("Enabling Interrupts\n");
sti();
/* This will be replaced by a system call after CP3 */
rtc_open();
filesys_init(fileptr); // start of filesystem
while(1)
{
printf("Reading-> ");
uint8_t buf[1024];
int cnt = terminal_read(buf, 1024);
buf[cnt] = '\0';
puts ((int8_t*)"Typed: ");
puts ((int8_t*)buf);
putc('\n');
}
/* Execute the first program (`shell') ... */
/* Spin (nicely, so we don't chew up cycles) */
asm volatile(".1: hlt; jmp .1;");
}
void TestExtendedInterlayer()
{
// Setup
terminal_set("window.title='Omni: extended output / interlayer animation'");
terminal_composition(TK_ON);
int map_left = terminal_state(TK_WIDTH)/2 - map_width/2;
int map_top = terminal_state(TK_HEIGHT)/2 - map_height/2;
std::srand(std::time(nullptr));
auto map = PrepareMap();
PlaceFoe();
auto Attack = [&]
{
int damage = 1+std::rand()%10;
foe_hp -= damage;
int x = foe_x, y = foe_y;
if (foe_hp <= 0)
{
map[foe_y*map_width+foe_x] = 1;
PlaceFoe();
terminal_clear();
DrawMap(map_left, map_top, map);
}
AnimateDamage(map_left+x, map_top+y, -damage);
};
auto Step = [&](int dx, int dy)
{
if (player_x+dx == foe_x && player_y+dy == foe_y)
{
Attack();
}
else if (map[(player_y+dy)*map_width+player_x+dx] <= 1)
{
player_x += dx;
player_y += dy;
}
};
for (bool proceed=true; proceed;)
{
terminal_clear();
DrawMap(map_left, map_top, map);
terminal_refresh();
do
{
int key = terminal_read();
if (key == TK_CLOSE || key == TK_ESCAPE)
{
proceed = false;
}
else if (key == TK_LEFT)
{
Step(-1, 0);
}
else if (key == TK_UP)
{
Step(0, -1);
}
else if (key == TK_RIGHT)
{
Step(1, 0);
}
else if (key == TK_DOWN)
{
Step(0, 1);
}
}
while (proceed && terminal_has_input());
}
// Clean up
terminal_composition(TK_OFF);
terminal_clear();
terminal_layer(0);
}
void TestTilesets()
{
terminal_set("window.title='Omni: tilesets'");
terminal_composition(TK_ON);
// Load tilesets
terminal_set("U+E100: ../Media/Runic.png, size=8x16");
terminal_set("U+E200: ../Media/Tiles.png, size=32x32, align=top-left");
terminal_set("U+E300: ../Media/fontawesome-webfont.ttf, size=24x24, spacing=3x2, codepage=../Media/fontawesome-codepage.txt");
terminal_set("zodiac font: ../Media/Zodiac-S.ttf, size=24x36, spacing=3x3, codepage=437");
terminal_clear();
terminal_color("white");
terminal_print(2, 1, "[color=orange]1.[/color] Of course, there is default font tileset.");
terminal_print(2, 3, "[color=orange]2.[/color] You can load some arbitrary tiles and use them as glyphs:");
terminal_print
(
2+3, 4,
"Fire rune ([color=red][U+E102][/color]), "
"water rune ([color=lighter blue][U+E103][/color]), "
"earth rune ([color=darker green][U+E104][/color])"
);
terminal_print(2, 6, "[color=orange]3.[/color] Tiles are not required to be of the same size as font symbols:");
terminal_put(2+3+0, 7, 0xE200+7);
terminal_put(2+3+5, 7, 0xE200+8);
terminal_put(2+3+10, 7, 0xE200+9);
terminal_print(2, 10, "[color=orange]4.[/color] Like font characters, tiles may be freely colored and combined:");
terminal_put(2+3+0, 11, 0xE200+8);
terminal_color("lighter orange");
terminal_put(2+3+5, 11, 0xE200+8);
terminal_color("orange");
terminal_put(2+3+10, 11, 0xE200+8);
terminal_color("dark orange");
terminal_put(2+3+15, 11, 0xE200+8);
terminal_color("white");
std::vector<int> order = {11, 10, 14, 12, 13};
for (int i=0; i<order.size(); i++)
{
terminal_put(2+3+25+i*4, 11, 0xE200+order[i]);
terminal_put(2+3+25+(order.size()+1)*4, 11, 0xE200+order[i]);
}
terminal_put(2+3+25+order.size()*4, 11, 0xE200+15);
terminal_print(2, 14, "[color=orange]5.[/color] And tiles can even come from TrueType fonts like this:");
for (int i=0; i<6; i++)
{
terminal_put(2+3+i*5, 15, 0xE300+i);
}
terminal_print(2+3, 18, "...or like this:\n[font=zodiac]D F G S C");
terminal_refresh();
for (int key=0; key!=TK_CLOSE && key!=TK_ESCAPE; key=terminal_read());
// Clean up
terminal_set("U+E100: none; U+E200: none; U+E300: none; zodiac font: none");
terminal_composition(TK_OFF);
}
string cql_ccm_bridge_t::terminal_read_stderr() {
return terminal_read(_esc_remover_stderr, SSH_STDERR);
}
string cql_ccm_bridge_t::terminal_read_stdout() {
return terminal_read(_esc_remover_stdout, SSH_STDOUT);
}
//XXX: flags are ignored...
int vfsfd_open(const char *pathname, int flags)
{
vfs_handle_t vh;
errval_t err;
char *path = vfs_path_mkabs(pathname);
assert(path != NULL);
// If O_CREAT was given, we use vfs_create()
if(flags & O_CREAT) {
// If O_EXCL was also given, we check whether we can open() first
if(flags & O_EXCL) {
err = vfs_open(path, &vh);
if(err_is_ok(err)) {
vfs_close(vh);
errno = EEXIST;
return -1;
}
assert(err_no(err) == FS_ERR_NOTFOUND);
}
err = vfs_create(path, &vh);
} else {
// Regular open()
err = vfs_open(path, &vh);
}
free(path);
if (err_is_fail(err)) {
VFSFD_DEBUG("open('%s') failed\n", pathname);
switch(err_no(err)) {
case FS_ERR_NOTFOUND:
errno = ENOENT;
break;
default:
#ifdef VFSFD_DEBUG_ENABLED
DEBUG_ERR(err, "vfs_open");
#endif
break;
}
return -1;
}
struct fdtab_entry e = {
.type = FDTAB_TYPE_FILE,
.handle = vh,
.epoll_fd = -1,
};
int fd = fdtab_alloc(&e);
VFSFD_DEBUG("open(%s) as fd %d\n", pathname, fd);
if (fd < 0) {
vfs_close(vh);
return -1;
} else {
return fd;
}
}
int vfsfd_read(int fd, void *buf, size_t len)
{
struct fdtab_entry *e = fdtab_get(fd);
size_t retlen = 0;
switch(e->type) {
case FDTAB_TYPE_FILE:
{
errval_t err = vfs_read((vfs_handle_t)e->handle, buf, len, &retlen);
VFSFD_DEBUG("%d : read(%d, %d) = %lu\n", disp_get_domain_id(), fd, len, retlen);
if (err_is_fail(err)) {
DEBUG_ERR(err, "error in vfs_read");
return -1;
}
}
break;
case FDTAB_TYPE_STDIN:
retlen = terminal_read((char *)buf, len);
break;
case FDTAB_TYPE_STDOUT:
case FDTAB_TYPE_STDERR:
case FDTAB_TYPE_AVAILABLE:
default:
return -1;
}
return retlen;
}
int vfsfd_write(int fd, const void *buf, size_t len)
{
struct fdtab_entry *e = fdtab_get(fd);
if (e->type == FDTAB_TYPE_AVAILABLE) {
return -1;
}
size_t retlen = 0;
switch(e->type) {
case FDTAB_TYPE_FILE:
{
errval_t err = vfs_write((vfs_handle_t)e->handle, buf, len, &retlen);
VFSFD_DEBUG("write(%d, %d) = %lu\n", fd, len, retlen);
if (err_is_fail(err)) {
DEBUG_ERR(err, "error in vfs_write");
return -1;
}
}
break;
case FDTAB_TYPE_STDOUT:
/* only support writting to terminal */
retlen = terminal_write((const char*) buf, len);
break;
case FDTAB_TYPE_STDERR:
retlen = terminal_write((const char*) buf, len);
break;
case FDTAB_TYPE_STDIN:
case FDTAB_TYPE_AVAILABLE:
default:
return -1;
}
return retlen;
}
int vfsfd_close(int fd)
{
errval_t err;
struct fdtab_entry *e = fdtab_get(fd);
if (e->type == FDTAB_TYPE_AVAILABLE) {
return -1;
}
VFSFD_DEBUG("close(%d)\n", fd);
switch(e->type) {
case FDTAB_TYPE_FILE:
err = vfs_close((vfs_handle_t)e->handle);
if (err_is_fail(err)) {
DEBUG_ERR(err, "error in vfs_close");
return -1;
}
break;
case FDTAB_TYPE_STDIN:
case FDTAB_TYPE_STDOUT:
case FDTAB_TYPE_STDERR:
// XXX: Should call fclose() when closing last FD
break;
default:
return -1;
} // end switch
fdtab_free(fd);
return 0;
}
