//<!--
//*****************************************************************************//
// (C) Copyright Virtual Mechanics 1998 Version 1.20, All rights reserved.     //
// All copies of this software must include this Copyright notice.             //
//*****************************************************************************//
var Version = 0;
var newPage = 0;
nm = new Array();
Active = new Array();
ob   = new Array();
cpox = new Array();
cpoy = new Array();
spox = new Array();
spoy = new Array();
epox = new Array();
epoy = new Array();
var Lpox;
var Lpoy;
dpox = new Array();
dpoy = new Array();
atDis  = new Array();
DisPt  = new Array();
disStep = new Array();
Plen = new Array();
Path = new Array();
obRef= new Array();
Gtyp = new Array();
Gnpt=new Array();
Gnam = new Array();
Glen = new Array();
Gszx = new Array();
Gszy = new Array();
Gorx = new Array();
Gory = new Array();
Gpxl = new Array();
Gpyl = new Array();
Gbrl = new Array();
Gbrt = new Array();
Gbrr = new Array();
Gbrb = new Array();
Grps = new Array();
Grpl = new Array();
Gspt = new Array();
Snam = new Array();
Scnt = new Array();
PathCount = new Array();
LastPt  = new Array();
lstVal = new Array();

TimeLeft = new Array();
AEvent = new Array();
WDEvent = new Array();
WAEvent = new Array();
AValue = new Array();
ATime = new Array();
AEnter = new Array();
ALeave = new Array();
AKey = new Array();
IKey = new Array();
DEvent = new Array();
DValue = new Array();
DTime = new Array();
DEnter = new Array();
DLeave = new Array();
DAKey = new Array();
DIKey = new Array();
WASOp  = new Array();
WAGOp  = new Array();
OpForm = new Array();
WAAObj = new Array();
WADObj = new Array();
WAForm = new Array();
WASVal = new Array();
WAGVal = new Array();
WACgeo = new Array();
WACsnd = new Array();
WACact = new Array();
WACevt = new Array();
WACatt = new Array();
WACobj = new Array();
WANobj = new Array();
WALink = new Array();
WDAObj = new Array();
WDDObj = new Array();
EndPath = new Array();
MType = new Array();

MPath  = new Array();
MRate  = new Array();
MTime  = new Array();
MDelay = new Array();
MRepeat= new Array();
MCount = new Array();
MPLen  = new Array();
MDir   = new Array();
MGWst  = new Array();
MGNth  = new Array();
MGEst  = new Array();
MGSth  = new Array();

eDELAY = (1);
eDELAY_TIME = (2);
eMOUSE = (4);
eMOUSE_OVER = (8);
eLMOUSE = (16);
eRMOUSE = (32);
eKEY = (64);
eOBJECT_ENTER = (128);
eOBJECT_ENTER_LIST = (256);
eOBJECT_LEAVE = (512);
eOBJECT_LEAVE_LIST = (1024);
eLT_VALUE =	(2048);
eEQ_VALUE = (4096);
eGT_VALUE =	(8192);
eVALUE	  = (16384);
eENDPATH  = (32768);
eACTIVATE_1 = (65536);
eACTIVATE_2	= (131072);
eANDtest = (1<<30);
var pageTime = -1;// link timer
var Cobj;
var Catt;
var Cact;
var Cevt;
var Cgrp;
var Cgeo;
var Csnd;
var Cpob;
var Gpgo;
var gcx;
var gcy;
var gcx;
var gcy;
var cmx = 0;
var cmy = 0;
var smx = -9999;
var smy = -9999;
var slm = 0;
var llm = -9999;
var sky = " ";
var lstsnd = -1;

var lmx = -9999;
var lmy = -9999;
var lky = 0;
var totObj;
var mS;
var mW;
var waitTime;
var GEO_TYPE = 7;
var GEO_OPEN = 8;
var GEO_COUNT= 32;
ACT_XPATH_STOP	 =(0);
ACT_XPATH_OBJPTH =(1<<0);
ACT_XPATH_OBJXYZ =(1<<1);
ACT_XPATH_LEFT   =(1<<2);
ACT_XPATH_RIGHT  =(1<<3);
ACT_XPATH_MOUSE	 =(1<<4);
ACT_YPATH_STOP	 =(0);
ACT_YPATH_OBJPTH =(1<<8);
ACT_YPATH_OBJXYZ =(1<<9);
ACT_YPATH_UP     =(1<<10);
ACT_YPATH_DOWN   =(1<<11);
ACT_YPATH_MOUSE	 =(1<<12);
ACT_ZPATH_STOP	 =(0);
ACT_ZPATH_OBJPTH =(1<<16);
ACT_ZPATH_OBJXYZ =(1<<17);
ACT_ZPATH_IN	 =(1<<18);
ACT_ZPATH_OUT	 =(1<<19);
ACT_ZPATH_KEY	 =(1<<20);
ACT_PATH_STOP	 =(0);
ACT_PATH_START	 =(1<<24);
ACT_PATH_CENTER	 =(1<<25);
ACT_PATH_END	 =(1<<26);
ACT_GEO_WEST     =(1<<28);
ACT_GEO_EAST     =(1<<29);
ACT_GEO_NORTH    =(1<<30);
ACT_GEO_SOUTH    =(1<<31);
ACT_SETX		 =(0xffffff00);
ACT_SETY		 =(0xffff00ff);
ACT_SETZ		 =(0xff00ffff);
ACT_SETO		 =(0xf0ffffff);
ACT_SETF		 =(0x0fffffff);
ACT_GETX		 =(0x000000ff);
ACT_GETY		 =(0x0000ff00);
ACT_GETZ		 =(0x00ff0000);
ACT_GETO		 =(0x0f000000);
ACT_GETF		 =(0xf0000000);

/**************************************************************************/
var isNav4 = false, isIE4 = false;
if (navigator.appVersion.charAt(0) >= "4") {
if (navigator.appName == "Netscape") {
	isNav4 = true;
	window.captureEvents(Event.MOUSEUP|Event.MOUSEDOWN|Event.MOUSEMOVE|Event.KEYPRESS);
	window.onmousedown=NNmouseDown;
	window.onmouseup=NNmouseUp;
	window.onmousemove=NNmouseMove;
	window.onkeypress=NNkeyPress;
}
else if (navigator.appVersion.indexOf("MSIE") != -1) {
	window.document.onmousemove = IEmouseMove;
	window.document.onkeypress  = IEkeyPress;
	window.document.onmousedown = IEmouseDown;
	window.document.onmouseup   = IEmouseUp;
	window.document.onkeydown   = IEkeyPress;
	window.document.ondragstart = IECancelEvent;
	isIE4 = true;
}
}
function NNmouseMove(e) {
	cmx = e.pageX;
	cmy = e.pageY;
	sclx = window.pageXOffset;
	scly = window.pageYOffset;
}
function NNmouseDown(e) {
	slm = slm | 1;
	document.onmousemove=drag;
	document.onmouseup=enddrag;
	smx=e.pageX;
	smy=e.pageY + window.pageYOffset;
	return true;
}
function enddrag(e) {
	slm = slm | 2;
	smx = e.pageX + window.pageXOffset;
	smy = e.pageY + window.pageYOffset;
	document.onmousemove=0;
	document.releaseEvents(Event.MOUSEMOVE);
	document.releaseEvents(Event.MOUSEUP);
	window.captureEvents(Event.MOUSEMOVE|Event.MOUSEDOWN|Event.KEYPRESS);
	return false;
}
function drag(e) {
	cmx = e.pageX + window.pageXOffset;
	cmy = e.pageY + window.pageYOffset;
}

