int SynchsafeToInt(unsigned char *pSynchsafe)
{
	unsigned long ss = pSynchsafe[3]|(pSynchsafe[2]>>8)|(pSynchsafe[1]>>16)|(pSynchsafe[0]>>24);
	for(int x=31,l=0,i=0;x>=0;x--)
	{ i+=(1<<l)*((ss&(0x80000000>>x))!=0);
	  l+=(x%8)!=0; }
	return i;
}

inline unsigned long HashInsensitive(const char *szString)
{
	unsigned long hashId = 0;

	if(szString == 0)
		return 0;

	for(int c,q=0, tmp; c=(int)szString[q]; q++)
	{
		if((c>='A')&&(c<='Z'))
			c+='a'-'A';

		hashId = (hashId << 4) + c;
		if( (tmp = hashId & 0xF0000000) != 0 )
		{
			hashId ^= (tmp >> 24);
			hashId &= ~tmp;
		}
	}

	return (hashId&0x7FFFFFFF);
}

. . . .
// compute collision impulse
float imp = vnd / ((pObjectA->getInverseMass() + pObjectB->getInverseMass()) + ((relativeContactPtA^normal)*(relativeContactPtA^normal)*pObjectA->getInverseInertia()) + ((relativeContactPtB^normal)*(relativeContactPtB^normal)*pObjectB->getInverseInertia()));
CVector2 impulse = ( normal * (-1.0f * (1.0f + fRestitution) * imp) ) + ( vec * (fDynamicFriction * imp) );
. . . .

bool CExpressionBuilder::formExpressionsAtDepth(int nDepth)
{
	std::list<BUILDERNODE>::iterator iter, iterLeft, iterRight;
	BUILDERNODE *curNode;
	LEXTOKEN *curToken;
	IExpression *expression, *pLeft, *pRight;
	int curPrecedence;
	int nOperatorID;

	IREPORT(formExpressionsAtDepth);

	// traverse the list, looking for immediate tokens (values/identifiers) at specified depth.
	// if the token is a value or identifier, wrap it into Value or Identifier expression
	for(iter = m_buildnodes.begin(); iter != m_buildnodes.end(); iter++)
	{
		curNode=&(*iter);

		// ignore processing preexisting expressions, and verify depth
		if( (curNode->depth == nDepth) && (!curNode->isExpression) )
		{
			curToken = curNode->pToken;

			// check for identifiers
			if( (curToken->type == TOKEN_IDENTIFIER) || (curToken->type == TOKEN_LOCALIDENTIFIER) )
				expression = formExpression_identifier(curToken);
			else
				// check for values
				if( (curToken->type == TOKEN_VALUE_INT)		||
					(curToken->type == TOKEN_VALUE_FLOAT)	||
					(curToken->type == TOKEN_VALUE_VECTOR)	|| 
					(curToken->type == TOKEN_VALUE_STRING) )
					expression = formExpression_value(curToken);
				else
					// dont do anything to tokens that are not values or identifiers
					continue;

			// make sure we could form the immediate expression
			if(expression == 0)
			{
				report(RL_ERROR, "Could not wrap value/identifier token");

				IFAIL();
				return false;
			}

			// set the expression's owner
			expression->m_pScript = m_pParser->m_pTargetScript;

			// replace the immediate with the wrapper expression
			curNode->pExpression = expression;
			curNode->isExpression = true;
		}
	}

	// we want to combine expressions using operator precedence, so traverse the list once for
	// each operator precedence level, starting with the highest. we skip processing precedence 0
	// because no operators assume this value. (technically i think an expression has a precedence of 0)
	for(curPrecedence=OPERATOR_MAX_PRECEDENCE; curPrecedence > 0; curPrecedence--)
	{
		// now traverse the list again, looking for operators of current precedence that have expressions associated with them
		// on the proper depth, wrapping those operations into Binary, Prefix, and Postfix expressions
		for(iter = m_buildnodes.begin(); iter != m_buildnodes.end(); iter++)
		{
			curNode=&(*iter);

			// we want to examine operators of current depth (note this excludes parens and subscripts, which have depths of -1, because they are non-functional operators)
			if( (curNode->depth == nDepth) && (!curNode->isExpression) && (curNode->pToken->type == TOKEN_OPERATOR) )
			{
				// curToken should contain an int; an enum of OPERATORS, not past NUM_OPERATORS
				curToken = curNode->pToken;
				nOperatorID = curToken->token.getInt();

				// lets verify that the operator is a functional one
				if( (nOperatorID < 0) || (nOperatorID >= NUM_OPERATORS) )
				{
					report(RL_WARNING, "Rejected attempt to combine expressions with non-functional operator (opID: %d)", nOperatorID);

					// skip
					continue;
				}

				// make sure operator is of current precedence (using operator id as index into lookup table)
				if(CExpressionBuilder::s_pOperatorPrecedences[nOperatorID] != curPrecedence)
					// skip if not
					continue;

				// aquire a left-side operand of equal or higher depth based on current position
				if(aquireOperand(iter, nDepth, -1, iterLeft))
					// aquire left side expression
					pLeft = (*iterLeft).pExpression;
				else
					// no left side
					pLeft = 0;

				// aquire a right-side operand of equal or higher depth based on current position
				if(aquireOperand(iter, nDepth, 1, iterRight))
					// aquire right side expression
					pRight = (*iterRight).pExpression;
				else
					// no right side
					pRight = 0;

				// form the expression
				expression = combineExpressions(nOperatorID, pLeft, pRight);

				// if we successfully combined the expressions, we should delete the nodes involved
				if(expression != 0)
				{
					// set the expression's owner
					expression->m_pScript = m_pParser->m_pTargetScript;

					// recycle the operator's node to contain the resulting expression.
					curNode->pExpression = expression;
					curNode->isExpression = true;

					// if a left side was used, erase it
					if(pLeft != 0)
						m_buildnodes.erase(iterLeft);

					// if a right side was used, erase it
                    if(pRight != 0)
						m_buildnodes.erase(iterRight);
				} else
					report(RL_WARNING, "Unable to combine expressions");
			}
		}
	}

	// success
	return true;
}

