path: root/x11.cpp

/* ScummVM - Scumm Interpreter
 * Copyright (C) 2001  Ludvig Strigeus
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * $Header$
 *
 */

/* The bare pure X11 port done by Lionel 'BBrox' Ulmer */

#include "stdafx.h"
#include "scumm.h"
#include "gui.h"
#include "cdmusic.h"
#include "mp3_cd.h"

#include <sys/time.h>
#include <unistd.h>

#include <sys/ipc.h>
#include <sys/shm.h>

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/extensions/XShm.h>
#include <linux/soundcard.h>

#include <sched.h>
#include <pthread.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>

Scumm scumm;
ScummDebugger debugger;
Gui gui;
IMuse sound;
SOUND_DRIVER_TYPE snd_driv;
static unsigned char *local_fb;

static int window_width, window_height;
static int scumm_x, scumm_y;

static int x11_socket = -1;
static Display *display;
static int screen;
static Window window;
static GC black_gc;
static XImage *image;
static pthread_t sound_thread;
static int old_mouse_x, old_mouse_y;
static int old_mouse_h, old_mouse_w;
static bool has_mouse, hide_mouse;

static unsigned int scale;
static int fake_right_mouse = 0;
static int report_presses = 1;
static int current_shake_pos = 0;

#define MAX_NUMBER_OF_DIRTY_SQUARES 32
typedef struct {
	int x, y, w, h;
} dirty_square;
static dirty_square ds[MAX_NUMBER_OF_DIRTY_SQUARES];
static int num_of_dirty_square;

/* Milisecond-based timer management */
static struct timeval start_time;
static void init_timer(void)
{
	gettimeofday(&start_time, NULL);
}
static unsigned int get_ms_from_start(void)
{
	struct timeval current_time;
	gettimeofday(&current_time, NULL);
	return (((current_time.tv_sec - start_time.tv_sec) * 1000) +
					((current_time.tv_usec - start_time.tv_usec) / 1000));
}

#define FRAG_SIZE 4096
static void *sound_and_music_thread(void *params)
{
	/* Init sound */
	int sound_fd, param, frag_size;
	unsigned char sound_buffer[FRAG_SIZE];

	sound_fd = open("/dev/dsp", O_WRONLY);
	audio_buf_info info;
	if (sound_fd < 0) {
		error("Error opening sound device !\n");
		exit(1);
	}
	param = 0;
	frag_size = FRAG_SIZE /* audio fragment size */ ;
	while (frag_size) {
		frag_size >>= 1;
		param++;
	}
	param--;
	param |= /* audio_fragment_num */ 3 << 16;
	if (ioctl(sound_fd, SNDCTL_DSP_SETFRAGMENT, &param) != 0) {
		error("Error in the SNDCTL_DSP_SETFRAGMENT ioctl !\n");
		exit(1);
	}
	param = AFMT_S16_LE;
	if (ioctl(sound_fd, SNDCTL_DSP_SETFMT, &param) == -1) {
		perror("Error in the SNDCTL_DSP_SETFMT ioctl !\n");
		exit(1);
	}
	if (param != AFMT_S16_LE) {
		error("AFMT_S16_LE not supported !\n");
		exit(1);
	}
	param = 2;
	if (ioctl(sound_fd, SNDCTL_DSP_CHANNELS, &param) == -1) {
		error("Error in the SNDCTL_DSP_CHANNELS ioctl !\n");
		exit(1);
	}
	if (param != 2) {
		error("Stereo mode not supported !\n");
		exit(1);
	}
	param = 22050;
	if (ioctl(sound_fd, SNDCTL_DSP_SPEED, &param) == -1) {
		perror("Error in the SNDCTL_DSP_SPEED ioctl !\n");
		exit(1);
	}
	if (param != 22050) {
		error("22050 kHz not supported !\n");
		exit(1);
	}
	if (ioctl(sound_fd, SNDCTL_DSP_GETOSPACE, &info) != 0) {
		perror("SNDCTL_DSP_GETOSPACE");
		exit(-1);
	}

	while (1) {
		unsigned short *buf = (unsigned short *)sound_buffer;
		int size, written;

		scumm.mixWaves((short *)sound_buffer, FRAG_SIZE >> 2);
		/* Now convert to stereo */
		for (int i = ((FRAG_SIZE >> 2) - 1); i >= 0; i--) {
			buf[2 * i + 1] = buf[2 * i] = buf[i];
		}
		size = FRAG_SIZE;
		while (size > 0) {
			written = write(sound_fd, sound_buffer, size);
			size -= written;
		}
	}

	return NULL;
}