function NNmouseUp(e) {
	slm = slm | 2 + window.pageXOffset;
	smx = e.pageX + window.pageXOffset;
	smy = e.pageY + window.pageYOffset;
}

function NNkeyPress(e) {
	sky = String.fromCharCode(e.which);
}

function IEmouseMove() {
	cmx = window.event.clientX + document.body.scrollLeft;
	cmy = window.event.clientY + document.body.scrollTop;
	sclx = document.body.scrollLeft;
	scly = document.body.scrollTop;
}

function IEmouseDown() {
	slm = slm | 1;
	smx = window.event.clientX + document.body.scrollLeft;
	smy = window.event.clientY + document.body.scrollTop;
}

function IEmouseUp() {
	slm = slm | 2;
	smx = window.event.clientX + document.body.scrollLeft;
	smy = window.event.clientY + document.body.scrollTop;
}

function IEkeyPress() {
	sky = window.event.keyCode;
}
function IECancelEvent() {
	window.event.returnValue=false;
}
/**************************************************************************/
function Setup() {
// setup defaults
	tmCount=0;

	obRef[0] = 0;
	ob[0] = new Array();
	ob[0] = 0;
	ob[0].name = "Geo0";
	ob[0].geo = 0;
	ob[0].att = 0; 
	ob[0].evt = 0; 
	ob[0].act = 0;
	ob[0].grp = 0;
	ob[0].cpox =0.000000;
	ob[0].cpoy =0.000000;
	ob[0].cscx =1.000000;
	ob[0].cscy =1.000000;
	ob[0].crot =0.000000;
	ob[0].flg = 0;

	MPath[0]  = 0;

	for(nob=1; nob<= pageObj; nob++) {
		ref = pObjLst[nob];
		cobj = obRef[ref];
		spox[cobj] = ob[cobj].cpox;  
		spoy[cobj] = ob[cobj].cpoy;
		SetPath(cobj);

		reset(cobj);

		if(ob[cobj].flg & 16)
			Active[cobj]    =  4;	// set to initial active state
	}
}

/***************************************************************************/
function ticktime() {
	doObjectList();
	window.setTimeout("ticktime();", waitTime, "JavaScript");
}

function doObjectList() {
	if(newPage == 1) window.location=WALink[Cevt];

	if(pageTime >= 0)
	{
		tmCount++;
		if(tmCount > pageTime) 
		{
			window.location=pgLink;
			pageTime = -1;
		}
	}

	if(lmx == smx) smx = -99999;
	if(lmy == smy) smy = -99999;
	if(lky == sky) sky = " ";
	llt = 0;
	if((llm & 2) == (slm & 2)) slm = (slm  & ~2);
	if((llm & 1) == (slm & 1)) slm = (slm  & ~1);
	lmx = smx;
	lmy = smy;
	lky = sky;
	llm = slm;

	MoOvrTst();

	for(nob=1; nob<= pageObj; nob++) {
		ref = pObjLst[nob];
		gcx = 0;
		gcy = 0;
		cobj = obRef[ref]
		Cgrp = ob[cobj].grp;
		if(!Cgrp) doObject(cobj);
	}
}

function MoOvrTst() {
for(i=0; i < MoLNo; i++) {
  Cobj = Molst[i];
  Cgeo = ob[Cobj].geo;
  if(Version <= 105) 
  {
	  if(MouseOver() == 1) {
		if(ob[Cobj].flg & 256) setVisibility("visible");
		else                   setVisibility("hidden");
	  }
	  else {
		if(ob[Cobj].flg & 128) setVisibility("visible");
		else                   setVisibility("hidden");
	  }
  }
  else if(ob[Cobj].flg & 512) 
  {
	  if(MouseOver() == 1) 
	  {
		if(ob[Cobj].flg & 128) setVisibility("visible");
		else                   setVisibility("hidden");
	  }
	  else 
	  {
		if(ob[Cobj].flg & 256) setVisibility("visible");
		else                   setVisibility("hidden");
	  }
  }
}}

function doObject(cobj)
{
	Cobj = cobj;
	Cgeo = ob[Cobj].geo;
	Csnd = ob[Cobj].snd;
	Cevt = ob[Cobj].evt;
	Catt = ob[Cobj].att;
	Cact = ob[Cobj].act;

	if(Cact)
	{			
		Cpob = MPath[Cact];
		if(Cpob)
			Cpgo = ob[Cpob].geo;
		else
			Cpgo = 0;
	}
	else
	{
		Cpob = 0;
		Cpgo = 0;
	}

	if(Cevt) Evtest();

	if     (Active[Cobj] == 4) whenActive();
	else if(Active[Cobj] == 2) whenDeactive();
	else if(Active[Cobj] == 1) isActive();
	else if(Active[Cobj] == 0) isDeactive();

	if(Cgeo && (Gtyp[Cgeo] & (1<<4)))
	{ 
		doGroup(Cgeo);
		return;
	}

}

function doGroup(cgrp)
{
	var gobj;
	gcx = cpox[Cobj];
	gcy = cpoy[Cobj];
	gobj = Cobj;
	for(i = 0; i < Grps[cgrp]; i++)
	{ 
		doObject(Grpl[cgrp][i]);
		ob[Cobj].style.left=gcx+cpox[Cobj] - Gszx[Cgeo] * ob[Cobj].cscx;
		ob[Cobj].style.top =gcy+cpoy[Cobj] - Gszy[Cgeo] * ob[Cobj].cscy;
	}
	return;
}

function setVisibility(code)
{
	if(Cgeo && (Gtyp[Cgeo] & (1<<4))) {
		for(i = 0; i < Grps[Cgeo]; i++) {
			ob[Grpl[Cgeo][i]].style.visibility = code;
		}
	}
		else
			ob[Cobj].style.visibility = code;
}

