Import the SCI engine sources from the FreeSCI Glutton branch (it doesn't compile yet)

svn-id: r38192

1 files changed, 580 insertions, 0 deletions

diff --git a/engines/sci/engine/kmovement.c b/engines/sci/engine/kmovement.c
new file mode 100644
index 0000000000..5f7d1a7281
--- /dev/null
+++ b/engines/sci/engine/kmovement.c
@@ -0,0 +1,580 @@
+/***************************************************************************
+ kmovement.c Copyright (C) 2001 Christoph Reichenbach
+
+
+ This program may be modified and copied freely according to the terms of
+ the GNU general public license (GPL), as long as the above copyright
+ notice and the licensing information contained herein are preserved.
+
+ Please refer to www.gnu.org for licensing details.
+
+ This work is provided AS IS, without warranty of any kind, expressed or
+ implied, including but not limited to the warranties of merchantibility,
+ noninfringement, and fitness for a specific purpose. The author will not
+ be held liable for any damage caused by this work or derivatives of it.
+
+ By using this source code, you agree to the licensing terms as stated
+ above.
+
+
+ Please contact the maintainer for bug reports or inquiries.
+
+ Current Maintainer:
+
+    Christoph Reichenbach (CR) <jameson@linuxgames.com>
+
+***************************************************************************/
+
+#include <sciresource.h>
+#include <engine.h>
+
+/*
+Compute "velocity" vector (xStep,yStep)=(vx,vy) for a jump from (0,0) to (dx,dy), with gravity gy. 
+The gravity is assumed to be non-negative.
+
+If this was ordinary continuous physics, we would compute the desired (floating point!)
+velocity vector (vx,vy) as follows, under the assumption that vx and vy are linearly correlated
+by some constant factor c, i.e. vy = c * vx: 
+   dx = t * vx
+   dy = t * vy + gy * t^2 / 2
+=> dy = c * dx + gy * (dx/vx)^2 / 2
+=> |vx| = sqrt( gy * dx^2 / (2 * (dy - c * dx)) )
+Here, the sign of vx must be chosen equal to the sign of dx, obviously. 
+
+Clearly, this square root only makes sense in our context if the denominator is positive,
+or equivalently, (dy - c * dx) must be positive. For simplicity and by symmetry
+along the x-axis, we assume dx to be positive for all computations, and only adjust for
+its sign in the end. Switching the sign of c appropriately, we set tmp := (dy + c * dx)
+and compute c so that this term becomes positive.
+
+Remark #1: If the jump is straight up, i.e. dx == 0, then we should not assume the above
+linear correlation vy = c * vx of the velocities (as vx will be 0, but vy shouldn't be,
+unless we drop).
+
+
+Remark #2: We are actually in a discrete setup. The motion is computed iteratively: each iteration,
+we add vx and vy to the position, then add gy to vy. So the real formula is the following
+(where t is ideally close to an int):
+
+  dx = t * vx
+  dy = t * vy + gy * t*(t-1) / 2
+
+But the solution resulting from that is a lot more complicated, so we use the above approximation instead.
+
+Still, what we compute in the end is of course not a real velocity anymore, but an integer approximation,
+used in an iterative stepping algorithm
+*/
+reg_t
+kSetJump(state_t *s, int funct_nr, int argc, reg_t *argv)
+{
+	// Input data
+	reg_t object = argv[0];
+	int dx = SKPV(1);
+	int dy = SKPV(2);
+	int gy = SKPV(3);
+
+	// Derived data
+	int c;
+	int tmp;
+	int vx = 0;  // x velocity
+	int vy = 0;  // y velocity
+
+	int dxWasNegative = (dx < 0);
+	dx = abs(dx);
+
+	assert(gy >= 0);
+
+	if (dx == 0) {
+		// Upward jump. Value of c doesn't really matter
+		c = 1;
+	} else {
+		// Compute a suitable value for c respectively tmp.
+		// The important thing to consider here is that we want the resulting
+		// *discrete* x/y velocities to be not-too-big integers, for a smooth
+		// curve (i.e. we could just set vx=dx, vy=dy, and be done, but that
+		// is hardly what you would call a parabolic jump, would ya? ;-).
+		//
+		// So, we make sure that 2.0*tmp will be bigger than dx (that way,
+		// we ensure vx will be less than sqrt(gy * dx)).
+		if (dx + dy < 0) {
+			// dy is negative and |dy| > |dx|
+			c = (2*abs(dy)) / dx;
+			//tmp = abs(dy);  // ALMOST the resulting value, except for obvious rounding issues
+		} else {
+			// dy is either positive, or |dy| <= |dx|
+			c = (dx*3/2 - dy) / dx;
+
+			// We force c to be strictly positive
+			if (c < 1)
+				c = 1;
+
+			//tmp = dx*3/2;  // ALMOST the resulting value, except for obvious rounding issues
+			
+			// FIXME: Where is the 3 coming from? Maybe they hard/coded, by "accident", that usually gy=3 ?
+			//  Then this choice of will make t equal to roughly sqrt(dx)
+		}
+	}
+	// POST: c >= 1
+	tmp = c * dx + dy;
+	// POST: (dx != 0)  ==>  abs(tmp) > abs(dx)
+	// POST: (dx != 0)  ==>  abs(tmp) ~>=~ abs(dy)
+
+
+	SCIkdebug(SCIkBRESEN, "c: %d, tmp: %d\n", c, tmp);
+	
+	// Compute x step
+	if (tmp != 0)
+		vx = (int)(dx * sqrt(gy / (2.0 * tmp)));
+	else
+		vx = 0;
+
+	// Restore the left/right direction: dx and vx should have the same sign.
+	if (dxWasNegative)
+		vx = -vx;
+	
+	if ((dy < 0) && (vx == 0)) {
+		// Special case: If this was a jump (almost) straight upward, i.e. dy < 0 (upward),
+		// and vx == 0 (i.e. no horizontal movement, at least not after rounding), then we
+		// compute vy directly.
+		// For this, we drop the assumption on the linear correlation of vx and vy (obviously).
+
+		// FIXME: This choice of vy makes t roughly (2+sqrt(2))/gy * sqrt(dy);
+		// so if gy==3, then t is roughly sqrt(dy)...
+		vy = (int)sqrt(gy * abs(2 * dy)) + 1;
+	} else {
+		// As stated above, the vertical direction is correlated to the horizontal by the
+		// (non-zero) factor c.
+		// Strictly speaking, we should probably be using the value of vx *before* rounding
+		// it to an integer... Ah well
+		vy = c * vx;
+	}
+
+	// Always force vy to be upwards
+	vy = -abs(vy);
+
+	SCIkdebug(SCIkBRESEN, "SetJump for object at "PREG"\n", PRINT_REG(object));
+	SCIkdebug(SCIkBRESEN, "xStep: %d, yStep: %d\n", vx, vy);
+	
+	PUT_SEL32V(object, xStep, vx);
+	PUT_SEL32V(object, yStep, vy);
+	
+	return s->r_acc;
+}
+
+#define _K_BRESEN_AXIS_X 0
+#define _K_BRESEN_AXIS_Y 1
+
+void
+initialize_bresen(state_t *s, int funct_nr, int argc, reg_t *argv, reg_t mover, int step_factor,
+		  int deltax, int deltay)
+{
+	reg_t client = GET_SEL32(mover, client);
+	int stepx = GET_SEL32SV(client, xStep) * step_factor;
+	int stepy = GET_SEL32SV(client, yStep) * step_factor;
+	int numsteps_x = stepx? (abs(deltax) + stepx-1) / stepx : 0;
+	int numsteps_y = stepy? (abs(deltay) + stepy-1) / stepy : 0;
+	int bdi, i1;
+	int numsteps;
+	int deltax_step;
+	int deltay_step;
+
+	if (numsteps_x > numsteps_y) {
+		numsteps = numsteps_x;
+		deltax_step = (deltax < 0)? -stepx : stepx;
+		deltay_step = numsteps? deltay / numsteps : deltay;
+	} else { /* numsteps_x <= numsteps_y */
+		numsteps = numsteps_y;
+		deltay_step = (deltay < 0)? -stepy : stepy;
+		deltax_step = numsteps? deltax / numsteps : deltax;
+	}
+
+	/*  if (abs(deltax) > abs(deltay)) {*/ /* Bresenham on y */
+	if (numsteps_y < numsteps_x) {
+
+		PUT_SEL32V(mover, b_xAxis, _K_BRESEN_AXIS_Y);
+		PUT_SEL32V(mover, b_incr, (deltay < 0)? -1 : 1);
+		/*
+		i1 = 2 * (abs(deltay) - abs(deltay_step * numsteps)) * abs(deltax_step);
+		bdi = -abs(deltax);
+		*/
+		i1 = 2*(abs(deltay) - abs(deltay_step * (numsteps - 1))) * abs(deltax_step);
+		bdi = -abs(deltax);
+
+	} else { /* Bresenham on x */
+
+		PUT_SEL32V(mover, b_xAxis, _K_BRESEN_AXIS_X);
+		PUT_SEL32V(mover, b_incr, (deltax < 0)? -1 : 1);
+		/*
+		i1= 2 * (abs(deltax) - abs(deltax_step * numsteps)) * abs(deltay_step);
+		bdi = -abs(deltay);
+		*/
+		i1 = 2*(abs(deltax) - abs(deltax_step * (numsteps - 1))) * abs(deltay_step);
+		bdi = -abs(deltay);
+
+	}
+
+	PUT_SEL32V(mover, dx, deltax_step);
+	PUT_SEL32V(mover, dy, deltay_step);
+
+	SCIkdebug(SCIkBRESEN, "Init bresen for mover "PREG": d=(%d,%d)\n", PRINT_REG(mover), deltax, deltay);
+	SCIkdebug(SCIkBRESEN, "    steps=%d, mv=(%d, %d), i1= %d, i2=%d\n",
+		  numsteps, deltax_step, deltay_step, i1, bdi*2);
+
+/*	PUT_SEL32V(mover, b_movCnt, numsteps); *//* Needed for HQ1/Ogre? */
+	PUT_SEL32V(mover, b_di, bdi);
+	PUT_SEL32V(mover, b_i1, i1);
+	PUT_SEL32V(mover, b_i2, bdi * 2);
+
+}
+
+reg_t
+kInitBresen(state_t *s, int funct_nr, int argc, reg_t *argv)
+{
+	reg_t mover = argv[0];
+	reg_t client = GET_SEL32(mover, client);
+
+	int deltax = GET_SEL32SV(mover, x) - GET_SEL32SV(client, x);
+	int deltay = GET_SEL32SV(mover, y) - GET_SEL32SV(client, y);
+
+	initialize_bresen(s, funct_nr, argc, argv, mover, KP_UINT(KP_ALT(1, make_reg(0, 1))), deltax, deltay);
+
+	return s->r_acc;
+}
+
+
+#define MOVING_ON_X (((axis == _K_BRESEN_AXIS_X)&&bi1) || dx)
+#define MOVING_ON_Y (((axis == _K_BRESEN_AXIS_Y)&&bi1) || dy)
+
+static enum {
+	IGNORE_MOVECNT,
+	INCREMENT_MOVECNT,
+	UNINITIALIZED
+} handle_movecnt = UNINITIALIZED;
+	
+int parse_reg_t(state_t *s, char *str, reg_t *dest); /* In scriptconsole.c */
+
+static int 
+checksum_bytes(byte *data, int size)
+{
+	int result = 0;
+	int i;
+
+	for (i = 0; i < size; i++)
+	{
+		result += *data;
+		data++;
+	}
+
+	return result;
+}
+
+static void
+bresenham_autodetect(state_t *s)
+{
+	reg_t motion_class;
+
+	if (!parse_reg_t(s, "?Motion", &motion_class))
+	{
+		object_t *obj = obj_get(s, motion_class);
+		reg_t fptr;
+		byte *buf;
+		
+		if (obj == NULL)
+		{
+			SCIkwarn(SCIkWARNING,"bresenham_autodetect failed!");
+			handle_movecnt = INCREMENT_MOVECNT; /* Most games do this, so best guess */
+			return;
+		}
+		
+		if (lookup_selector(s, motion_class, s->selector_map.doit, NULL, &fptr) != SELECTOR_METHOD)
+		{
+			SCIkwarn(SCIkWARNING,"bresenham_autodetect failed!");
+			handle_movecnt = INCREMENT_MOVECNT; /* Most games do this, so best guess */
+			return;
+		}
+
+		buf = s->seg_manager.heap[fptr.segment]->data.script.buf + fptr.offset;
+		handle_movecnt = (SCI_VERSION_MAJOR(s->version) == 0 ||
+				  checksum_bytes(buf, 8) == 0x216) ? INCREMENT_MOVECNT : IGNORE_MOVECNT;
+		sciprintf("b-moveCnt action based on checksum: %s\n", handle_movecnt == IGNORE_MOVECNT ?
+			  "ignore" : "increment");
+	} else
+	{
+		SCIkwarn(SCIkWARNING,"bresenham_autodetect failed!");
+		handle_movecnt = INCREMENT_MOVECNT; /* Most games do this, so best guess */
+	}
+}
+
+reg_t
+kDoBresen(state_t *s, int funct_nr, int argc, reg_t *argv)
+{
+	reg_t mover = argv[0];
+	reg_t client = GET_SEL32(mover, client);
+
+	int x = GET_SEL32SV(client, x);
+	int y = GET_SEL32SV(client, y);
+	int oldx, oldy, destx, desty, dx, dy, bdi, bi1, bi2, movcnt, bdelta, axis;
+	word signal = GET_SEL32V(client, signal);
+	int completed = 0;
+	int max_movcnt = GET_SEL32V(client, moveSpeed);
+
+	if (SCI_VERSION_MAJOR(s->version)>0)
+		signal&=~_K_VIEW_SIG_FLAG_HIT_OBSTACLE;
+
+	if (handle_movecnt == UNINITIALIZED)
+		bresenham_autodetect(s);
+
+	PUT_SEL32(client, signal, make_reg(0, signal)); /* This is a NOP for SCI0 */
+	oldx = x;
+	oldy = y;
+	destx = GET_SEL32SV(mover, x);
+	desty = GET_SEL32SV(mover, y);
+	dx = GET_SEL32SV(mover, dx);
+	dy = GET_SEL32SV(mover, dy);
+	bdi = GET_SEL32SV(mover, b_di);
+	bi1 = GET_SEL32SV(mover, b_i1);
+	bi2 = GET_SEL32SV(mover, b_i2);
+	movcnt = GET_SEL32V(mover, b_movCnt);
+	bdelta = GET_SEL32SV(mover, b_incr);
+	axis = GET_SEL32SV(mover, b_xAxis);
+
+//	sciprintf("movecnt %d, move speed %d\n", movcnt, max_movcnt);
+
+	if (handle_movecnt)
+	{
+		if (max_movcnt > movcnt)
+		{
+			++movcnt;
+			PUT_SEL32V(mover, b_movCnt, movcnt); /* Needed for HQ1/Ogre? */
+			return NULL_REG;
+		}
+		else
+		{
+			movcnt = 0;
+			PUT_SEL32V(mover, b_movCnt, movcnt); /* Needed for HQ1/Ogre? */
+		}
+	}
+
+	if ((bdi += bi1) > 0) {
+		bdi += bi2;
+
+		if (axis == _K_BRESEN_AXIS_X)
+			dx += bdelta;
+		else
+			dy += bdelta;
+	}
+
+	PUT_SEL32V(mover, b_di, bdi);
+
+	x += dx;
+	y += dy;
+
+ 	if ((MOVING_ON_X
+	     && (((x < destx) && (oldx >= destx)) /* Moving left, exceeded? */
+		 ||
+		 ((x > destx) && (oldx <= destx)) /* Moving right, exceeded? */
+		 ||
+		 ((x == destx) && (abs(dx) > abs(dy))) /* Moving fast, reached? */
+		 /* Treat this last case specially- when doing sub-pixel movements
+		 ** on the other axis, we could still be far away from the destination  */
+		 )
+	     )
+	    || (MOVING_ON_Y
+		&& (((y < desty) && (oldy >= desty)) /* Moving upwards, exceeded? */
+		    ||
+		    ((y > desty) && (oldy <= desty)) /* Moving downwards, exceeded? */
+		    ||
+		    ((y == desty) && (abs(dy) >= abs(dx))) /* Moving fast, reached? */
+		    )
+		)
+	    )
+		/* Whew... in short: If we have reached or passed our target position */
+		{
+			x = destx;
+			y = desty;
+			completed = 1;
+
+			SCIkdebug(SCIkBRESEN, "Finished mover "PREG"\n", PRINT_REG(mover));
+		}
+
+
+	PUT_SEL32V(client, x, x);
+	PUT_SEL32V(client, y, y);
+
+	SCIkdebug(SCIkBRESEN, "New data: (x,y)=(%d,%d), di=%d\n", x, y, bdi);
+
+	if (s->version >= SCI_VERSION_FTU_INVERSE_CANBEHERE)
+		invoke_selector(INV_SEL(client, cantBeHere, 0), 0); else
+			invoke_selector(INV_SEL(client, canBeHere, 0), 0);
+
+	s->r_acc = not_register(s, s->r_acc);
+
+	if (!s->r_acc.offset) { /* Contains the return value */
+
+		signal = GET_SEL32V(client, signal);
+
+		PUT_SEL32V(client, x, oldx);
+		PUT_SEL32V(client, y, oldy);
+
+		PUT_SEL32V(client, signal, (signal | _K_VIEW_SIG_FLAG_HIT_OBSTACLE));
+
+		SCIkdebug(SCIkBRESEN, "Finished mover "PREG" by collision\n", PRINT_REG(mover));
+		completed = 1;
+	}
+
+	if (SCI_VERSION_MAJOR(s->version)>0)
+		if (completed)
+			invoke_selector(INV_SEL(mover, moveDone, 0), 0);
+
+	return make_reg(0, completed);
+}
+
+extern void
+_k_dirloop(reg_t obj, word angle, state_t *s, int funct_nr,
+	   int argc, reg_t *argv);
+/* From kgraphics.c, used as alternative looper */
+
+int
+is_heap_object(state_t *s, reg_t pos);
+/* From kscripts.c */
+
+extern int
+get_angle(int xrel, int yrel);
+/* from kmath.c, used for calculating angles */
+
+
+reg_t
+kDoAvoider(state_t *s, int funct_nr, int argc, reg_t *argv)
+{
+	reg_t avoider = argv[0];
+	reg_t client, looper, mover;
+	int angle;
+	int dx, dy;
+	int destx, desty;
+
+
+	s->r_acc = make_reg(0, -1);
+
+	if (!is_heap_object(s, avoider)) {
+		SCIkwarn(SCIkWARNING, "DoAvoider() where avoider "PREG" is not an object\n", PRINT_REG(avoider));
+		return NULL_REG;
+	}
+
+	client = GET_SEL32(avoider, client);
+
+	if (!is_heap_object(s, client)) {
+		SCIkwarn(SCIkWARNING, "DoAvoider() where client "PREG" is not an object\n", PRINT_REG(client));
+		return NULL_REG;
+	}
+
+	looper = GET_SEL32(client, looper);
+
+	mover = GET_SEL32(client, mover);
+
+	if (!is_heap_object(s, mover)) {
+		if (mover.segment) {
+			SCIkwarn(SCIkWARNING, "DoAvoider() where mover "PREG" is not an object\n", PRINT_REG(mover));
+		}
+		return s->r_acc;
+	}
+
+	destx = GET_SEL32V(mover, x);
+	desty = GET_SEL32V(mover, y);
+
+	SCIkdebug(SCIkBRESEN, "Doing avoider %04x (dest=%d,%d)\n", avoider, destx, desty);
+
+	if (invoke_selector(INV_SEL(mover, doit, 1) , 0)) {
+		SCIkwarn(SCIkERROR, "Mover "PREG" of avoider "PREG
+			 " doesn't have a doit() funcselector\n", 
+			 PRINT_REG(mover), PRINT_REG(avoider));
+		return NULL_REG;
+	}
+
+	mover = GET_SEL32(client, mover);
+	if (!mover.segment) /* Mover has been disposed? */
+		return s->r_acc; /* Return gracefully. */
+
+	if (invoke_selector(INV_SEL(client, isBlocked, 1) , 0)) {
+		SCIkwarn(SCIkERROR, "Client "PREG" of avoider "PREG" doesn't"
+			 " have an isBlocked() funcselector\n", PRINT_REG(client), PRINT_REG(avoider));
+		return NULL_REG;
+	}
+
+	dx = destx - GET_SEL32V(client, x);
+	dy = desty - GET_SEL32V(client, y);
+	angle = get_angle(dx, dy);
+
+	SCIkdebug(SCIkBRESEN, "Movement (%d,%d), angle %d is %sblocked\n",
+		  dx, dy, angle, (s->r_acc.offset)? " ": "not ");
+
+	if (s->r_acc.offset) { /* isBlocked() returned non-zero */
+		int rotation = (rand() & 1)? 45 : (360-45); /* Clockwise/counterclockwise */
+		int oldx = GET_SEL32V(client, x);
+		int oldy = GET_SEL32V(client, y);
+		int xstep = GET_SEL32V(client, xStep);
+		int ystep = GET_SEL32V(client, yStep);
+		int moves;
+
+		SCIkdebug(SCIkBRESEN, " avoider "PREG"\n", PRINT_REG(avoider));
+
+		for (moves = 0; moves < 8; moves++) {
+			int move_x = (int) (sin(angle * PI / 180.0) * (xstep));
+			int move_y = (int) (-cos(angle * PI / 180.0) * (ystep));
+
+			PUT_SEL32V(client, x, oldx + move_x);
+			PUT_SEL32V(client, y, oldy + move_y);
+
+			SCIkdebug(SCIkBRESEN, "Pos (%d,%d): Trying angle %d; delta=(%d,%d)\n",
+				  oldx, oldy, angle, move_x, move_y);
+
+			if (invoke_selector(INV_SEL(client, canBeHere, 1) , 0)) {
+				SCIkwarn(SCIkERROR, "Client "PREG" of avoider "PREG" doesn't"
+					 " have a canBeHere() funcselector\n", 
+					 PRINT_REG(client), PRINT_REG(avoider));
+				return NULL_REG;
+			}
+
+			PUT_SEL32V(client, x, oldx);
+			PUT_SEL32V(client, y, oldy);
+
+			if (s->r_acc.offset) { /* We can be here */
+				SCIkdebug(SCIkBRESEN, "Success\n");
+				PUT_SEL32V(client, heading, angle);
+
+				return make_reg(0, angle);
+			}
+
+			angle += rotation;
+
+			if (angle > 360)
+				angle -= 360;
+		}
+
+		SCIkwarn(SCIkWARNING, "DoAvoider failed for avoider "PREG"\n",
+			 PRINT_REG(avoider));
+
+	} else {
+		int heading = GET_SEL32V(client, heading);
+
+		if (heading == -1)
+			return s->r_acc; /* No change */
+
+		PUT_SEL32V(client, heading, angle);
+
+		s->r_acc = make_reg(0, angle);
+
+		if (looper.segment) {
+			if (invoke_selector(INV_SEL(looper, doit, 1), 2, angle, client)) {
+				SCIkwarn(SCIkERROR, "Looper "PREG" of avoider "PREG" doesn't"
+					 " have a doit() funcselector\n", 
+					 PRINT_REG(looper), PRINT_REG(avoider));
+			} else return s->r_acc;
+		} else
+		/* No looper? Fall back to DirLoop */
+
+		_k_dirloop(client, (word)angle, s, funct_nr, argc, argv);
+	}
+
+	return s->r_acc;
+}
+