/* Function used to hide the mouse cursor */
static void create_empty_cursor(Display * display, int screen, Window window)
{
	XColor bg;
	Pixmap pixmapBits;
	Cursor cursor = None;
	static const char data[] = { 0 };

	bg.red = bg.green = bg.blue = 0x0000;
	pixmapBits =
		XCreateBitmapFromData(display, XRootWindow(display, screen), data, 1, 1);
	if (pixmapBits) {
		cursor = XCreatePixmapCursor(display, pixmapBits, pixmapBits,
																 &bg, &bg, 0, 0);
		XFreePixmap(display, pixmapBits);
	}
	XDefineCursor(display, window, cursor);
}

/* No CD on the iPAQ => stub functions */
void cd_play(Scumm *s, int track, int num_loops, int start_frame,
						 int end_frame)
{

#ifdef COMPRESSED_SOUND_FILE
	mp3_cd_play(s, track, num_loops, start_frame, end_frame);
#endif
}
int cd_is_running(void)
{
	return 1;
}
void cd_stop(void)
{
}

/* No debugger on the iPAQ => stub function */
void BoxTest(int num)
{
}

/* Initialize the graphics sub-system */
void initGraphics(Scumm *s, bool fullScreen, unsigned int scaleFactor)
{
	char buf[512], *gameName;
	static XShmSegmentInfo shminfo;
	XWMHints *wm_hints;
	XGCValues values;
	XTextProperty window_name;
	char *name = (char *)&buf;

	scale = scaleFactor;					// not implemented yet! ignored.

	/* For the window title */
	sprintf(buf, "ScummVM - %s", gameName = s->getGameName());
	free(gameName);

	display = XOpenDisplay(NULL);
	if (display == NULL) {
		error("Could not open display !\n");
		exit(1);
	}
	screen = DefaultScreen(display);
	x11_socket = ConnectionNumber(display);

	window_width = 320;
	window_height = 200;
	scumm_x = 0;
	scumm_y = 0;
	window = XCreateSimpleWindow(display, XRootWindow(display, screen), 0, 0,
															 320, 200, 0, 0, 0);
	wm_hints = XAllocWMHints();
	if (wm_hints == NULL) {
		error("Not enough memory to allocate Hints !\n");
		exit(1);
	}
	wm_hints->flags = InputHint | StateHint;
	wm_hints->input = True;
	wm_hints->initial_state = NormalState;
	XStringListToTextProperty(&name, 1, &window_name);
	XSetWMProperties(display, window, &window_name, &window_name,
									 NULL /* argv */ , 0 /* argc */ , NULL /* size hints */ ,
									 wm_hints, NULL /* class hints */ );

	XSelectInput(display, window,
							 ExposureMask | KeyPressMask | KeyReleaseMask |
							 PointerMotionMask | ButtonPressMask | ButtonReleaseMask |
							 StructureNotifyMask);
	image =
		XShmCreateImage(display, DefaultVisual(display, screen), 16, ZPixmap,
										NULL, &shminfo, 320, 200);
	shminfo.shmid = shmget(IPC_PRIVATE, 320 * 200 * 2, IPC_CREAT | 0700);
	shminfo.shmaddr = (char *)shmat(shminfo.shmid, 0, 0);
	image->data = shminfo.shmaddr;
	shminfo.readOnly = False;
	if (XShmAttach(display, &shminfo) == 0) {
		error("Could not attach shared memory segment !\n");
		exit(1);
	}
	shmctl(shminfo.shmid, IPC_RMID, 0);

	values.foreground = BlackPixel(display, screen);
	black_gc = XCreateGC(display, window, GCForeground, &values);

	XMapWindow(display, window);
	XFlush(display);

	while (1) {
		XEvent event;
		XNextEvent(display, &event);
		switch (event.type) {
		case Expose:
			goto out_of_loop;
		}
	}
out_of_loop:
	create_empty_cursor(display, screen, window);

	/* And finally start the music thread */
	pthread_create(&sound_thread, NULL, sound_and_music_thread, NULL);

	/* Initialize the 'local' frame buffer */
	local_fb = (unsigned char *)malloc(320 * 200 * sizeof(unsigned char));
}