/*************************************************************************/
function UpdPos() {
Lpox = cpox[Cobj];
Lpoy = cpoy[Cobj];
// end of path condition
if(Plen[Cobj] > 0 && atDis[Cobj] >= Plen[Cobj]) 
{
	atDis[Cobj] -= Plen[Cobj];
	DisPt[Cobj]  = 0;
	LastPt[Cobj] = 0;
	cpox[Cobj]   = spox[Cobj];
	cpoy[Cobj]   = spoy[Cobj];
}
if(MType[Cact] & ACT_XPATH_OBJXYZ) 
{
	cpox[Cobj] = cpox[Cpob];
	cpoy[Cobj] = cpoy[Cpob];
}
else if(MType[Cact] & ACT_XPATH_OBJPTH)
{
	if     ((Gtyp[Cpgo] & GEO_TYPE) == 1)
		GetRectLoc();
	else if((Gtyp[Cpgo] & GEO_TYPE) == 2) 
	{
		GetArcLoc();
	}
	else if((Gtyp[Cpgo] & GEO_TYPE) == 3)
	{
		GetPathLoc();
	}
	cpox[Cobj] += cpox[Cpob];
	cpoy[Cobj] += cpoy[Cpob];
}
else
{
	if(MType[Cact] & ACT_XPATH_MOUSE)
		cpox[Cobj] = cmx;
	else
		cpox[Cobj] += dpox[Cobj]; //^^ is this STOP?

	if(MType[Cact] & ACT_YPATH_MOUSE)
		cpoy[Cobj] = cmy;
	else
		cpoy[Cobj] += dpoy[Cobj];
}
if(Plen[Cobj] != 0) atDis[Cobj] += disStep[Cobj];
ob[Cobj].style.left=cpox[Cobj] - Gszx[Cgeo] * ob[Cobj].cscx;
ob[Cobj].style.top =cpoy[Cobj] - Gszy[Cgeo] * ob[Cobj].cscy;

if(Plen[Cobj] > 0 && atDis[Cobj] >= Plen[Cobj]) 
{
	if(PathCount[Cobj] > 0) PathCount[Cobj]--;
	if(PathCount[Cobj] == 0) {
		EndPath[Cobj] = 1;
		ob[Cobj].style.left=epox[Cobj] - Gszx[Cgeo] * ob[Cobj].cscx;
		ob[Cobj].style.top =epoy[Cobj] - Gszy[Cgeo] * ob[Cobj].cscy;
	}
}
if(Cact) UpdGeo();
return;
}

function UpdGeo() {
	var drx = Lpox - cpox[Cobj];
	var dry = Lpoy - cpoy[Cobj];
	if(Math.abs(dry) > Math.abs(drx))
	{
		if    ((dry < 0) && (MDir[Cobj] != 270))
		{
			if(MType[Cact] & (ACT_GEO_SOUTH))
			{
				ob[Cobj].image.src = Gspt[MGSth[Cact]].src;
			}
			MDir[Cobj] = 270;
		}
		else  if((dry >= 0) && MDir[Cobj] != 90)
		{
			if(MType[Cact] & (ACT_GEO_NORTH))
			{ 
				ob[Cobj].image.src = Gspt[MGNth[Cact]].src;
			}
			MDir[Cobj] = 90;
		}
	}
	else
	{
		if    ((drx > 0) && (MDir[Cobj] != 0))
		{
			if(MType[Cact] & (ACT_GEO_WEST))
			{ 
				ob[Cobj].image.src = Gspt[MGWst[Cact]].src;
			}
			MDir[Cobj] = 0;
		}
		else  if((drx <= 0) && MDir[Cobj] != 180)
		{
			if(MType[Cact] & (ACT_GEO_EAST))
			{ 
				ob[Cobj].image.src = Gspt[MGEst[Cact]].src;
			}
			MDir[Cobj] = 180;
		}
	}
return;
}

function UpdStr() {
	if(lstVal[Cobj] == ob[Cobj].val) return;
	lstVal[Cobj] = ob[Cobj].val;
	if(isIE4)
		ob[Cobj].name.innerText = ob[Cobj].val;
	else
		window.status = "Object " + ob[Cobj].name + " Counter=" + ob[Cobj].val;

	return;
}

function UpdAudio(on)
{
	if(isIE4)
	{
		if(on > 0)
		{
			if(Scnt[Csnd] < 0) Scnt[Csnd] = 9999;
			SoundEffect.loop= Scnt[Csnd];
			SoundEffect.src = Snam[Csnd];
//			SoundEffect.autostart=1;
			lstsnd = Csnd;
		}
		else
		{
			if(lstsnd != Csnd) return;
			SoundEffect.src= " ";
			SoundEffect.loop= 0;
			SoundEffect.autostart=0;
		}
	}
	else if(isNav4) 
	{
//		<embed id = BackMusic  src=Snam[Csnd] autostart=true loop= Scnt[Csnd] hidden=true></embed>
	}
}