# jkras.cog     DCP 07
#
#
#  NOTE:  [in*] indicates that the parameter may be modified although it is not used
#         to return any meaningful value.
#
#
#  MATRIX:  4x4 matrix stored in 5 heap entries
#
#           0x 0y 0z 4x
#           1x 1y 1z 4y
#           2x 2y 2z 4z
#           3x 3y 3z  1
#
#
# HEAP:  The beginning of the heap contains the block definition. Each entry contains
#        2 values:  pointer to start of block, and size of block (in elements)
#
#        after the block definition is a temp pointers list of size hpmaxblocks
#
#        
#
################################################################################################

symbols

#  PROPERTIES PROVIDED BY USER
#-----------------------------------------------------------------------------------------------
# screen attributes
int		cellsWidth				# [const]	screen width
int		cellsHeight				# [const]	screen height
surface 	firstCell				# [const]	surface of pixel 0,0

# system attributes
cog		remoteheap				# [const]	an instantiation of rmtheap.cog



#  API CALLS
#-----------------------------------------------------------------------------------------------
# drawSolidTriangle
#
#   [parameters]
vector		tv0			local		# [in*]		triangle vertex 0
vector		tv1			local		# [in*]		triangle vertex 1
vector		tv2			local		# [in*]		triangle vertex 2
flex		tc0			local		# [in*]		triangle vertex color 0
flex		tc1			local		# [in*]		triangle vertex color 1
flex		tc2			local		# [in*]		triangle vertex color 2



#  INTERNAL METHODS
#-----------------------------------------------------------------------------------------------
# sortSolidTriangleVerts
#
#   uses drawXXXTriangle params (in/out)


# solidScanConvert
#
#   [parameters]
vector		cv0			local		# [in]		endpoint 0
vector		cv1			local		# [in]		endpoint 1
flex		cc0			local		# [in]		endpoint color 0
flex		cc1			local		# [in]		endpoint color 1
int		pedge			local		# [in/out]	edge pointer
int		pz			local		# [in/out]	depth value pointer
int		pcolor			local		# [in/out]	color pointer
int		edgeheight		local		# [out]		edge height


# drawSolidScanline
#
#   [parameters]
flex		sy			local		# [in]		pixel row
flex		sx0			local		# [in/out]	current pixel column
flex		sz0			local		# [in/out]	current pixel depth
flex		sc0			local		# [in/out]	current pixel color
flex		sx1			local		# [in]		ending pixel column
flex		sz1			local		# [in]		ending pixel depth
flex		sc1			local		# [in]		ending pixel color



#  HEAP METHODS
#-----------------------------------------------------------------------------------------------
# new
#
#  [parameters]
int		size			local		# [in]		requested element count
int		ptr			local		# [out]		pointer to allocated block