void setWindowName(Scumm *s)
{
	char buf[512], *gameName;
	XTextProperty window_name;
	char *name = (char *)&buf;

	/* For the window title */
	sprintf(buf, "ScummVM - %s", gameName = s->getGameName());
	free(gameName);

	XStringListToTextProperty(&name, 1, &window_name);
	XSetWMProperties(display, window, &window_name, &window_name,
									 NULL /* argv */ , 0 /* argc */ , NULL /* size hints */ ,
									 NULL /* WM hints */ , NULL /* class hints */ );
}

/* This simply shifts up or down the screen by 'shake pos' */
void setShakePos(Scumm *s, int shake_pos)
{
	if (shake_pos != current_shake_pos) {
		int dirty_top = 0, dirty_height = 0;
		int line;

		/* This is to provoke a full redraw */
		num_of_dirty_square = MAX_NUMBER_OF_DIRTY_SQUARES;

		/* Update the mouse to prevent 'mouse droppings' */
		old_mouse_y += shake_pos - current_shake_pos;

		/* Handle the 'dirty part' of the screen */
		if (shake_pos > current_shake_pos) {
			for (line = 199 + shake_pos; line >= -shake_pos; line--) {
				int cur_pos, new_pos;
				int cur_OK, new_OK;

				cur_pos = line + current_shake_pos;
				new_pos = line + shake_pos;

				cur_OK = (cur_pos >= 0) && (cur_pos < 200);
				new_OK = (new_pos >= 0) && (new_pos < 200);
				if (cur_OK && new_OK)
					memcpy(local_fb + new_pos * 320, local_fb + cur_pos * 320, 320);
				else if (cur_OK)
					memset(local_fb + cur_pos * 320, 0, 320);
				else if (new_OK)
					memset(local_fb + new_pos * 320, 0, 320);
			}

			if (current_shake_pos < 0) {
				dirty_top = -shake_pos;
				dirty_height = shake_pos - current_shake_pos;
				if (dirty_top < 0) {
					dirty_height += dirty_top;
					dirty_top = 0;
				}
				if ((dirty_height + dirty_top) > 200)
					dirty_height = 200 - dirty_top;
			} else {
				dirty_height = 0;
			}
		} else {
			for (line = -current_shake_pos; line < 200 + current_shake_pos; line++) {
				int cur_pos, new_pos;
				int cur_OK, new_OK;

				cur_pos = line + current_shake_pos;
				new_pos = line + shake_pos;
				cur_OK = (cur_pos >= 0) && (cur_pos < 200);
				new_OK = (new_pos >= 0) && (new_pos < 200);

				if (cur_OK && new_OK)
					memcpy(local_fb + new_pos * 320, local_fb + cur_pos * 320, 320);
				else if (cur_OK)
					memset(local_fb + cur_pos * 320, 0, 320);
				else if (new_OK)
					memset(local_fb + new_pos * 320, 0, 320);
			}

			if (current_shake_pos <= 0) {
				dirty_height = 0;
			} else {
				dirty_top = 200 - current_shake_pos;
				dirty_height = current_shake_pos - shake_pos;
				if ((dirty_height + dirty_top) > 200)
					dirty_height = 200 - dirty_top;
			}
		}

		/* And save the new shake position */
		current_shake_pos = shake_pos;
		if (dirty_height > 0)
			s->redrawLines(dirty_top, dirty_top + dirty_height);
	}
}

#define AddDirtyRec(xi,yi,wi,hi) 				\
  if (num_of_dirty_square < MAX_NUMBER_OF_DIRTY_SQUARES) {	\
    ds[num_of_dirty_square].x = xi;				\
    ds[num_of_dirty_square].y = yi;				\
    ds[num_of_dirty_square].w = wi;				\
    ds[num_of_dirty_square].h = hi;				\
    num_of_dirty_square++;					\
  }