/**************************************************************************/
function GetArcLoc() {
if(MRate[Cact] > 0) 
{
	cpox[Cobj] = (Math.sin(0.017453292*(-atDis[Cobj]-90)) * Gszx[Cpgo]) * ob[Cpob].cscx;
	cpoy[Cobj] = (Math.cos(0.017453292*(-atDis[Cobj]-90)) * Gszy[Cpgo]) * ob[Cpob].cscy;
}
else 
{
	cpox[Cobj] = (Math.sin(0.017453292*(atDis[Cobj]-90)) * Gszx[Cpgo]) * ob[Cpob].cscx;
	cpoy[Cobj] = (Math.cos(0.017453292*(atDis[Cobj]-90)) * Gszy[Cpgo]) * ob[Cpob].cscy;
}
return;
}
/*************************************************************************/
function GetPathLoc() {
var cPt, nPt, x, y, dis=0.0, ratio=0.0, ct = 0;

if(MRate[Cact] > 0) 
{
	while(ct <= Gnpt[Cpgo]) 
	{
		ct ++;
		if(LastPt[Cobj]+1 < Gnpt[Cpgo]) 
		{
			cPt = LastPt[Cobj];
			nPt = cPt + 1; 
		}
		else
		{
			if(Gtyp[Cpgo] & GEO_OPEN) 
			{
				LastPt[Cobj]  = 0;
				cPt = 0;
				nPt = 1; 
			}
			else 
			{
				LastPt[Cobj]  = Gnpt[Cpgo]-1;
				cPt = LastPt[Cobj];
				nPt = 0; 
			}
		}
		x  = (Gpxl[Cpgo][nPt] - Gpxl[Cpgo][cPt]) * ob[Cpob].cscx;
		y  = (Gpyl[Cpgo][nPt] - Gpyl[Cpgo][cPt]) * ob[Cpob].cscy;
		dis = Math.sqrt(x*x + y*y);
		if(atDis[Cobj] < (dis + DisPt[Cobj])) break;
		DisPt[Cobj] += dis;
		LastPt[Cobj]++;
		if(LastPt[Cobj] >= Gnpt[Cpgo]) 
		{
			cPt = 0;
			nPt = 1;
		}
	}
	ratio = (atDis[Cobj] - DisPt[Cobj]) / dis;
	cpox[Cobj] = Gpxl[Cpgo][cPt] * ob[Cpob].cscx + x * ratio;
	cpoy[Cobj] = Gpyl[Cpgo][cPt] * ob[Cpob].cscy + y * ratio;

	return;
}
else 
{
	nPt = LastPt[Cobj];
	if(nPt == Gnpt[Cpgo]-1)
		cPt = 0;
	else
		cPt = nPt; 
	while(ct <= Gnpt[Cpgo]) 
	{
		ct ++;
		if(nPt > 0) 
		{
			cPt = nPt;
			nPt--; 
		}
		else 
		{
			if(Gtyp[Cpgo] & GEO_OPEN) 
			{
				LastPt[Cobj]  = Gnpt[Cpgo]-1;
				cPt = LastPt[Cobj];
				nPt = cPt-1; 
			}
			else 
			{
				cPt = 0;
				nPt = Gnpt[Cpgo]-1; 
				LastPt[Cobj]  = nPt;
			}
		}

		x  = (Gpxl[Cpgo][nPt] - Gpxl[Cpgo][cPt]) * ob[Cpob].cscx;
		y  = (Gpyl[Cpgo][nPt] - Gpyl[Cpgo][cPt]) * ob[Cpob].cscy;
		dis = Math.sqrt(x*x + y*y);
		if(atDis[Cobj] < (dis + DisPt[Cobj])) break;
		DisPt[Cobj] += dis;
		LastPt[Cobj]--;
	}
	ratio = (atDis[Cobj] - DisPt[Cobj]) / dis;
	cpox[Cobj] = Gpxl[Cpgo][cPt] * ob[Cpob].cscx + x * ratio;
	cpoy[Cobj] = Gpyl[Cpgo][cPt] * ob[Cpob].cscy + y * ratio;

	return;
}
}
/************************************************************************/
function GetRectLoc() 
{
var dis = 0.0;

while (0==0) 
{
	if(MRate[Cact] > 0) 
	{
		if(LastPt[Cobj] == 0) 
		{
			dis = (Gpxl[Cpgo][1] - Gpxl[Cpgo][0]) * ob[Cpob].cscx;
			if((DisPt[Cobj] + dis) > atDis[Cobj]) 
			{
				cpox[Cobj] = Gpxl[Cpgo][0] * ob[Cpob].cscx + atDis[Cobj];
				cpoy[Cobj] = Gpyl[Cpgo][0] * ob[Cpob].cscy;
				break; 
			}
			LastPt[Cobj] = 1;
			DisPt[Cobj] += dis; 
		}
		if(LastPt[Cobj] == 1) 
		{
			dis = (Gpyl[Cpgo][1] - Gpyl[Cpgo][0]) * ob[Cpob].cscy;
			if((DisPt[Cobj] + dis) > atDis[Cobj]) 
			{
				cpox[Cobj] = Gpxl[Cpgo][1] * ob[Cpob].cscx;
				cpoy[Cobj] = Gpyl[Cpgo][0] * ob[Cpob].cscy + (atDis[Cobj]-DisPt[Cobj]);
				break;
			}
			DisPt[Cobj] += dis;
			LastPt[Cobj] = 2;
		}
		if(LastPt[Cobj] == 2) 
		{
			dis = (Gpxl[Cpgo][1] - Gpxl[Cpgo][0]) * ob[Cpob].cscx;
			if((DisPt[Cobj] + dis) > atDis[Cobj]) 
			{
				cpox[Cobj] = Gpxl[Cpgo][1] * ob[Cpob].cscx - (atDis[Cobj]-DisPt[Cobj]);
				cpoy[Cobj] = Gpyl[Cpgo][1] * ob[Cpob].cscy;
				break; 
			}
			DisPt[Cobj] += dis;
			LastPt[Cobj] = 3; 
		}
		if(LastPt[Cobj] == 3) 
		{
			dis = (Gpyl[Cpgo][1] - Gpyl[Cpgo][0]) * ob[Cpob].cscy;
			if((DisPt[Cobj] + dis) > atDis[Cobj]) 
			{
				cpox[Cobj] = Gpxl[Cpgo][0] * ob[Cpob].cscx;
				cpoy[Cobj] = Gpyl[Cpgo][1] * ob[Cpob].cscy - (atDis[Cobj]-DisPt[Cobj]);
				break;
			}
		}
	}
	else 
	{
		if(LastPt[Cobj] == 0) 
		{
			dis = (Gpyl[Cpgo][1] - Gpyl[Cpgo][0]) * ob[Cpob].cscy;
			if((DisPt[Cobj] + dis) > atDis[Cobj]) 
			{
				cpox[Cobj] = Gpxl[Cpgo][0] * ob[Cpob].cscx;
				cpoy[Cobj] = Gpyl[Cpgo][0] * ob[Cpob].cscy + atDis[Cobj];
				break; 
			}
			LastPt[Cobj] = 3;
			DisPt[Cobj] += dis; 
		}
		if(LastPt[Cobj] == 3) 
		{
			dis = (Gpxl[Cpgo][1] - Gpxl[Cpgo][0]) * ob[Cpob].cscx;
			if((DisPt[Cobj] + dis) > atDis[Cobj]) 
			{
				cpox[Cobj] = Gpxl[Cpgo][0] * ob[Cpob].cscx + (atDis[Cobj]-DisPt[Cobj]);
				cpoy[Cobj] = Gpyl[Cpgo][1] * ob[Cpob].cscy;
				break;
			}
			DisPt[Cobj] += dis;
			LastPt[Cobj] = 2;
		}
		if(LastPt[Cobj] == 2) 
		{
			dis = (Gpyl[Cpgo][1] - Gpyl[Cpgo][0]) * ob[Cpob].cscy;
			if((DisPt[Cobj] + dis) > atDis[Cobj]) 
			{
				cpox[Cobj] = Gpxl[Cpgo][1] * ob[Cpob].cscx;
				cpoy[Cobj] = Gpyl[Cpgo][1] * ob[Cpob].cscy - (atDis[Cobj]-DisPt[Cobj]);
				break; 
			}
			DisPt[Cobj] += dis;
			LastPt[Cobj] = 1; 
		}
		if(LastPt[Cobj] == 1) 
		{
			dis = (Gpxl[Cpgo][1] - Gpxl[Cpgo][0]) * ob[Cpob].cscx;
			if((DisPt[Cobj] + dis) > atDis[Cobj]) 
			{
				cpox[Cobj] = Gpxl[Cpgo][1] * ob[Cpob].cscx - (atDis[Cobj]-DisPt[Cobj]);
				cpoy[Cobj] = Gpyl[Cpgo][0] * ob[Cpob].cscy;
				break;
			}
		}
	}
}
return;
}
/****************************************************************************/
function Evtest() 
{
	if(Active[Cobj] == 0) 
	{
		if(AEvent[Cevt] & eANDtest)
			ActANDTest();
		else
			ActORTest();
	}
	else if(Active[Cobj] == 1) {
		if(DEvent[Cevt] & eANDtest)
			DeactANDTest();
		else
			DeactORTest();
	}
return;
}
/***************************************************************************/
function ActORTest()
{
if(((AEvent[Cevt] & eDELAY) 		&& TimeCount() <= 0  ) ||
  ( (AEvent[Cevt] & eOBJECT_ENTER)	&& ObjectEnter(AEnter[Cevt])  ) ||
  ( (AEvent[Cevt] & eOBJECT_LEAVE) 	&& ObjectLeave(ALeave[Cevt])  ) ||
  ( (AEvent[Cevt] & eMOUSE)			&& MouseSelect() > 0 ) ||
  ( (AEvent[Cevt] & eMOUSE_OVER)	&& MouseOver()   ) ||
  ( (AEvent[Cevt] & eLMOUSE)		&& IsMouseLClick()   ) ||
  ( (AEvent[Cevt] & eRMOUSE)		&& IsMouseRClick()   ) ||
  ( (AEvent[Cevt] & eKEY)			&& KeyChar()   ) ||
  ( (AEvent[Cevt] & eLT_VALUE)		&& ob[Cobj].val <  AValue[Cevt]) ||
  ( (AEvent[Cevt] & eEQ_VALUE)		&& ob[Cobj].val == AValue[Cevt]) ||
  ( (AEvent[Cevt] & eGT_VALUE)		&& ob[Cobj].val >  AValue[Cevt]) ||
  ( (AEvent[Cevt] & eENDPATH)		&& EndPath[Cobj]     )   )
Active[Cobj] = 4;
}
/***************************************************************************/
function ActANDTest()
{
if(((AEvent[Cevt] & eDELAY) 		&& !(TimeCount() <= 0)  ) ||
  ( (AEvent[Cevt] & eOBJECT_ENTER)	&& !ObjectEnter(AEnter[Cevt])  ) ||
  ( (AEvent[Cevt] & eOBJECT_LEAVE) 	&& !ObjectLeave(ALeave[Cevt])  ) ||
  ( (AEvent[Cevt] & eMOUSE)			&& !(MouseSelect() > 0) ) ||
  ( (AEvent[Cevt] & eMOUSE_OVER)	&& !MouseOver()   ) ||
  ( (AEvent[Cevt] & eLMOUSE)		&& !IsMouseLClick()   ) ||
  ( (AEvent[Cevt] & eRMOUSE)		&& !IsMouseRClick()   ) ||
  ( (AEvent[Cevt] & eKEY)			&& !KeyChar()   ) ||
  ( (AEvent[Cevt] & eLT_VALUE)		&& !(ob[Cobj].val <  AValue[Cevt])) ||
  ( (AEvent[Cevt] & eEQ_VALUE)		&& !(ob[Cobj].val == AValue[Cevt])) ||
  ( (AEvent[Cevt] & eGT_VALUE)		&& !(ob[Cobj].val >  AValue[Cevt])) ||
  ( (AEvent[Cevt] & eENDPATH)		&& !EndPath[Cobj]     )   )
  {} else Active[Cobj] = 4;
}
/***************************************************************************/
function DeactORTest()
{

if(((DEvent[Cevt] & eDELAY) 		&& TimeCount() <= 0  ) ||
  ( (DEvent[Cevt] & eOBJECT_ENTER)	&& ObjectEnter(DEnter[Cevt])  ) ||
  ( (DEvent[Cevt] & eOBJECT_LEAVE) 	&& ObjectLeave(DLeave[Cevt])  ) ||
  ( (DEvent[Cevt] & eMOUSE)			&& MouseSelect() > 0 ) ||
  ( (DEvent[Cevt] & eMOUSE_OVER)	&& !MouseOver()   ) ||
  ( (DEvent[Cevt] & eLMOUSE)		&& IsMouseLClick()   ) ||
  ( (DEvent[Cevt] & eRMOUSE)		&& IsMouseRClick()   ) ||
  ( (DEvent[Cevt] & eKEY)			&& KeyChar()   ) ||
  ( (DEvent[Cevt] & eLT_VALUE)		&& ob[Cobj].val <  AValue[Cevt]) ||
  ( (DEvent[Cevt] & eEQ_VALUE)		&& ob[Cobj].val == AValue[Cevt]) ||
  ( (DEvent[Cevt] & eGT_VALUE)		&& ob[Cobj].val >  AValue[Cevt]) ||
  ( (DEvent[Cevt] & eENDPATH)		&& EndPath[Cobj]     )   )
	Active[Cobj] = 2;
}
/***************************************************************************/
function DeactANDTest()
{
if(((DEvent[Cevt] & eDELAY) 		&& !(TimeCount() <= 0)  ) ||
  ( (DEvent[Cevt] & eOBJECT_ENTER)	&& !ObjectEnter(DEnter[Cevt])  ) ||
  ( (DEvent[Cevt] & eOBJECT_LEAVE) 	&& !ObjectLeave(DLeave[Cevt])  ) ||
  ( (DEvent[Cevt] & eMOUSE)			&& !(MouseSelect() > 0) ) ||
  ( (DEvent[Cevt] & eMOUSE_OVER)	&& !MouseOver()   ) ||
  ( (DEvent[Cevt] & eLMOUSE)		&& !IsMouseLClick()   ) ||
  ( (DEvent[Cevt] & eRMOUSE)		&& !IsMouseRClick()   ) ||
  ( (DEvent[Cevt] & eKEY)			&& !KeyChar()   ) ||
  ( (DEvent[Cevt] & eLT_VALUE)		&& !(ob[Cobj].val <  AValue[Cevt])) ||
  ( (DEvent[Cevt] & eEQ_VALUE)		&& !(ob[Cobj].val == AValue[Cevt])) ||
  ( (DEvent[Cevt] & eGT_VALUE)		&& !(ob[Cobj].val >  AValue[Cevt])) ||
  ( (DEvent[Cevt] & eENDPATH)		&& !EndPath[Cobj]     )   )
  {} else Active[Cobj] = 2;
}
/**************************************************************************/
function TimeCount() {
	if(TimeLeft[Cobj] > 0)  
	{
		if(isNav4) TimeLeft[Cobj] -= 2;
		else       TimeLeft[Cobj] -= 1;
	}
	return (TimeLeft[Cobj]);
}