# delete
#
#  [parameters]
#int		ptr			local		# [in]		pointer to allocated block



# attributes
int		hpmaxblocks=0		local
int		hpnumblocks=0		local
int		hpdatsize=0		local

# temps
int		hpx			local



#  ENGINE HOOKS
#-----------------------------------------------------------------------------------------------
message		startup
message		pulse


end
code
################################################################################################

startup:
	SetPulse(0.01);


	totalheapsize = 0;


	// used for scan conversion
	reqheapsize = cellsHeight * 6;
	if(reqheapsize > totalheapsize) totalheapsize = reqheapsize;


	HeapNew(totalheapsize);

	jkStringClear();
	jkStringConcatASCIIString("Heap size: ");
	jkStringConcatInt(totalheapsize);
	jkStringOutput();

	blah = 0.0;

	return;

#-----------------------------------------------------------------------------------------------

pulse:
	// clear backbuffer
	for(x=cellsWidth*cellsHeight+firstCell-1; x>=0; x=x-1)
		ClearFaceType(x, 0xFF00);

	blah = blah + 0.05;
	if(blah >= 1.0)
		blah = 0.0;


	tv0 = VectorSet(40.0, 0.0, 0.0);	tc0 = 0;
	tv1 = VectorSet(0.0, 120.0, 0.0);	tc1 = 0;
	tv2 = VectorSet(100.0, 40.0, 0.0);	tc2 = blah;
	call drawSolidTriangle;


	// present backbuffer
	for(x=cellsWidth*cellsHeight+firstCell-1; x>=0; x=x-1)
		SetSurfaceLight(x, ((GetFaceType(x)/256)&0xFF)/255, 0);

	return;

#-----------------------------------------------------------------------------------------------

drawSolidTriangle:
	// clamp colors
	if(tc0 < 0.0) tc0 = 0.0;
	else if(tc0 > 1.0) tc0 = 1.0;
	if(tc1 < 0.0) tc1 = 0.0;
	else if(tc1 > 1.0) tc1 = 1.0;
	if(tc2 < 0.0) tc2 = 0.0;
	else if(tc2 > 1.0) tc2 = 1.0;

	call sortSolidTriangleVerts;


	edge0 = 0; edge1 = edge0+cellsHeight;
	z0 = edge1+cellsHeight; z1 = z0+cellsHeight;
	color0 = z1+cellsHeight; color1=color0+cellsHeight;

	// determine horizontal orientation
	if(VectorX(tv2) <= VectorX(tv1))
	{
		edgeL = edge0; edgeR = edge1;
		zL = z0; zR = z1;
		colorL = color0; colorR = color1;
	} else {
		edgeL = edge1; edgeR = edge0;
		zL = z1; zR = z0;
		colorL = color1; colorR = color0;
	}

	cv0 = tv0; cc0 = tc0;
	cv1 = tv1; cc1 = tc1;
	pedge = edge1; pz = z1; pcolor = color1;
	call solidScanConvert;

	cv0 = tv1; cc0 = tc1;
	cv1 = tv2; cc1 = tc2;
	pedge = edge1+edgeheight; pz = z1+edgeheight; pcolor = color1+edgeheight;
	call solidScanConvert;

	cv0 = tv0; cc0 = tc0;
	cv1 = tv2; cc1 = tc2;
	pedge = edge0; pz = z0; pcolor = color0;
	call solidScanConvert;

	// rasterize scanlines
	offptr = 0;
	for(sy = VectorY(tv0); edgeheight > 0; sy=sy-1.0)
	{
		sx0 = HeapGet(edgeL+offptr); sx1 = HeapGet(edgeR+offptr);
		sz0 = HeapGet(zL+offptr); sz1 = HeapGet(zR+offptr);
		sc0 = HeapGet(colorL+offptr); sc1 = HeapGet(colorR+offptr);
		call drawSolidScanline;
		offptr = offptr + 1;
		edgeheight = edgeheight - 1;
	}

	printflex(tc1);

	return;

#-----------------------------------------------------------------------------------------------