void blitToScreen(Scumm *s, byte *src, int x, int y, int w, int h)
{
	unsigned char *dst;

	y += current_shake_pos;
	if (y < 0) {
		h += y;
		src -= y * 320;
		y = 0;
	}
	if (h > (200 - y)) {
		h = 200 - y;
	}

	dst = local_fb + 320 * y + x;

	if (h <= 0)
		return;

	hide_mouse = true;
	if (has_mouse) {
		s->drawMouse();
	}

	AddDirtyRec(x, y, w, h);
	while (h-- > 0) {
		memcpy(dst, src, w);
		dst += 320;
		src += 320;
	}
}

#define BAK_WIDTH 40
#define BAK_HEIGHT 40
unsigned char old_backup[BAK_WIDTH * BAK_HEIGHT];

void drawMouse(int xdraw, int ydraw, int w, int h, byte *buf,
							 bool visible)
{
	unsigned char *dst, *bak;

	ydraw += current_shake_pos;

	if ((xdraw >= 320) || ((xdraw + w) <= 0) ||
			(ydraw >= 200) || ((ydraw + h) <= 0)) {
		if (hide_mouse)
			visible = false;
		if (has_mouse)
			has_mouse = false;
		if (visible)
			has_mouse = true;
		return;
	}

	if (hide_mouse)
		visible = false;

	assert(w <= BAK_WIDTH && h <= BAK_HEIGHT);

	if (has_mouse) {
		int old_h = old_mouse_h;

		has_mouse = false;
		AddDirtyRec(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h);

		dst = local_fb + (old_mouse_y * 320) + old_mouse_x;
		bak = old_backup;

		while (old_h > 0) {
			memcpy(dst, bak, old_mouse_w);
			bak += BAK_WIDTH;
			dst += 320;
			old_h--;
		}
	}

	if (visible) {
		int real_w;
		int real_h;
		int real_h_2;
		unsigned char *dst2;

		if (ydraw < 0) {
			real_h = h + ydraw;
			buf += (-ydraw) * w;
			ydraw = 0;
		} else {
			real_h = (ydraw + h) > 200 ? (200 - ydraw) : h;
		}
		if (xdraw < 0) {
			real_w = w + xdraw;
			buf += (-xdraw);
			xdraw = 0;
		} else {
			real_w = (xdraw + w) > 320 ? (320 - xdraw) : w;
		}

		dst = local_fb + (ydraw * 320) + xdraw;
		dst2 = dst;
		bak = old_backup;

		has_mouse = true;

		AddDirtyRec(xdraw, ydraw, real_w, real_h);
		old_mouse_x = xdraw;
		old_mouse_y = ydraw;
		old_mouse_w = real_w;
		old_mouse_h = real_h;

		real_h_2 = real_h;
		while (real_h_2 > 0) {
			memcpy(bak, dst, real_w);
			bak += BAK_WIDTH;
			dst += 320;
			real_h_2--;
		}
		while (real_h > 0) {
			int width = real_w;
			while (width > 0) {
				unsigned char color = *buf;
				if (color != 0xFF) {
					*dst2 = color;
				}
				buf++;
				dst2++;
				width--;
			}
			buf += w - real_w;
			dst2 += 320 - real_w;
			real_h--;
		}
	}
}

static unsigned short palette[256];
static void update_palette(Scumm *s)
{
	int first = s->_palDirtyMin;
	int num = s->_palDirtyMax - first + 1;
	int i;
	unsigned char *data = s->_currentPalette;
	unsigned short *pal = &(palette[first]);

	data += first * 3;
	for (i = 0; i < num; i++, data += 3) {
		*pal++ =
			((data[0] & 0xF8) << 8) | ((data[1] & 0xFC) << 3) | (data[2] >> 3);
	}
	s->_palDirtyMax = -1;
	s->_palDirtyMin = 0x3E8;
}