function ObjectEnter(eobj) {
x = Gszx[Cgeo] * ob[Cobj].cscx;
y = Gszy[Cgeo] * ob[Cobj].cscy;
if ( cpox[eobj] >= (cpox[Cobj] - x) && cpox[eobj] <= (cpox[Cobj]) + x &&
	  cpoy[eobj] >= (cpoy[Cobj] - y) && cpoy[eobj] <= (cpoy[Cobj]) + y )
	return 1;
return 0;
}

function ObjectLeave(eobj) {
x = Gszx[Cgeo] * ob[Cobj].cscx;
y = Gszy[Cgeo] * ob[Cobj].cscy;
if ( cpox[eobj] >= cpox[Cobj] - x && cpox[eobj] <= cpox[Cobj] + x &&
	 cpoy[eobj] >= cpoy[Cobj] - y && cpoy[eobj] <= cpoy[Cobj] + y )
	return 0;
return 1;
}

function MouseSelect() {
var val = 0;
if(smx == -99999) return val;
x = Gszx[Cgeo] * ob[Cobj].cscx;
y = Gszy[Cgeo] * ob[Cobj].cscy;
if ( smx >= cpox[Cobj] - x && smx <= cpox[Cobj] + x &&
	 smy >= cpoy[Cobj] - y && smy <= cpoy[Cobj] + y )
	return val = 1;
return val;
}

