int main(void) {
buffer_t buf = buf_new(1);
screen_t fake, real;
int rows = 20, cols = 20;
//read_dimensions(&rows, &cols);
fake_screen_init(&fake, rows, cols);
real_screen_init(&buf, &real, rows, cols);
struct timespec req = {.tv_sec = 0, .tv_nsec = 100000000};
struct timespec rem;
int x, y;
double cx = rows / 2.0,
cy = cols / 2.0;
double maxradius = sqrt(pow(cx, 2) + pow(cy, 2));
int t = 0;
while (t < 50) {
for (x = 0; x < cols; x++) {
for (y = 0; y < rows; y++) {
int i = x + y*cols;
int shade = 128 + 128*sin(t + sqrt(pow(x - cx, 2) + pow(y - cy, 2)));
if (shade > 255) {
shade = 255;
}
fake.cells[i].style.back.r = shade;
fake.cells[i].style.back.g = shade;
fake.cells[i].style.back.b = shade;
}
}
screen_flush(&buf, &fake, &real);
write(STDOUT_FILENO, buf.data, buf.used);
buf.used = 0;
fake_screen_reset(&fake, rows, cols);
t++;
nanosleep(&req, &rem);
}
real_screen_cleanup(&buf, &real);
write(STDOUT_FILENO, buf.data, buf.used);
screen_free(&fake);
screen_free(&real);
buf_free(&buf);
}
void
window_clock_free(struct window_pane *wp)
{
struct window_clock_mode_data *data = wp->modedata;
screen_free(&data->screen);
free(data);
}
void
window_copy_search_down(struct window_pane *wp, const char *searchstr)
{
struct window_copy_mode_data *data = wp->modedata;
struct screen *s = &wp->base, ss;
struct screen_write_ctx ctx;
struct grid *gd = s->grid, *sgd;
struct grid_cell gc;
size_t searchlen;
u_int i, first, fx, fy, px;
int utf8flag, n, wrapped;
if (*searchstr == '\0')
return;
utf8flag = options_get_number(&wp->window->options, "utf8");
searchlen = screen_write_strlen(utf8flag, "%s", searchstr);
screen_init(&ss, searchlen, 1, 0);
screen_write_start(&ctx, NULL, &ss);
memcpy(&gc, &grid_default_cell, sizeof gc);
screen_write_nputs(&ctx, -1, &gc, utf8flag, "%s", searchstr);
screen_write_stop(&ctx);
fx = data->cx;
fy = gd->hsize - data->oy + data->cy;
if (fx == gd->sx - 1) {
if (fy == gd->hsize + gd->sy)
return;
fx = 0;
fy++;
} else
fx++;
n = wrapped = 0;
retry:
sgd = ss.grid;
for (i = fy + 1; i < gd->hsize + gd->sy; i++) {
first = 0;
if (i == fy + 1)
first = fx;
n = window_copy_search_lr(gd, sgd, &px, i - 1, first, gd->sx);
if (n) {
window_copy_scroll_to(wp, px, i - 1);
break;
}
}
if (!n && !wrapped) {
fx = 0;
fy = 0;
wrapped = 1;
goto retry;
}
screen_free(&ss);
}
void
window_copy_free(struct window_pane *wp)
{
struct window_copy_mode_data *data = wp->modedata;
if (wp->fd != -1)
bufferevent_enable(wp->event, EV_READ|EV_WRITE);
if (data->searchstr != NULL)
xfree(data->searchstr);
xfree(data->inputstr);
if (data->backing != &wp->base) {
screen_free(data->backing);
xfree(data->backing);
}
screen_free(&data->screen);
xfree(data);
}
void
window_more_free(struct window_pane *wp)
{
struct window_more_mode_data *data = wp->modedata;
u_int i;
for (i = 0; i < ARRAY_LENGTH(&data->list); i++)
xfree(ARRAY_ITEM(&data->list, i));
ARRAY_FREE(&data->list);
screen_free(&data->screen);
xfree(data);
}
static void errorscreen_free(ErrorScreen *error) {
if (error == NULL)
return;
button_free(error->quit);
text_osd_free(error->message);
rect_osd_free(error->background);
screen_free(error->screen);
g_free(error);
}
void
window_copy_free(struct window_pane *wp)
{
struct window_copy_mode_data *data = wp->modedata;
wp->flags &= ~PANE_FREEZE;
bufferevent_enable(wp->event, EV_READ|EV_WRITE);
if (data->searchstr != NULL)
xfree(data->searchstr);
xfree(data->inputstr);
screen_free(&data->screen);
xfree(data);
}
int main(int argc, char** argv)
{
auint j;
auint t;
auint cdi = 0U;
auint auc = 0U;
uint16* lpt;
uint16* rpt;
uint16 edt; /* Event data (just one) */
auint mid; /* Mouse device id */
SDL_Event event; /* The event got from the queue */
rrpge_object_t* emu = NULL;
/* Init message */
printf("\n");
printf("%s", main_appname);
printf("\n\n");
printf("%s", main_appauth);
printf("%s", main_copyrig);
printf("\n");
/* Check arguments: need an application */
if (argc <= 1){
printf("Error: need an application to run as parameter!\n");
exit(1);
}else{
printf("Opening %s...\n", argv[1]);
main_app = fopen(argv[1], "rb");
if (main_app == NULL){
perror("Failed to open file");
exit(1);
}
}
/* Initialize emulator library */
rrpge_init_lib(&main_malloc, &free);
/* Attempt to initialize the emulator. Note that the app. binary load
** callback is blocking, so no need to implement any waiting here using
** rrpge_init_run(). */
emu = rrpge_new_emu(&main_cbpack);
if (emu == NULL){
printf("Failed to allocate emulator state\n");
goto loadfault;
}
t = rrpge_init_run(emu, RRPGE_INI_RESET);
if (t != RRPGE_ERR_OK){
printf("Failed to initialize emulator\n");
main_printrerr(t);
goto loadfault;
}
mid = rrpge_dev_add(emu, RRPGE_DEV_POINT); /* Add mouse (pointing device) */
/* Initialize renderer */
render_reset(emu);
/* Initialize SDL */
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO)!=0) return -1;
/* Try to set up the screen */
if (screen_set()!=0) return -1;
SDL_WM_SetCaption(main_appname, main_appicon);
/* Set up audio */
if (audio_set(2048U) != 0U) return -1;
/* OK, let's go! */
printf("Entering emulation\n");
/* The main loop: It is more straightforward to exit from it with a suitable
** break at the proper place */
while(1){
/* Wait for some event... */
if (SDL_WaitEvent(&event)==0) return -1; /*Error?*/
/* An event is here: do something about it! */
if (event.type==SDL_USEREVENT){
if (event.user.code==AUDIO_EVENT){
t = 0U; /* No halt */
while (audio_needservice()){ /* Waiting for audio data from emulator */
do{
j = rrpge_run(emu, RRPGE_RUN_FREE);
t = rrpge_gethaltcause(emu);
if (t & RRPGE_HLT_AUDIO){ cdi++; }
if (cdi >= 10){
cdi = 0U;
printf("Audio events: %08d\n", auc);
printf("Cycles: %08d\n", j);
main_printstats(emu);
main_printhalt(t);
}
/* Need proper exit point... */
}while ((t & (RRPGE_HLT_AUDIO |
RRPGE_HLT_EXIT |
RRPGE_HLT_STACK |
RRPGE_HLT_INVKCALL |
RRPGE_HLT_INVOP |
RRPGE_HLT_FAULT |
RRPGE_HLT_DETACHED |
RRPGE_HLT_WAIT)) == 0U);
if ((t & RRPGE_HLT_AUDIO) != 0U){ /* Audio data produced by emulator */
audio_getbufptrs(&lpt, &rpt);
rrpge_getaudio(emu, lpt, rpt);
auc++;
}
if ((t & (RRPGE_HLT_EXIT |
RRPGE_HLT_STACK |
RRPGE_HLT_INVKCALL |
RRPGE_HLT_INVOP |
RRPGE_HLT_FAULT |
RRPGE_HLT_DETACHED |
RRPGE_HLT_WAIT)) != 0U){ /* Errors & Exit */
break;
}
} /* End of audio wait loop */
if ((t & RRPGE_HLT_EXIT) != 0U){ break; } /* Exit program */
if ((t & (RRPGE_HLT_STACK |
RRPGE_HLT_INVKCALL |
RRPGE_HLT_INVOP |
RRPGE_HLT_FAULT |
RRPGE_HLT_DETACHED |
RRPGE_HLT_WAIT)) != 0U){
main_errexit(t, emu);
break; /* Also exit, with error */
}
}
}else if (event.type==SDL_KEYDOWN){
/* Some key was pressed. Which? */
if (event.key.keysym.sym==SDLK_ESCAPE) break; /* Exit program */
}else if (event.type==SDL_KEYUP){
}else if (event.type==SDL_QUIT){ /* Exit program */
break;
}else if (event.type==SDL_MOUSEBUTTONDOWN){
edt = (uint16)(event.button.x);
rrpge_dev_push(emu, mid, 2U, 1U, &edt);
edt = (uint16)(event.button.y);
rrpge_dev_push(emu, mid, 3U, 1U, &edt);
if (event.button.button == SDL_BUTTON_LEFT){ edt = 1U; rrpge_dev_push(emu, mid, 0U, 1U, &edt); }
else if (event.button.button == SDL_BUTTON_RIGHT){ edt = 2U; rrpge_dev_push(emu, mid, 0U, 1U, &edt); }
else if (event.button.button == SDL_BUTTON_MIDDLE){ edt = 3U; rrpge_dev_push(emu, mid, 0U, 1U, &edt); }
else {}
}else if (event.type==SDL_MOUSEBUTTONUP){
edt = (uint16)(event.button.x);
rrpge_dev_push(emu, mid, 2U, 1U, &edt);
edt = (uint16)(event.button.y);
rrpge_dev_push(emu, mid, 3U, 1U, &edt);
if (event.button.button == SDL_BUTTON_LEFT){ edt = 1U; rrpge_dev_push(emu, mid, 1U, 1U, &edt); }
else if (event.button.button == SDL_BUTTON_RIGHT){ edt = 2U; rrpge_dev_push(emu, mid, 1U, 1U, &edt); }
else if (event.button.button == SDL_BUTTON_MIDDLE){ edt = 3U; rrpge_dev_push(emu, mid, 1U, 1U, &edt); }
else {}
}else if (event.type==SDL_MOUSEMOTION){
edt = (uint16)(event.motion.x);
rrpge_dev_push(emu, mid, 2U, 1U, &edt);
edt = (uint16)(event.motion.y);
rrpge_dev_push(emu, mid, 3U, 1U, &edt);
}
}
printf("Trying to exit\n");
rrpge_delete(emu);
audio_free();
screen_free();
SDL_Quit();
fclose(main_app);
exit(0);
loadfault:
if (emu != NULL) free(emu);
fclose(main_app);
exit(1);
}
int main(void){
int input;
int width, height;
struct sigaction sa;
sa.sa_handler = &signalCatch;
sa.sa_flags = 0;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGQUIT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
screen_init();
get_screen_size(&width, &height);
srand((unsigned int)time(NULL));
init_map();
player.x = 1;
player.y = 1;
player.ele = 0;
player.type = CREA_EARTH_PONY;
player.inv = 0;
player.health = 1;
SQUARE(get_tile(0,0,0)->tile.sq, 1,1)->c = &player;
struct item* spikes = malloc(sizeof(struct item));
spikes->type = ITEM_HOOF_SPIKES;
struct itemlist* a_list = malloc(sizeof(struct itemlist));
a_list->item = spikes;
a_list->next = 0;
SQUARE(get_tile(0,0,0)->tile.sq, 4,2)->i = a_list;
struct creature *earth_pony = malloc(sizeof(struct creature));
earth_pony->type = 0;
earth_pony->health = 5; /* test value */
earth_pony->dex = 5;
SQUARE(get_tile(0,0,0)->tile.sq, 3,3)->c = earth_pony;
draw_map(1,1,0);
while(1){
input = getchar();
switch(input){
case 'h':
move_player(W);
break;
case 'j':
move_player(S);
break;
case 'k':
move_player(N);
break;
case 'l':
move_player(E);
break;
case 'y':
move_player(NW);
break;
case 'u':
move_player(NE);
break;
case 'n':
move_player(SE);
break;
case 'b':
move_player(SW);
break;
case ',':
pick_up();
break;
case 'q':
screen_free();
return 0;
}
}
}
void signalCatch(int s){
if(s){
screen_free();
exit(0);
}
}
int main(int argc, char *argv[])
{
char input = 0;
char save_name[50];
//Prepare engine
Engine *engine = prepare_game(save_name);
GoF_Screen *screen = screen_create(0, 0, 30, 30, 20);
Graphics g;
graphics_init(&g, 800, 900, "The Game of Life!");
input = 0;
while(input != 'k')
{
screen_draw(screen, &g, engine);
input = graphics_event(&g);
if(input == 1)
engine_add_entity(engine, entity_create(g.last_x/screen->entity_length, g.last_y/screen->entity_length));
else if(input == 3)
engine_remove_entity(engine, g.last_x/screen->entity_length, g.last_y/screen->entity_length);
}
//Input
input = 0;
int sens = 5;
//Main game loop
while(input != 'q')
{
//Draw on screen
screen_draw(screen, &g, engine);
//Update Engine
engine_update(engine);
//Process input
while(graphics_check_event(&g))
{
input = graphics_event(&g);
switch(input)
{
case 'p':
engine->ups++;
break;
case 'm':
if(engine->ups > 1)
engine->ups--;
break;
case '.':
sens++;
break;
case ',':
if(sens > 1)
sens--;
break;
case UP_ARROW:
screen->y -= sens;
break;
case DOWN_ARROW:
screen->y += sens;
break;
case LEFT_ARROW:
screen->x -= sens;
break;
case RIGHT_ARROW:
screen->x += sens;
break;
}
}
//Sleep
usleep((1000/engine->ups) * 1000);
}
//Close graphics
graphics_close(&g);
//Save game
printf("Saving game...\n");
engine_save(engine, save_name);
//Free mem
engine_free(engine);
screen_free(screen);
return 0;
}
int main(void) {
buffer_t buf = buf_new(1);
screen_t fake, real;
int rows, cols;
read_dimensions(&rows, &cols);
fake_screen_init(&fake, rows, cols);
real_screen_init(&buf, &real, rows, cols);
prepare_events();
int x = 0,
y = 0;
char text[cols*rows];
bool marks[cols*rows];
memset(text, ' ', sizeof text);
memset(marks, 0, sizeof marks);
await: {
event_t e = await_event();
switch (e.type) {
case E_SIG:
goto quit;
break;
case E_KEY:
switch (e.key) {
case '\b':
if (x > 0) x -= 1;
break;
case '\n': x = 0; y += 1; break;
case '~':
marks[x + y*cols] = !marks[x + y*cols];
x++;
break;
default:
text[x + y*cols] = e.key;
x++;
break;
}
break;
case E_UP: y -= 1; break;
case E_DOWN: y += 1; break;
case E_LEFT: x -= 1; break;
case E_RIGHT: x += 1; break;
default:
break;
}
int cx, cy;
for (cx = 0; cx < cols; cx++) {
for (cy = 0; cy < rows; cy++) {
fake.cells[cx + cy*cols].codes[0] = text[cx + cy*cols];
}
}
int j;
for (j = 0; j < cols*rows; j++) {
if (marks[j]) {
fake.cells[j].style.back.rgb = 0xff0000;
}
}
fake.cursor.x = x;
fake.cursor.y = y;
fake.cursor.visible = true;
screen_flush(&buf, &fake, &real);
write(STDOUT_FILENO, buf.data, buf.used);
buf.used = 0;
fake_screen_reset(&fake, 25, 80);
goto await;
}
quit:
cleanup_events();
real_screen_cleanup(&buf, &real);
write(STDOUT_FILENO, buf.data, buf.used);
screen_free(&fake);
screen_free(&real);
buf_free(&buf);
return 0;
}