static void update_screen(Scumm *s, const dirty_square * d,
													dirty_square * dout)
{
	int x, y;
	unsigned char *ptr_src = local_fb + (320 * d->y) + d->x;
	unsigned short *ptr_dst =
		((unsigned short *)image->data) + (320 * d->y) + d->x;
	for (y = 0; y < d->h; y++) {
		for (x = 0; x < d->w; x++) {
			*ptr_dst++ = palette[*ptr_src++];
		}
		ptr_dst += 320 - d->w;
		ptr_src += 320 - d->w;
	}
	if (d->x < dout->x)
		dout->x = d->x;
	if (d->y < dout->y)
		dout->y = d->y;
	if ((d->x + d->w) > dout->w)
		dout->w = d->x + d->w;
	if ((d->y + d->h) > dout->h)
		dout->h = d->y + d->h;
}

void updateScreen(Scumm *s)
{
	bool full_redraw = false;
	bool need_redraw = false;
	static const dirty_square ds_full = { 0, 0, 320, 200 };
	dirty_square dout = { 320, 200, 0, 0 };

	if (s->_fastMode & 2)
		return;

	if (hide_mouse) {
		hide_mouse = false;
		s->drawMouse();
	}

	if (s->_palDirtyMax != -1) {
		update_palette(s);
		full_redraw = true;
		num_of_dirty_square = 0;
	} else if (num_of_dirty_square >= MAX_NUMBER_OF_DIRTY_SQUARES) {
		full_redraw = true;
		num_of_dirty_square = 0;
	}

	if (full_redraw) {
		update_screen(s, &ds_full, &dout);
		need_redraw = true;
	} else if (num_of_dirty_square > 0) {
		need_redraw = true;
		while (num_of_dirty_square > 0) {
			num_of_dirty_square--;
			update_screen(s, &(ds[num_of_dirty_square]), &dout);
		}
	}
	if (need_redraw == true) {
		XShmPutImage(display, window, DefaultGC(display, screen), image,
								 dout.x, dout.y,
								 scumm_x + dout.x, scumm_y + dout.y,
								 dout.w - dout.x, dout.h - dout.y, 0);
		XFlush(display);
	}
}

void launcherLoop()
{
	int last_time, new_time;
	int delta = 0;
	last_time = get_ms_from_start();

	gui.launcher();
	while (1) {
		updateScreen(&scumm);

		new_time = get_ms_from_start();
		waitForTimer(&scumm, delta * 15 + last_time - new_time);
		last_time = get_ms_from_start();

		if (gui._active) {
			gui.loop();
			delta = 5;
		} else {
			error("gui closed!");
		}
	}
}