function MouseOver() {
x = Gszx[Cgeo] * ob[Cobj].cscx;
y = Gszy[Cgeo] * ob[Cobj].cscy;
if ( cmx >= cpox[Cobj] - x && cmx <= cpox[Cobj] + x &&
	 cmy >= cpoy[Cobj] - y && cmy <= cpoy[Cobj] + y ) {
	return 1;}
return 0;
}

function IsMouseLClick() {
return (slm && 1);
}

function IsMouseRClick() {
return (slm && 2);
}

function KeyChar() {
if(!sky) return 0;
if(isNav4 && (AKey[Cevt] == sky)) return 1;
if(isIE4  && (IKey[Cevt] == sky)) return 1;
return 0;
}

/***************************************************************************/
function isDeactive() {
	if(PathCount[Cobj] != 0) UpdPos();
	if(Gtyp[Cgeo] & GEO_COUNT) UpdStr();

return;
}
/***************************************************************************/
function isActive() {
	if(PathCount[Cobj] != 0) UpdPos();
	if(Gtyp[Cgeo] & GEO_COUNT) UpdStr();
return;
}
/***************************************************************************/
function whenActive()
{
	Active[Cobj]  = 1;
	EndPath[Cobj] = 0;

	// set default active events
	if(!Cevt)
	{
		TimeLeft[Cobj]  =  0;
		PathCount[Cobj] = 0;
		setVisibility("visible")
	}
	else
	{
//		if(WAEvent[Cevt] & (1<<14)) window.location=WALink[Cevt];
//		if(WAEvent[Cevt] & (1<<15)) window.location=WALink[Cevt];
		if(WAEvent[Cevt] & (1<<14) || WAEvent[Cevt] & (1<<15)) 
		{
			if (navigator.appName == "Netscape") waitTime = 100;
			newPage = 1;
		}

		if(Csnd > 0) UpdAudio((WAEvent[Cevt] & 16));
//		if(WAEvent[Cevt] & 16) UpdAudio(); //sound
		if(WAEvent[Cevt] & 8) setVisibility("visible");
		else                  setVisibility("hidden");

		TimeLeft[Cobj]  = DTime[Cevt];

		if(WAEvent[Cevt] & (1<<5)) Active[WAAObj[Cevt]] = 4;
		if(WAEvent[Cevt] & (1<<7)) Active[WADObj[Cevt]] = 2;

		// apply value
		if(WAEvent[Cevt] & (1<<13)) {
			if	   ((OpForm[Cevt] & 0x000f) == 0)
				ob[Cobj].val  = WAForm[Cevt];
			else if((OpForm[Cevt] & 0x000f) == 1)
				ob[Cobj].val += WAForm[Cevt];
			else if((OpForm[Cevt] & 0x000f) == 2)
				ob[Cobj].val -= WAForm[Cevt];
			else if((OpForm[Cevt] & 0x000f) == 3)
				ob[Cobj].val *= WAForm[Cevt];
			else if((OpForm[Cevt] & 0x000f) == 4)
				if(WAForm[Cevt] != 0) ob[Cobj].val /= WAForm[Cevt];
		}
		// get value
		if(WAEvent[Cevt] & (1<<11)) {
			if	   ((WAGOp[Cevt] & 0x000f) == 0)
				ob[Cobj].val  = ob[WAGVal[Cevt]].val;
			else if((WAGOp[Cevt] & 0x000f) == 1)
				ob[Cobj].val += ob[WAGVal[Cevt]].val;
			else if((WAGOp[Cevt] & 0x000f) == 2)
				ob[Cobj].val -= ob[WAGVal[Cevt]].val;
			else if((WAGOp[Cevt] & 0x000f) == 3)
				ob[Cobj].val*= ob[WAGVal[Cevt]].val;
			else if((WAGOp[Cevt] & 0x000f) == 4)
				if(ob[WAGVal[Cevt]].val != 0) ob[Cobj].val /= ob[WAGVal[Cevt]].val;
		}
		// send result
		if(WAEvent[Cevt] & (1<<9)) {
			if	   ((WASOp[Cevt] & 0x000f) == 0)
				ob[WASVal[Cevt]].val  = ob[Cobj].val;
			else if((WASOp[Cevt] & 0x000f) == 1)
				ob[WASVal[Cevt]].val += ob[Cobj].val;
			else if((WASOp[Cevt] & 0x000f) == 2)
				ob[WASVal[Cevt]].val -= ob[Cobj].val;
			else if((WASOp[Cevt] & 0x000f) == 3)
				ob[WASVal[Cevt]].val *= ob[Cobj].val;
			else if((WASOp[Cevt] & 0x000f) == 4)
				if(ob[Cobj].val != 0) ob[WASVal[Cobj]].val /= ob[Cobj].val;
		}
		if(WAEvent[Cevt] & 4) PathCount[Cobj] = MCount[Cact]; // motion
		// replace current object components
		if(WAEvent[Cevt] & (1<<17))
		{
			if(WAEvent[Cevt] & (1<<18)) {
				ob[Cobj].name = Gnam[WACgeo[Cevt]];
				ob[Cobj].geo  = WACgeo[Cevt];
			}
			if(WAEvent[Cevt] & (1<<19)) ob[Cobj].att  = WACatt[Cevt];
			if(WAEvent[Cevt] & (1<<20)) ob[Cobj].act  = WACact[Cevt];
			if(WAEvent[Cevt] & (1<<22)) ob[Cobj].evt  = WACevt[Cevt];
			spox[Cobj] = cpox[Cobj];  
			spoy[Cobj] = cpoy[Cobj];
			SetPath(Cobj);
		}
		// replace additional object components
		for(ref=0; ref< WACobj[Cevt]; ref++) {
			if(WAEvent[Cevt] & (1<<18)) {
				ob[WANobj[Cevt][ref]].name = Gnam[WACgeo[Cevt]];
				ob[WANobj[Cevt][ref]].geo  = WACgeo[Cevt];
			}
			if(WAEvent[Cevt] & (1<<19)) ob[WANobj[Cevt][ref]].att  = WACatt[Cevt];
			if(WAEvent[Cevt] & (1<<20)) ob[WANobj[Cevt][ref]].act  = WACact[Cevt];
			if(WAEvent[Cevt] & (1<<22)) ob[WANobj[Cevt][ref]].evt  = WACevt[Cevt];
			spox[WANobj[Cevt][ref]] = cpox[Cobj];  
			spoy[WANobj[Cevt][ref]] = cpoy[Cobj];
			SetPath(WANobj[Cevt][ref]);
		}

		if(WAEvent[Cevt] & (1<<30)) reset(Cobj);
	}
}
//**************************************************************************
function whenDeactive()
{

	EndPath[Cobj] = 0;
	Active[Cobj]  = 0;	// is deactive

	if(!Cevt) 
	{
		PathCount[Cobj] = -1;
		TimeLeft[Cobj]  =  0;
		setVisibility("hidden");
	}
	else
	{
		if(WDEvent[Cevt] & 4) PathCount[Cobj] = MCount[Cact]; // motion
		if(WDEvent[Cevt] & (1<<30)) reset(Cobj);

		if(Csnd > 0) UpdAudio((WDEvent[Cevt] & 16));	//sound
		if(WDEvent[Cevt] & 8) setVisibility("visible");
		else                  setVisibility("hidden");

		TimeLeft[Cobj]  = ATime[Cevt];
		if(WDEvent[Cevt] & 4) PathCount[Cobj] = MCount[Cact];	// motion
		else                  PathCount[Cobj] = 0;

		if(WDEvent[Cevt] & (1<<5)) Active[WDAObj[Cevt]] = 4;
		if(WDEvent[Cevt] & (1<<7)) Active[WDDObj[Cevt]] = 2;
	}

}