sortSolidTriangleVerts:
	y0g1 = VectorY(tv0) > VectorY(tv1);
	y0g2 = VectorY(tv0) > VectorY(tv2);
	y1g2 = VectorY(tv1) > VectorY(tv2);

	if(y0g1 && y0g2)
	{
		if(!y1g2)
		{
			tempv = tv1; tempc = tc1;
			tv1 = tv2; tc1 = tc2;
			tv2 = tempv; tc2 = tempc;
		}
	} else if( (!y0g1) && y1g2 )
	{
		tempv = tv0; tempc = tc0;
		tv0 = tv1; tc0 = tc1;
		if(y0g2)
		{
			tv1 = tempv; tc1 = tempc;
		} else {
			tv1 = tv2; tc1 = tc2;
			tv2 = tempv; tc2 = tempc;
		}
	} else {
		tempv = tv0; tempc = tc0;
		tv0 = tv2; tc0 = tc2;
		if(y0g1)
		{
			tv2 = tv1; tc2 = tc1;
			tv1 = tempv; tc1 = tempc;
		} else {
			tv2 = tempv; tc2 = tempc;
		}
	}

	return;

#-----------------------------------------------------------------------------------------------

solidScanConvert:
	edgeheight = (VectorY(cv0)-VectorY(cv1) + 0.999) & 0xFFFF;
	if(edgeheight < 1)
		return;

	y = edgeheight;

	// calculate interpolation slopes
	dedge = ( VectorX(cv1)-VectorX(cv0) ) / edgeheight;
	dz = ( VectorZ(cv1)-VectorZ(cv0) ) / edgeheight;
	dcolor = ( cc1 - cc0 ) / edgeheight;

	// initialize values
	curedge = VectorX(cv0);
	curz = VectorZ(cv0);
	curcolor = cc0;

	while(y > 0)
	{
		// store interpolated edge values
		HeapSet(pedge, curedge); pedge=pedge+1;
		HeapSet(pz, curz); pz=pz+1;
		HeapSet(pcolor, curcolor); pcolor=pcolor+1;

		// continue iteration and interpolate
		y=y-1;
		curedge=curedge+dedge;
		curz=curz+dz;
		curcolor=curcolor+dcolor;
	}

	return;

#-----------------------------------------------------------------------------------------------

drawSolidScanline:
	//if(sx1 < sx0)
	//	return;

	zX = (sz1-sz0) / (sx1-sx0);
	cX = (sc1-sc1) / (sx1-sx0);

	while(sx0<=sx1)
	{
		call drawSolidFragment;
		sx0 = sx0 + 1.0;
		sz0 = sz0 + zX;
		sc0 = sc0 + cX;
	}

	return;

#-----------------------------------------------------------------------------------------------

drawSolidFragment:
	sf = (sx0+sy*cellsWidth)&0xFFFFFF;

	// handle depth/stencil check and update here


	// set the pixel
	ClearFaceType(sf, 0xFF00);
	SetFaceType(sf, ((sc0*255)*256)&0xFF00);

	return;

#-----------------------------------------------------------------------------------------------

new:
	// try to find a free block that's big enough
	call dumbnew;
	if(ptr != -1)
		return;

	// heap is consumed; need to allocate more blocks


	// dump heap to remote, if applicable
	hptemp = hpmaxblocks*2+hpdatsize;
	if(hptemp>0)
	{
		SendMessage(remoteheap, user0, 1, hptemp, -1, -1);
		for(hpx=0; hpx<hptemp, hpx=hpx+4)
			SendMessage(remoteheap, user0, heapget(hpx), heapget(hpx+1), heapget(hpx+2), heapget(hpx+3));
	}

	// grow heap
	hpdatsize = hpdatsize+size;
	hpmaxblocks = hpmaxblocks+1;
	heapnew(hpmaxblocks*2+hpdatsize);

	// restore previous blocks, if applicable
	if(hptemp>0)
	{

	}

	// establish new pointer
	ptr = hpdatsize-size-1;

	// write new block
	hpx = (hpmaxblocks-1)*2;
	heapset(hpx, ptr);
	heapset(hpx+1, size*-1);    // flag as used
	return;

dumbnew:
	for(hpx=0; hpx<hpmaxblocks; hpx=hpx+1)
		if(heapget(hpx*2+1)>=size)
		{
			
			ptr=heapget(hpx*2);
			heapset(hpx*2+1, heapget(hpx*2+1)*-1);	 // flag as used
			return;	
		}
	ptr=-1;
	return;

#-----------------------------------------------------------------------------------------------

delete:

	return;

################################################################################################

end

Stored proc:
select
	a.this, b.this, a.that
from
	tblA a, tblB b
where
	b.here in (
		select a.pkLOL from tblA a where a.fkDongs = 'big'
	)

cX = (sc1-sc1) / (sx1-sx0);