/* This function waits for 'msec_delay' miliseconds and handles external events */
void waitForTimer(Scumm *s, int msec_delay)
{
	int start_time = get_ms_from_start();
	int end_time;
	fd_set rfds;
	struct timeval tv;
	XEvent event;

	if (s->_fastMode & 2)
		msec_delay = 0;
	else if (s->_fastMode & 1)
		msec_delay = 10;
	end_time = start_time + msec_delay;


	while (1) {
		FD_ZERO(&rfds);
		FD_SET(x11_socket, &rfds);

		msec_delay = end_time - get_ms_from_start();
		tv.tv_sec = 0;
		if (msec_delay <= 0) {
			tv.tv_usec = 0;
		} else {
			tv.tv_usec = msec_delay * 1000;
		}
		if (select(x11_socket + 1, &rfds, NULL, NULL, &tv) == 0)
			break;										/* This is the timeout */
		while (XPending(display)) {
			XNextEvent(display, &event);
			switch (event.type) {
			case Expose:{
					int real_w, real_h;
					int real_x, real_y;
					real_x = event.xexpose.x;
					real_y = event.xexpose.y;
					real_w = event.xexpose.width;
					real_h = event.xexpose.height;

					if (real_x < scumm_x) {
						real_w -= scumm_x - real_x;
						real_x = 0;
					} else {
						real_x -= scumm_x;
					}
					if (real_y < scumm_y) {
						real_h -= scumm_y - real_y;
						real_y = 0;
					} else {
						real_y -= scumm_y;
					}
					if ((real_h <= 0) || (real_w <= 0))
						break;
					if ((real_x >= 320) || (real_y >= 200))
						break;

					if ((real_x + real_w) >= 320) {
						real_w = 320 - real_x;
					}
					if ((real_y + real_h) >= 200) {
						real_h = 200 - real_y;
					}

					/* Compute the intersection of the expose event with the real ScummVM display zone */
					AddDirtyRec(real_x, real_y, real_w, real_h);
				}
				break;

			case KeyPress:
				switch (event.xkey.keycode) {
				case 132:
					report_presses = 0;
					break;

				case 133:
					fake_right_mouse = 1;
					break;
				}
				break;

			case KeyRelease:
				/* I am using keycodes here and NOT keysyms to be sure that even if the user
				   remaps his iPAQ's keyboard, it will still work.
				 */
				switch (event.xkey.keycode) {
				case 9:								/* Escape on my PC */
				case 130:							/* Calendar on the iPAQ */
					s->_keyPressed = 27;
					break;

				case 71:								/* F5 on my PC */
				case 128:							/* Record on the iPAQ */
					s->_keyPressed = 319;
					break;

				case 65:								/* Space on my PC */
				case 131:							/* Schedule on the iPAQ */
					s->_keyPressed = 32;
					break;

				case 132:							/* 'Q' on the iPAQ */
					report_presses = 1;
					break;

				case 133:							/* Arrow on the iPAQ */
					fake_right_mouse = 0;
					break;

				default:{
						KeySym xsym;
						xsym = XKeycodeToKeysym(display, event.xkey.keycode, 0);
						if ((xsym >= 'a') && (xsym <= 'z') && (event.xkey.state & 0x01))
							xsym &= ~0x20;		/* Handle shifted keys */
						s->_keyPressed = xsym;
					}
				}
				break;

			case ButtonPress:
				if (report_presses != 0) {
					if (event.xbutton.button == 1) {
						if (fake_right_mouse == 0) {
							s->_leftBtnPressed |= msClicked | msDown;
						} else {
							s->_rightBtnPressed |= msClicked | msDown;
						}
					} else if (event.xbutton.button == 3)
						s->_rightBtnPressed |= msClicked | msDown;
				}
				break;

			case ButtonRelease:
				if (report_presses != 0) {
					if (event.xbutton.button == 1) {
						if (fake_right_mouse == 0) {
							s->_leftBtnPressed &= ~msDown;
						} else {
							s->_rightBtnPressed &= ~msDown;
						}
					} else if (event.xbutton.button == 3)
						s->_rightBtnPressed &= ~msDown;
				}
				break;

			case MotionNotify:{
					int newx, newy;
					newx = event.xmotion.x - scumm_x;
					newy = event.xmotion.y - scumm_y;
					if ((newx != s->mouse.x) || (newy != s->mouse.y)) {
						s->mouse.x = newx;
						s->mouse.y = newy;
						s->drawMouse();
						updateScreen(s);
					}
				}
				break;

			case ConfigureNotify:{
					if ((window_width != event.xconfigure.width) ||
							(window_height != event.xconfigure.height)) {
						window_width = event.xconfigure.width;
						window_height = event.xconfigure.height;
						scumm_x = (window_width - 320) / 2;
						scumm_y = (window_height - 200) / 2;
						XFillRectangle(display, window, black_gc, 0, 0, window_width,
													 window_height);
					}
				}
				break;

			default:
				printf("%d\n", event.type);
				break;
			}
		}
	}
}

/* Main function for the system-dependent part. Needs to handle :
    - handle command line arguments
    - initialize all the 'globals' (sound driver, Scumm object, ...)
    - do the main loop of the game
*/
int main(int argc, char *argv[])
{
	int delta;
	int last_time, new_time;

	scumm._gui = &gui;
	gui.init(&scumm);
	sound.initialize(&scumm, &snd_driv);
	scumm.scummMain(argc, argv);
	gui.init(&scumm);							/* Reinit GUI after loading a game */

	num_of_dirty_square = 0;

	/* Start the milisecond counter */
	init_timer();
	last_time = 0;
	delta = 0;
	while (1) {
		updateScreen(&scumm);

		new_time = get_ms_from_start();
		waitForTimer(&scumm, delta * 15 + last_time - new_time);
		last_time = get_ms_from_start();

		if (gui._active) {
			gui.loop();
			delta = 5;
		} else {
			delta = scumm.scummLoop(delta);
		}
	}

	return 0;
}