//**************************************************************************
function reset(cobj) {

	cobj = cobj;
	Cevt = ob[cobj].evt;
	Catt = ob[cobj].att;
	Cact = ob[cobj].act;
	Cgrp = ob[cobj].grp;
	Cgeo = ob[cobj].geo;
	Active[cobj]    =  0;	// is deactive
	if(Cevt)
	{
		if(WDEvent[Cevt] & 8) setVisibility("visible");
		else                  setVisibility("hidden");
		if(WDEvent[Cevt] & (1<<31)) {
			PathCount[cobj] = MCount[Cact];			// restart path
			cpox[cobj] = spox[cobj];
			cpoy[cobj] = spoy[cobj];
			LastPt[cobj] = 0;
			atDis[cobj] = 0;
			DisPt[cobj] = 0;
			EndPath[cobj] = 0;
		}
		if(!(WDEvent[Cevt] & 4)) PathCount[cobj] = 0;	// no motion
		TimeLeft[cobj]  = ATime[Cevt];
	}
	else
	{
	if(Version <= 105) {
			if(ob[cobj].flg & 64)
				setVisibility("hidden");
			else
				setVisibility("visible");
		}
		else {
			if(ob[cobj].flg & 64)
				setVisibility("visible");
			else
				setVisibility("hidden");
		}
		// set action variables
		if(Cact) PathCount[cobj] = MCount[Cact]; // motion
		else     PathCount[cobj] = 0;
		TimeLeft[cobj]  = 0;

		cpox[cobj] = spox[cobj];
		cpoy[cobj] = spoy[cobj];
		LastPt[cobj] = 0;
		atDis[cobj] = 0;
		DisPt[cobj] = 0;
		EndPath[cobj] = 0;
	}

	if(Cgeo) {
		ob[cobj].style.left=cpox[cobj] - Gszx[Cgeo] * ob[cobj].cscx;
		ob[cobj].style.top =cpoy[cobj] - Gszy[Cgeo] * ob[cobj].cscy;
	}

return;
}

/*************************************************************************/
function SetPath(cobj) {

	Cobj = cobj;
	Cevt = ob[Cobj].evt;	// Objects event
	Catt = ob[Cobj].att;	// Objects attribute
	Cact = ob[Cobj].act;	// Objects action
	Cgrp = ob[Cobj].grp;	// Objects group
	Cgeo = ob[Cobj].geo;	// Objects geometry
	Csnd = ob[Cobj].snd;	// Objects sound
	Cpob = MPath[Cact];		// Object actions path object
	Cpgo = ob[Cpob].geo;	// Path objects geometry
	lstVal[Cobj] = ob[Cobj].val - 100;
	MDir[Cobj] = -1;

	if(!Cact) {
		Plen[Cobj] = 0;
		noStep = 0;
		disStep[Cobj] = 0;
		dpox[Cobj] = 0;
		dpoy[Cobj] = 0;
		PathCount[Cobj] = 0;
	}
	else {
		PathCount[Cobj] = MCount[Cact];

		if(MType[Cact] & ACT_XPATH_MOUSE || MType[Cact] & ACT_YPATH_MOUSE) { //^^ replaced with linPath??
			Plen[Cobj] = 1;
			noStep = 1;
			disStep[Cobj] = 1;
			dpox[Cobj] = 0;
			dpoy[Cobj] = 0;
		}
		else if(MType[Cact] & ACT_XPATH_OBJPTH || MType[Cact] & ACT_XPATH_OBJXYZ) {
			objPath(Cobj,Cpob,Cpgo);
		}
		else
		{
			linPath(Cobj);
		}
	}
	cpox[Cobj] = spox[Cobj];
	cpoy[Cobj] = spoy[Cobj];
	LastPt[Cobj] = 0;
	atDis[Cobj] = 0;
	DisPt[Cobj] = 0;
	EndPath[Cobj] = 0;

	return;
}
//****************************************************************************
function getPathLenth(Cobj,Cpob,Cgeo)
// return lenth of transformed path
{
	var i, x = 0.0, y = 0.0;
	Plen[Cobj] = 0;
	// find length of rectangle
	if		((Gtyp[Cgeo] & GEO_TYPE) == 1) {
		Plen[Cobj] = 2 * (Gpxl[Cgeo][1] - Gpxl[Cgeo][0]) * ob[Cpob].cscx
		           + 2 * (Gpyl[Cgeo][1] - Gpyl[Cgeo][0]) * ob[Cpob].cscy;
	}
	// find length of ellipse
	else if	((Gtyp[Cgeo] & GEO_TYPE) == 2) {
		Plen[Cobj] = 360;
	}
	// find length of polygon
	else if	((Gtyp[Cgeo] & GEO_TYPE) == 3) {
		for ( i = 1; i < Gnpt[Cgeo]; i++)
		{
			x = (Gpxl[Cgeo][i] - Gpxl[Cgeo][i-1]) * ob[Cpob].cscx;
			y = (Gpyl[Cgeo][i] - Gpyl[Cgeo][i-1]) * ob[Cpob].cscy;
			Plen[Cobj] += Math.sqrt(x*x + y*y);
		}

		if(!(Gtyp[Cgeo] & GEO_OPEN))
		{
			x = (Gpxl[Cgeo][Gnpt[Cgeo]-1] - Gpxl[Cgeo][0]) * ob[Cpob].cscx;
			y = (Gpyl[Cgeo][Gnpt[Cgeo]-1] - Gpyl[Cgeo][0]) * ob[Cpob].cscy;
			Plen[Cobj] += Math.sqrt(x*x + y*y);
		}
	}
}

