nestedvm.c

   1 /*
   2  * nestedvm.c: NestedVM front end for my puzzle collection.
   3  */
   4
   5 #include <stdio.h>
   6 #include <assert.h>
   7 #include <stdlib.h>
   8 #include <time.h>
   9 #include <stdarg.h>
  10 #include <string.h>
  11 #include <errno.h>
  12
  13 #include <sys/time.h>
  14
  15 #include "puzzles.h"
  16
  17 extern void _pause();
  18 extern int _call_java(int cmd, int arg1, int arg2, int arg3);
  19
  20 void fatal(char *fmt, ...)
  21 {
  22     va_list ap;
  23     fprintf(stderr, "fatal error: ");
  24     va_start(ap, fmt);
  25     vfprintf(stderr, fmt, ap);
  26     va_end(ap);
  27     fprintf(stderr, "\n");
  28     exit(1);
  29 }
  30
  31 struct frontend {
  32     // TODO kill unneeded members!
  33     midend *me;
  34     int timer_active;
  35     struct timeval last_time;
  36     config_item *cfg;
  37     int cfg_which, cfgret;
  38     int ox, oy;
  39 };
  40
  41 static frontend *_fe;
  42
  43 void get_random_seed(void **randseed, int *randseedsize)
  44 {
  45     struct timeval *tvp = snew(struct timeval);
  46     gettimeofday(tvp, NULL);
  47     *randseed = (void *)tvp;
  48     *randseedsize = sizeof(struct timeval);
  49 }
  50
  51 void frontend_default_colour(frontend *fe, float *output)
  52 {
  53     output[0] = output[1]= output[2] = 0.8f;
  54 }
  55
  56 void nestedvm_status_bar(void *handle, char *text)
  57 {
  58     _call_java(4,0,(int)text,0);
  59 }
  60
  61 void nestedvm_start_draw(void *handle)
  62 {
  63     frontend *fe = (frontend *)handle;
  64     _call_java(4, 1, fe->ox, fe->oy);
  65 }
  66
  67 void nestedvm_clip(void *handle, int x, int y, int w, int h)
  68 {
  69     frontend *fe = (frontend *)handle;
  70     _call_java(5, w, h, 0);
  71     _call_java(4, 3, x + fe->ox, y + fe->oy);
  72 }
  73
  74 void nestedvm_unclip(void *handle)
  75 {
  76     frontend *fe = (frontend *)handle;
  77     _call_java(4, 4, fe->ox, fe->oy);
  78 }
  79
  80 void nestedvm_draw_text(void *handle, int x, int y, int fonttype, int fontsize,
  81                    int align, int colour, char *text)
  82 {
  83     frontend *fe = (frontend *)handle;
  84     _call_java(5, x + fe->ox, y + fe->oy,
  85                (fonttype == FONT_FIXED ? 0x10 : 0x0) | align);
  86     _call_java(7, fontsize, colour, (int)text);
  87 }
  88
  89 void nestedvm_draw_rect(void *handle, int x, int y, int w, int h, int colour)
  90 {
  91     frontend *fe = (frontend *)handle;
  92     _call_java(5, w, h, colour);
  93     _call_java(4, 5, x + fe->ox, y + fe->oy);
  94 }
  95
  96 void nestedvm_draw_line(void *handle, int x1, int y1, int x2, int y2,
  97                         int colour)
  98 {
  99     frontend *fe = (frontend *)handle;
 100     _call_java(5, x2 + fe->ox, y2 + fe->oy, colour);
 101     _call_java(4, 6, x1 + fe->ox, y1 + fe->oy);
 102 }
 103
 104 void nestedvm_draw_poly(void *handle, int *coords, int npoints,
 105                         int fillcolour, int outlinecolour)
 106 {
 107     frontend *fe = (frontend *)handle;
 108     int i;
 109     _call_java(4, 7, npoints, 0);
 110     for (i = 0; i < npoints; i++) {
 111         _call_java(6, i, coords[i*2] + fe->ox, coords[i*2+1] + fe->oy);
 112     }
 113     _call_java(4, 8, outlinecolour, fillcolour);
 114 }
 115
 116 void nestedvm_draw_circle(void *handle, int cx, int cy, int radius,
 117                      int fillcolour, int outlinecolour)
 118 {
 119     frontend *fe = (frontend *)handle;
 120     _call_java(5, cx+fe->ox, cy+fe->oy, radius);
 121     _call_java(4, 9, outlinecolour, fillcolour);
 122 }
 123
 124 struct blitter {
 125     int handle, w, h, x, y;
 126 };
 127
 128 blitter *nestedvm_blitter_new(void *handle, int w, int h)
 129 {
 130     blitter *bl = snew(blitter);
 131     bl->handle = -1;
 132     bl->w = w;
 133     bl->h = h;
 134     return bl;
 135 }
 136
 137 void nestedvm_blitter_free(void *handle, blitter *bl)
 138 {
 139     if (bl->handle != -1)
 140         _call_java(4, 11, bl->handle, 0);
 141     sfree(bl);
 142 }
 143
 144 void nestedvm_blitter_save(void *handle, blitter *bl, int x, int y)
 145 {
 146     frontend *fe = (frontend *)handle;
 147     if (bl->handle == -1)
 148         bl->handle = _call_java(4,10,bl->w, bl->h);
 149     bl->x = x;
 150     bl->y = y;
 151     _call_java(8, bl->handle, x + fe->ox, y + fe->oy);
 152 }
 153
 154 void nestedvm_blitter_load(void *handle, blitter *bl, int x, int y)
 155 {
 156     frontend *fe = (frontend *)handle;
 157     assert(bl->handle != -1);
 158     if (x == BLITTER_FROMSAVED && y == BLITTER_FROMSAVED) {
 159         x = bl->x;
 160         y = bl->y;
 161     }
 162     _call_java(9, bl->handle, x + fe->ox, y + fe->oy);
 163 }
 164
 165 void nestedvm_end_draw(void *handle)
 166 {
 167     _call_java(4,2,0,0);
 168 }
 169
 170 const struct drawing_api nestedvm_drawing = {
 171     nestedvm_draw_text,
 172     nestedvm_draw_rect,
 173     nestedvm_draw_line,
 174     nestedvm_draw_poly,
 175     nestedvm_draw_circle,
 176     NULL, // draw_update,
 177     nestedvm_clip,
 178     nestedvm_unclip,
 179     nestedvm_start_draw,
 180     nestedvm_end_draw,
 181     nestedvm_status_bar,
 182     nestedvm_blitter_new,
 183     nestedvm_blitter_free,
 184     nestedvm_blitter_save,
 185     nestedvm_blitter_load,
 186     NULL, NULL, NULL, NULL, NULL, NULL, /* {begin,end}_{doc,page,puzzle} */
 187     NULL,                              /* line_width */
 188 };
 189
 190 int jcallback_key_event(int x, int y, int keyval)
 191 {
 192     frontend *fe = (frontend *)_fe;
 193     if (fe->ox == -1)
 194         return 1;
 195     if (keyval >= 0 &&
 196         !midend_process_key(fe->me, x - fe->ox, y - fe->oy, keyval))
 197         return 42;
 198     return 1;
 199 }
 200
 201 int jcallback_resize(int width, int height)
 202 {
 203     frontend *fe = (frontend *)_fe;
 204     int x, y;
 205     x = width;
 206     y = height;
 207     midend_size(fe->me, &x, &y, TRUE);
 208     fe->ox = (width - x) / 2;
 209     fe->oy = (height - y) / 2;
 210     midend_force_redraw(fe->me);
 211     return 0;
 212 }
 213
 214 int jcallback_timer_func()
 215 {
 216     frontend *fe = (frontend *)_fe;
 217     if (fe->timer_active) {
 218         struct timeval now;
 219         float elapsed;
 220         gettimeofday(&now, NULL);
 221         elapsed = ((now.tv_usec - fe->last_time.tv_usec) * 0.000001F +
 222                    (now.tv_sec - fe->last_time.tv_sec));
 223         midend_timer(fe->me, elapsed);  /* may clear timer_active */
 224         fe->last_time = now;
 225     }
 226     return fe->timer_active;
 227 }
 228
 229 void deactivate_timer(frontend *fe)
 230 {
 231     if (fe->timer_active)
 232         _call_java(4, 13, 0, 0);
 233     fe->timer_active = FALSE;
 234 }
 235
 236 void activate_timer(frontend *fe)
 237 {
 238     if (!fe->timer_active) {
 239         _call_java(4, 12, 0, 0);
 240         gettimeofday(&fe->last_time, NULL);
 241     }
 242     fe->timer_active = TRUE;
 243 }
 244
 245 void jcallback_config_ok()
 246 {
 247     frontend *fe = (frontend *)_fe;
 248     char *err;
 249
 250     err = midend_set_config(fe->me, fe->cfg_which, fe->cfg);
 251
 252     if (err)
 253         _call_java(2, (int) "Error", (int)err, 1);
 254     else {
 255         fe->cfgret = TRUE;
 256     }
 257 }
 258
 259 void jcallback_config_set_string(int item_ptr, int char_ptr) {
 260     config_item *i = (config_item *)item_ptr;
 261     char* newval = (char*) char_ptr;
 262     sfree(i->sval);
 263     i->sval = dupstr(newval);
 264     free(newval);
 265 }
 266
 267 void jcallback_config_set_boolean(int item_ptr, int selected) {
 268     config_item *i = (config_item *)item_ptr;
 269     i->ival = selected != 0 ? TRUE : FALSE;
 270 }
 271
 272 void jcallback_config_set_choice(int item_ptr, int selected) {
 273     config_item *i = (config_item *)item_ptr;
 274     i->ival = selected;
 275 }
 276
 277 static int get_config(frontend *fe, int which)
 278 {
 279     char *title;
 280     config_item *i;
 281     fe->cfg = midend_get_config(fe->me, which, &title);
 282     fe->cfg_which = which;
 283     fe->cfgret = FALSE;
 284     _call_java(10, (int)title, 0, 0);
 285     for (i = fe->cfg; i->type != C_END; i++) {
 286         _call_java(5, (int)i, i->type, (int)i->name);
 287         _call_java(11, (int)i->sval, i->ival, 0);
 288     }
 289     _call_java(12,0,0,0);
 290     free_cfg(fe->cfg);
 291     return fe->cfgret;
 292 }
 293
 294 int jcallback_menu_key_event(int key)
 295 {
 296     frontend *fe = (frontend *)_fe;
 297     if (!midend_process_key(fe->me, 0, 0, key))
 298         return 42;
 299     return 0;
 300 }
 301
 302 static void resize_fe(frontend *fe)
 303 {
 304     int x, y;
 305
 306     x = INT_MAX;
 307     y = INT_MAX;
 308     midend_size(fe->me, &x, &y, FALSE);
 309     _call_java(3, x, y, 0);
 310 }
 311
 312 int jcallback_preset_event(int ptr_game_params)
 313 {
 314     frontend *fe = (frontend *)_fe;
 315     game_params *params =
 316         (game_params *)ptr_game_params;
 317
 318     midend_set_params(fe->me, params);
 319     midend_new_game(fe->me);
 320     resize_fe(fe);
 321     _call_java(13, midend_which_preset(fe->me), 0, 0);
 322     return 0;
 323 }
 324
 325 int jcallback_solve_event()
 326 {
 327     frontend *fe = (frontend *)_fe;
 328     char *msg;
 329
 330     msg = midend_solve(fe->me);
 331
 332     if (msg)
 333         _call_java(2, (int) "Error", (int)msg, 1);
 334     return 0;
 335 }
 336
 337 int jcallback_restart_event()
 338 {
 339     frontend *fe = (frontend *)_fe;
 340
 341     midend_restart_game(fe->me);
 342     return 0;
 343 }
 344
 345 int jcallback_config_event(int which)
 346 {
 347     frontend *fe = (frontend *)_fe;
 348     _call_java(13, midend_which_preset(fe->me), 0, 0);
 349     if (!get_config(fe, which))
 350         return 0;
 351     midend_new_game(fe->me);
 352     resize_fe(fe);
 353     _call_java(13, midend_which_preset(fe->me), 0, 0);
 354     return 0;
 355 }
 356
 357 int jcallback_about_event()
 358 {
 359     char titlebuf[256];
 360     char textbuf[1024];
 361
 362     sprintf(titlebuf, "About %.200s", thegame.name);
 363     sprintf(textbuf,
 364             "%.200s\n\n"
 365             "from Simon Tatham's Portable Puzzle Collection\n\n"
 366             "%.500s", thegame.name, ver);
 367     _call_java(2, (int)&titlebuf, (int)&textbuf, 0);
 368     return 0;
 369 }
 370
 371 int main(int argc, char **argv)
 372 {
 373     int i, n;
 374     float* colours;
 375
 376     _fe = snew(frontend);
 377     _fe->timer_active = FALSE;
 378     _fe->me = midend_new(_fe, &thegame, &nestedvm_drawing, _fe);
 379     if (argc > 1)
 380         midend_game_id(_fe->me, argv[1]);   /* ignore failure */
 381     midend_new_game(_fe->me);
 382
 383     if ((n = midend_num_presets(_fe->me)) > 0) {
 384         int i;
 385         for (i = 0; i < n; i++) {
 386             char *name;
 387             game_params *params;
 388             midend_fetch_preset(_fe->me, i, &name, &params);
 389             _call_java(1, (int)name, (int)params, 0);
 390         }
 391     }
 392
 393     colours = midend_colours(_fe->me, &n);
 394     _fe->ox = -1;
 395
 396     _call_java(0, (int)thegame.name,
 397                (thegame.can_configure ? 1 : 0) |
 398                (midend_wants_statusbar(_fe->me) ? 2 : 0) |
 399                (thegame.can_solve ? 4 : 0), n);
 400     for (i = 0; i < n; i++) {
 401         _call_java(1024+ i,
 402                    (int)(colours[i*3] * 0xFF),
 403                    (int)(colours[i*3+1] * 0xFF),
 404                    (int)(colours[i*3+2] * 0xFF));
 405     }
 406     resize_fe(_fe);
 407
 408     _call_java(13, midend_which_preset(_fe->me), 0, 0);
 409
 410     // Now pause the vm. The VM will be call()ed when
 411     // an input event occurs.
 412     _pause();
 413
 414     // shut down when the VM is resumed.
 415     deactivate_timer(_fe);
 416     midend_free(_fe->me);
 417     return 0;
 418 }