//************************************************************************************
function linPath(Cobj) {
epox[Cobj] = spox[Cobj];
epoy[Cobj] = spoy[Cobj];
var lh = mH;
var lw = mW;
if(Version >= 105)
{
	lh = lh * (MPLen[Cact] / 100.);
	lw = lw * (MPLen[Cact] / 100.);
}

	if(MType[Cact] & ACT_YPATH_UP) {
		if(MType[Cact] & ACT_PATH_CENTER) {
			spoy[Cobj] 	+= lh;
			epoy[Cobj] -= lh;
		}
		else if(MType[Cact] & ACT_PATH_END) {
			spoy[Cobj] 	+= lh;
		}
		else if(MType[Cact] & ACT_PATH_START) {
			epoy[Cobj] -= lh;
		}
	}
	else if(MType[Cact] & ACT_YPATH_DOWN) {
		if(MType[Cact] & ACT_PATH_START) {
			epoy[Cobj] += lh;
		}
		else if(MType[Cact] & ACT_PATH_END) {
			spoy[Cobj] 	-= lh;
		}
		else if(MType[Cact] & ACT_PATH_CENTER) {
			spoy[Cobj] 	-= lh;
			epoy[Cobj] += lh;
		}
	}
	else if(MType[Cact] & ACT_YPATH_MOUSE) {
		Plen[Cobj] = 1;
		noStep = 1;
		disStep[Cobj] = 1;
		dpoy[Cobj] = 0;
		spoy[Cobj] = cpoy[Cobj];
	}

	if(MType[Cact] & ACT_XPATH_LEFT) {
		if(MType[Cact] & ACT_PATH_CENTER) {
			spox[Cobj] 	+= lw;
			epox[Cobj]  -= lw;
		}
		else if(MType[Cact] & ACT_PATH_END) {
			spox[Cobj] 	+= lw;
		}
		else if(MType[Cact] & ACT_PATH_START) {
			epox[Cobj]  -= lw;
		}
	}
	else if(MType[Cact] & ACT_XPATH_RIGHT) {
		if(MType[Cact] & ACT_PATH_START) {
			epox[Cobj]  += lw;
		}
		else if(MType[Cact] & ACT_PATH_END) {
			spox[Cobj] 	-= lw;
		}
		else if(MType[Cact] & ACT_PATH_CENTER) {
			spox[Cobj] 	-= lw;
			epox[Cobj]  += lw;
		}
	}
	else if(MType[Cact] & ACT_YPATH_MOUSE) {
		Plen[Cobj] = 1;
		noStep = 1;
		disStep[Cobj] = 1;
		dpox[Cobj] = 0;
		spox[Cobj] = cpox[Cobj];
	}
	var x = epox[Cobj] - spox[Cobj];
	var y = epoy[Cobj] - spoy[Cobj];
	if(x+y)
	{
		Plen[Cobj] = Math.sqrt(x*x + y*y);
		noStep  = Math.abs(Plen[Cobj] / MRate[Cact]);
		if(noStep < 1) noStep = 1;
		disStep[Cobj] = Plen[Cobj] / noStep;
		dpox[Cobj] = x / noStep;
		dpoy[Cobj] = y / noStep;
	}
	else
	{
		Plen[Cobj] = 0;
		dpox[Cobj] = 0;
		dpoy[Cobj] = 0;
		disStep[Cobj] = 0;
	}
	return
}

function objPath(Cobj,Cpob,Cpgo) 
{
	if		((Gtyp[Cpgo] & GEO_TYPE) == 1) {	
		spox[Cobj] = Gpxl[Cpgo][0] * ob[Cpob].cscx + ob[Cpob].cpox;  
		spoy[Cobj] = Gpyl[Cpgo][0] * ob[Cpob].cscy + ob[Cpob].cpoy;
		epox[Cobj] = spox[Cobj];
		epoy[Cobj] = spoy[Cobj];
	}
	else if	((Gtyp[Cpgo] & GEO_TYPE) == 2) {
		spox[Cobj] = Gpxl[Cpgo][0] * ob[Cpob].cscx + ob[Cpob].cpox;
//		spoy[Cobj] = Gpyl[Cpgo][0] * ob[Cpob].cscy + ob[Cpob].cpoy + Gszy[Cpob] * ob[Cpob].cscy;
		spoy[Cobj] = (Gpyl[Cpgo][0] + Gszy[Cpgo]) * ob[Cpob].cscy + ob[Cpob].cpoy;
		epox[Cobj] = spox[Cobj];
		epoy[Cobj] = spoy[Cobj];
	}
	else if	((Gtyp[Cpgo] & GEO_TYPE) == 3) {
		spox[Cobj] = Gpxl[Cpgo][0] * ob[Cpob].cscx + ob[Cpob].cpox;
		spoy[Cobj] = Gpyl[Cpgo][0] * ob[Cpob].cscy + ob[Cpob].cpoy;
		if(Gtyp[Cpgo] & GEO_OPEN) 
		{
			epox[Cobj] = Gpxl[Cpgo][Gnpt[Cpgo]-1] * ob[Cpob].cscx + ob[Cpob].cpox;
			epoy[Cobj] = Gpyl[Cpgo][Gnpt[Cpgo]-1] * ob[Cpob].cscy + ob[Cpob].cpoy;
		}
		else 
		{
			epox[Cobj] = spox[Cobj];
			epoy[Cobj] = spoy[Cobj];
		}
	}

	getPathLenth(Cobj,Cpob,Cpgo);
	if(Cact)
		noStep  = Math.abs(Plen[Cobj] / MRate[Cact]);
	else
		noStep = 0;
	if(noStep < 1) noStep = 1;
	disStep[Cobj] = Plen[Cobj] / noStep;

	return;
}

//window.status = " Cobj=" + Cobj + " epox[Cobj]=" + epox[Cobj] + " Cgeo=" + Cgeo;
//window.status = " Deact Cobj=" + Cobj + " WDEvent[Cevt] & (1<<5)=" + WDEvent[Cevt] & (1<<5) + " Active[WDAObj[Cevt]]=" + Active[WDAObj[Cevt]];
//if(Cobj==2) window.status = " Cobj=" + Cobj + " ob[Cobj].val=" + ob[Cobj].val;
//-->