import "std.zh"

import "ffcscript.zh"

import "ghost.zh"


														 //Global Scripts

//%MGSO% DECLARATION ScrollingBackgrounds
//%MGSO% DECLARATION MovingPlatforms
//%MGSO% DECLARATION MooshPit
//%MGSO% DECLARATION Confusion
//%MGSO% DECLARATION SolidFFC

//%MGSO% HEADER_START ScrollingBackgrounds

const int SCROLLINGLAYER_LINKSTEP = 1.5; //Link's step speed
const int SCROLLINGLAYER_FASTSCROLLING = 1; //Set to 1 if Very Fast Scrolling is enabled
const int SCROLLINGLAYER_DEBUG = 0; //Set to 1 to show positions of onscreen layers

int ScrollingBG[112]; //Size should be at least _SBG_START + 6 * _SBG_BLOCK

//Global array indices
const int _SBG_LINKX			 = 0;
const int _SBG_LINKY			 = 1;
const int _SBG_SCROLLDIR		 = 2;
const int _SBG_SCROLLCOUNTER	 = 3;

//Start index of the 2D part of the global array and block size
const int _SBG_START = 16;
const int _SBG_BLOCK = 16;

//Indices for scrolling layer properties
const int _SBG_X		 = 0;
const int _SBG_Y		 = 1;
const int _SBG_XSTEP	 = 2;
const int _SBG_YSTEP	 = 3;
const int _SBG_MAP		 = 4;
const int _SBG_SCREEN	 = 5;
const int _SBG_LAYER	 = 6;
const int _SBG_WIDTH	 = 7;
const int _SBG_HEIGHT	 = 8;
const int _SBG_OPACITY	 = 9;
const int _SBG_FLAGS	 = 10;
const int _SBG_DMAP		 = 11;

//Flag constants
const int _SBGF_NORESET			 = 00000001b;
const int _SBGF_NOPOSITION		 = 00000010b;
const int _SBGF_TRACKX			 = 00000100b;
const int _SBGF_TRACKY			 = 00001000b;
const int _SBGF_TRACKXSCROLL	 = 00010000b;
const int _SBGF_TRACKYSCROLL	 = 00100000b;
const int _SBGF_FORCEDRAWSCREEN	 = 01000000b;


void ScrollingBG_Init(){
	int i; int j; int k;
	for(i=0; i<6; ++i){
		j = _SBG_START+i*_SBG_BLOCK;
		//If the layer hasn't been assigned by an FFC this frame, clear it on F6
		if(!(ScrollingBG[j+_SBG_FLAGS]&_SBGF_NORESET)){
			for(k=0; k<_SBG_BLOCK; ++k){
				ScrollingBG[j+k] = 0;
			}
		}
	}

	ScrollingBG[_SBG_LINKX] = Link->X;
	ScrollingBG[_SBG_LINKY] = Link->Y;
	ScrollingBG[_SBG_SCROLLDIR] = -1;
	ScrollingBG[_SBG_SCROLLCOUNTER] = 0;
}

void ScrollingBG_Update(){
	int i; int j; int k;

	int x; int y; int w; int h;
	bool trackLinkX; bool trackScrollX;
	bool trackLinkY; bool trackScrollY;

	int dX = (Link->X-ScrollingBG[_SBG_LINKX])/SCROLLINGLAYER_LINKSTEP;
	int dY = (Link->Y-ScrollingBG[_SBG_LINKY])/SCROLLINGLAYER_LINKSTEP;
	ScrollingBG[_SBG_LINKX] = Link->X;
	ScrollingBG[_SBG_LINKY] = Link->Y;

	if(Link->Action==LA_SCROLLING){
		if(ScrollingBG[_SBG_SCROLLDIR]==-1){
			if(Link->Y>160)
				ScrollingBG[_SBG_SCROLLDIR] = DIR_UP;
			else if(Link->Y<0)
			ScrollingBG[_SBG_SCROLLDIR] = DIR_DOWN;
			else if(Link->X>240)
			ScrollingBG[_SBG_SCROLLDIR] = DIR_LEFT;
			else
			ScrollingBG[_SBG_SCROLLDIR] = DIR_RIGHT;

			ScrollingBG[_SBG_SCROLLCOUNTER] = 0;
		}
		else
		++ScrollingBG[_SBG_SCROLLCOUNTER];
	}
	else
	ScrollingBG[_SBG_SCROLLDIR] = -1;

	for(i=0; i<6; ++i){
		j = _SBG_START+i*_SBG_BLOCK;
		if(ScrollingBG[j+_SBG_OPACITY]&&ScrollingBG[j+_SBG_DMAP]==Game->GetCurDMap()&&Game->GetCurScreen()<0x7F){
			if(ScrollingBG[j+_SBG_FLAGS]&_SBGF_TRACKX)
				trackLinkX = true;
			if(ScrollingBG[j+_SBG_FLAGS]&_SBGF_TRACKY)
				trackLinkY = true;
			if(ScrollingBG[j+_SBG_FLAGS]&_SBGF_TRACKXSCROLL)
				trackScrollX = true;
			if(ScrollingBG[j+_SBG_FLAGS]&_SBGF_TRACKYSCROLL)
				trackScrollY = true;

			w = 256*ScrollingBG[j+_SBG_WIDTH];
			h = 176*ScrollingBG[j+_SBG_HEIGHT];

			//Process scrolling animation
			//X-axis
			if(ScrollingBG_IsScrolling()){
				//During the scroll animation, move the background if set to track scrolling
				if(trackScrollX){
					if(ScrollingBG[_SBG_SCROLLDIR]==DIR_LEFT)
						ScrollingBG[j+_SBG_X] -= ScrollingBG[j+_SBG_XSTEP];
					else if(ScrollingBG[_SBG_SCROLLDIR]==DIR_RIGHT)
					ScrollingBG[j+_SBG_X] += ScrollingBG[j+_SBG_XSTEP];
				}
				//Scroll automatically if neither Link nor scrolling are being tracked
				else if(!trackLinkX){
					ScrollingBG[j+_SBG_X] += ScrollingBG[j+_SBG_XSTEP];
				}
			}
			else{
				//Only move when Link does if tracking him
				if(trackLinkX){
					ScrollingBG[j+_SBG_X] += ScrollingBG[j+_SBG_XSTEP]*dX;
				}
				else if(!trackScrollX)
				ScrollingBG[j+_SBG_X] += ScrollingBG[j+_SBG_XSTEP];
			}
			//Y-axis
			if(ScrollingBG_IsScrolling()){
				//During the scroll animation, move the background if set to track scrolling
				if(trackScrollY){
					if(ScrollingBG[_SBG_SCROLLDIR]==DIR_UP)
						ScrollingBG[j+_SBG_Y] -= ScrollingBG[j+_SBG_YSTEP];
					else if(ScrollingBG[_SBG_SCROLLDIR]==DIR_DOWN)
					ScrollingBG[j+_SBG_Y] += ScrollingBG[j+_SBG_YSTEP];
				}
				//Scroll automatically if neither Link nor scrolling are being tracked
				else if(!trackLinkY){
					ScrollingBG[j+_SBG_Y] += ScrollingBG[j+_SBG_YSTEP];
				}
			}
			else{
				//Only move when Link does if tracking him
				if(trackLinkY){
					ScrollingBG[j+_SBG_Y] += ScrollingBG[j+_SBG_YSTEP]*dY;
				}
				else if(!trackScrollX)
				ScrollingBG[j+_SBG_Y] += ScrollingBG[j+_SBG_YSTEP];
			}

			//Keep the X and Y positions of the background wrapped based on size
			if(ScrollingBG[j+_SBG_X]<0)
				ScrollingBG[j+_SBG_X] += w;
			if(ScrollingBG[j+_SBG_X]>=w)
				ScrollingBG[j+_SBG_X] -= w;

			if(ScrollingBG[j+_SBG_Y]<0)
				ScrollingBG[j+_SBG_Y] += h;
			if(ScrollingBG[j+_SBG_Y]>=h)
				ScrollingBG[j+_SBG_Y] -= h;

			x = Floor(ScrollingBG[j+_SBG_X]);
			y = Floor(ScrollingBG[j+_SBG_Y]);

			ScrollingBG_DrawLayer(ScrollingBG[j+_SBG_LAYER], ScrollingBG[j+_SBG_MAP], ScrollingBG[j+_SBG_SCREEN], x, y, ScrollingBG[j+_SBG_WIDTH], ScrollingBG[j+_SBG_HEIGHT], ScrollingBG[j+_SBG_OPACITY], ScrollingBG[j+_SBG_FLAGS]&_SBGF_FORCEDRAWSCREEN);

			if(SCROLLINGLAYER_DEBUG){
				Screen->DrawInteger(6, 24*i, 0, FONT_Z3SMALL, 0x01, 0x0F, -1, -1, x, 0, 128);
				Screen->DrawInteger(6, 24*i, 8, FONT_Z3SMALL, 0x01, 0x0F, -1, -1, y, 0, 128);
			}
		}

		//Unmark flags telling the global not to reset it and the FFC not to reposition it
		if(ScrollingBG[j+_SBG_FLAGS]&_SBGF_NORESET)
			ScrollingBG[j+_SBG_FLAGS] &= ~_SBGF_NORESET;
		if(ScrollingBG[j+_SBG_FLAGS]&_SBGF_NOPOSITION)
			ScrollingBG[j+_SBG_FLAGS] &= ~_SBGF_NOPOSITION;
	}
}

bool ScrollingBG_IsScrolling(){
	int xFrames = 64;
	int yFrames = 44;
	if(SCROLLINGLAYER_FASTSCROLLING){
		xFrames = 16;
		yFrames = 11;
	}
	if(ScrollingBG[_SBG_SCROLLDIR]>-1&&ScrollingBG[_SBG_SCROLLCOUNTER]>0){
		if(ScrollingBG[_SBG_SCROLLDIR]<2&&ScrollingBG[_SBG_SCROLLCOUNTER]<yFrames+1)
			return true;
		if(ScrollingBG[_SBG_SCROLLDIR]>=2&&ScrollingBG[_SBG_SCROLLCOUNTER]<xFrames+1)
			return true;
	}
	return false;
}

void ScrollingBG_DrawLayer(int layer, int srcMap, int srcScreen, int x, int y, int w, int h, int op, bool forceDrawScreen){
	int i;
	bool useDrawScreen;
	if(forceDrawScreen)
		useDrawScreen = true;
	//While scrolling, avoid using DrawLayer on negative layers. ZC does not like this.
	if(op==128&&Link->Action==LA_SCROLLING){
		if(layer==2&&ScreenFlag(SF_VIEW, 4))
			useDrawScreen = true;
		if(layer==3&&ScreenFlag(SF_VIEW, 5))
			useDrawScreen = true;
	}

	int tmpScreen;
	int scrnX;
	int scrnY;

	for(i=0; i<4; ++i){
		scrnX = Floor(x/256)+(i%2);
		scrnY = Floor(y/176)+Floor(i/2);

		if(scrnX<0)
			scrnX += w;
		if(scrnX>w-1)
			scrnX -= w;
		if(scrnY<0)
			scrnY += h;
		if(scrnY>h-1)
			scrnY -= h;

		tmpScreen = srcScreen+scrnX+scrnY*16;
		if(useDrawScreen)
			Screen->DrawScreen(layer, srcMap, tmpScreen, -(x%256)+256*(i%2), -(y%176)+176*Floor(i/2), 0);
		else
		Screen->DrawLayer(layer, srcMap, tmpScreen, 0, -(x%256)+256*(i%2), -(y%176)+176*Floor(i/2), 0, op);
	}
}

//This FFC script is placed on the screen to assign or unassign a scrolling layer for the current DMap
//D0: Which of the simultaneous scrolling layers to assign (0-5)
//D1: Layer to draw to
//D2: Source Map for the layer
//D3: Source Screen for the layer (in decimal)
//D4: X speed for the layer
//D5: Y speed for the layer
//D6: Opacity for the layer (0 to clear, 64 for transparent, 128 for opaque)
//D7: Sum of all of these flags you want to use
//		1 - Track Link when walking on the X axis
//		2 - Track Link when walking on the Y axis
//		4 - Track Link when scrolling on the X axis
//		8 - Track Link when scrolling on the Y axis
//		16 - Use 2x2 screen block
//		32 - Use 3x3 screen block
//		64 - Use 4x4 screen block
//		128 - Always use drawscreen (slow)
ffc script ScrollingLayer_Assign{
	void run(int whichScrollingLayer, int drawLayer, int srcMap, int srcScreen, int xStep, int yStep, int opacity, int flags){
		whichScrollingLayer = Clamp(whichScrollingLayer, 0, 5);

		int width = 1;
		if(flags&16)
			width = 2;
		if(flags&32)
			width = 3;
		if(flags&64)
			width = 4;

		//Get the starting array index for the scrolling layer block
		int i = _SBG_START+whichScrollingLayer*_SBG_BLOCK;
		int j;

		//This runs twice because of script order shenanigans. Hooraaaay! Script order!
		for(j=0; j<2; ++j){
			if(opacity!=0&&(ScrollingBG[i+_SBG_OPACITY]&&ScrollingBG[i+_SBG_DMAP]==Game->GetCurDMap())){
				Waitframe();
				continue;
			}

			//Assign that stuff
			if(!(ScrollingBG[i+_SBG_FLAGS]&_SBGF_NOPOSITION)){
				ScrollingBG[i+_SBG_X] = 0;
				ScrollingBG[i+_SBG_Y] = 0;
				ScrollingBG[i+_SBG_WIDTH] = width;
				ScrollingBG[i+_SBG_HEIGHT] = width;
			}
			ScrollingBG[i+_SBG_XSTEP] = xStep;
			ScrollingBG[i+_SBG_YSTEP] = yStep;
			ScrollingBG[i+_SBG_MAP] = srcMap;
			ScrollingBG[i+_SBG_SCREEN] = srcScreen;
			ScrollingBG[i+_SBG_LAYER] = drawLayer;
			ScrollingBG[i+_SBG_OPACITY] = opacity;

			//Assign the flag that tells the global not to reset this index, as well as any others specified
			ScrollingBG[i+_SBG_FLAGS] = _SBGF_NORESET;
			if(flags&1)
				ScrollingBG[i+_SBG_FLAGS] |= _SBGF_TRACKX;
			if(flags&2)
				ScrollingBG[i+_SBG_FLAGS] |= _SBGF_TRACKY;
			if(flags&4)
				ScrollingBG[i+_SBG_FLAGS] |= _SBGF_TRACKXSCROLL;
			if(flags&8)
				ScrollingBG[i+_SBG_FLAGS] |= _SBGF_TRACKYSCROLL;
			if(flags&128)
				ScrollingBG[i+_SBG_FLAGS] |= _SBGF_FORCEDRAWSCREEN;

			ScrollingBG[i+_SBG_DMAP] = Game->GetCurDMap();

			Quit();
		}
	}
}

//This FFC script is placed on the screen to change the position of an assigned layer (because the last script ran out of arguments)
//D0: Which of the simultaneous scrolling layers to assign (0-5)
//D1: X position to set the layer to
//D2: Y position to set the layer to
//D3: Width to set the layer to (overrides flags used by the previous script)
//D4: Height to set the layer to (overrides flags used by the previous script)
ffc script ScrollingLayer_Reposition{
	void run(int whichScrollingLayer, int x, int y, int newW, int newH){
		whichScrollingLayer = Clamp(whichScrollingLayer, 0, 5);
		newW = Clamp(newW, 0, 16);
		newH = Clamp(newH, 0, 8);

		//Get the starting array index for the scrolling layer block
		int i = _SBG_START+whichScrollingLayer*_SBG_BLOCK;
		int j;

		int w = ScrollingBG[i+_SBG_WIDTH]*256;
		int h = ScrollingBG[i+_SBG_HEIGHT]*176;

		//This runs twice because of script order shenanigans. Hooraaaay! Script order!
		for(j=0; j<2; ++j){
			if(!ScrollingBG[i+_SBG_OPACITY]||ScrollingBG[i+_SBG_FLAGS]&_SBGF_NORESET){
				if(newW&&newH){
					ScrollingBG[i+_SBG_WIDTH] = newW;
					ScrollingBG[i+_SBG_HEIGHT] = newH;
					w = ScrollingBG[i+_SBG_WIDTH]*256;
					h = ScrollingBG[i+_SBG_HEIGHT]*176;
				}

				while(x<0)
				x += w;
				while(x>=w)
				x -= w;
				while(y<0)
				y += h;
				while(y>=h)
				y -= h;

				ScrollingBG[i+_SBG_X] = x;
				ScrollingBG[i+_SBG_Y] = y;

				//Flag that the ScrollingLayer_Assign script shouldn't reset the layer's position, if this one comes first
				ScrollingBG[i+_SBG_FLAGS] |= _SBGF_NOPOSITION;
				Quit();
			}

			Waitframe();
		}
	}
}
//%MGSO% HEADER_END ScrollingBackgrounds

//%MGSO% HEADER_START MovingPlatforms

///Constants and Variables used by platform script;
const int DIAGONAL_MOVEMENT = 0; //Enable the option and change this to 0 for nes movement.
int onplatform; //Global variable use this to check if Link is on a platform for other scripts.


void NesMovementFix()
{
	if(DIAGONAL_MOVEMENT==0 && (Link->InputUp || Link->InputDown))
		{
		Link->InputLeft = false;
		Link->InputRight = false;
	}
}

void MovingPlatforms()
{
	onplatform = 0;
	if(Link->Z == 0)
		{
		int buffer[] = "movingplatform";
		for(int i = 1; i <= 32; i++)
		{
			ffc f = Screen->LoadFFC(i);
			if(f->Script != Game->GetFFCScript(buffer)) continue;
			if(Abs(Link->X + 8 - CenterX(f)) >= f->TileWidth*8) continue;
			if(Abs(Link->Y + 12 - CenterY(f)) >= f->TileHeight*8) continue;
			onplatform = FFCNum(f);
			break;
		}
	}
}

ffc script MovingPlatform
{
	void run()
	{
		float oldx = this->X;
		float oldy = this->Y;
		float linkx;
		float linky;
		while(true)
		{
			if(onplatform == FFCNum(this))
				{
				linkx += this->X - oldx;
				linky += this->Y - oldy;
				if(linkx << 0 != 0)
					{
					Link->X += linkx << 0;
					linkx -= linkx << 0;
				}
				if(linky << 0 != 0)
					{
					Link->Y += linky << 0;
					linky -= linky << 0;
				}
			}
			else
			{
				linkx = 0;
				linky = 0;
			}
			oldx = this->X;
			oldy = this->Y;
			Waitframe();
		}
	}
}
//%MGSO% HEADER_END MovingPlatforms

//%MGSO% HEADER_START MooshPit

int MooshPit[16];
const int _MP_LASTX = 0;
const int _MP_LASTY = 1;
const int _MP_LASTDMAP = 2;
const int _MP_LASTSCREEN = 3;
const int _MP_ENTRYX = 4;
const int _MP_ENTRYY = 5;
const int _MP_ENTRYDMAP = 6;
const int _MP_ENTRYSCREEN = 7;
const int _MP_FALLX = 8;
const int _MP_FALLY = 9;
const int _MP_FALLTIMER = 10;
const int _MP_FALLSTATE = 11;
const int _MP_DAMAGETYPE = 12;
const int _MP_SLIDETIMER = 13;

const int MOOSHPIT_NO_GRID_SNAP = 0; //Set to 1 to prevent Link's falling sprite from snapping to the combo grid.
const int MOOSHPIT_ENABLE_SLIDEYPITS = 0; //Set to 1 if Link should slide into pits he's partially on
const int MOOSHPIT_NO_MOVE_WHILE_FALLING = 1; //Set to 1 if you don't want Link able to move while falling
const int MOOSHPIT_NO_REENTER_STAIRS = 1; //Set to 1 to prevent Link reentering stairs when respawning from a pit. This uses an FFC slot to run the script
const int MOOSHPIT_STUN_ENEMIES_WHILE_FALLING = 1; //Set to 1 to stun stunnable enemies while falling in a pit

const int CT_HOLELAVA = 128; //Combo type for pits (No Ground Enemies by default)
const int CF_LAVA = 98; //Combo flag marking pits as lava (Script 1 by default)

const int SPR_FALLHOLE = 100; //Sprite for Link falling in a hole
const int SPR_FALLLAVA = 89; //Sprite for Link falling in lava

const int SFX_FALLHOLE = 38; //Sound for falling in a hole
const int SFX_FALLLAVA = 13; //Sound for falling in lava

const int DAMAGE_FALLHOLE = 8; //How much damage pits deal (1/2 heart default)
const int DAMAGE_FALLLAVA = 16; //How much damage lava deals (1 heart default)

const int FFC_MOOSHPIT_AUTOWARPA = 32; //FFC that turns into an auto side warp combo when you fall in a pit
const int CMB_MOOSHPIT_AUTOWARPA = 875; //Combo number of an invisible Auto Side Warp A combo
const int SF_MISC_MOOSHPITWARP = 2; //Number of the screen flag under the Misc. section that makes pits warp (Script 1 by default)
//All pit warps use Side Warp A

const int MOOSHPIT_MIN_FALL_TIME = 60; //Minimum time for the pit's fall animation, to prevent repeated falling in pits
const int MOOSHPIT_EXTRA_FALL_TIME = 0; //Extra frames at the end of the falling animation before Link respawns

//Width and height of Link's hitbox for colliding with pits
const int MOOSHPIT_LINKHITBOXWIDTH = 2;
const int MOOSHPIT_LINKHITBOXHEIGHT = 2;

//Width and height of Link's hitbox for colliding with pits/lava in sideview
const int MOOSHPIT_SIDEVIEW_LINKHITBOXWIDTH = 2;
const int MOOSHPIT_SIDEVIEW_LINKHITBOXHEIGHT = 2;

const int MOOSHPIT_SLIDEYPIT_FREQ = 3; //Link will be pushed into slideypits every 1/n frames
const int MOOSHPIT_SLIDEYPIT_MAXTIME = 20; //Link will be pushed into slideypits more intensely after n frames
const int MOOSHPIT_SLIDEYPIT_ACCELFREQ = 8; //How often Link accelerates when falling in the pit

int MooshPit_OnPit(int LinkX, int LinkY, bool countFFCs){
	if(Link->Action==LA_FROZEN||Link->Action==LA_RAFTING||Link->Action==LA_INWIND)
		return -1;

	if(countFFCs){
		if(MooshPit_OnFFC(LinkX, LinkY))
			return -1;
	}

	bool sideview;
	if(Screen->Flags[SF_ROOMTYPE]&100b)
		sideview = true;
	//wew lad
	int width = MOOSHPIT_LINKHITBOXWIDTH;
	int height = MOOSHPIT_LINKHITBOXHEIGHT;

	int total;
	int solidTotal;

	for(int x=0; x<=1; x++){
		for(int y=0; y<=1; y++){
			int X; int Y;
			if(sideview){ //Hitbox functions differently in sideview
				width = MOOSHPIT_SIDEVIEW_LINKHITBOXWIDTH;
				height = MOOSHPIT_SIDEVIEW_LINKHITBOXHEIGHT;
				X = Floor(LinkX+7-width/2+(width-1)*x)+1;
				Y = Floor(LinkY+7-height/2+(height-1)*y)+1;
			}
			else{
				X = Floor(LinkX+7-width/2+(width-1)*x)+1;
				Y = Floor(LinkY+11-height/2+(height-1)*y)+1;
			}

			//If one corner of Link's hitbox is on a pit, flag that corner as covered
			if(Screen->ComboT[ComboAt(X, Y)]==CT_HOLELAVA){
				total |= 1<<(1+(x+y*2));
			}
			//If Link is on a solid combo, count that corner as a pit
			if(Screen->isSolid(X, Y)){
				solidTotal |= 1<<(x+y*2);
			}
		}
	}
	if(total>0) //Assuming Link is on at least one actual pit, add up the solid and nonsolid pits
		return (total>>1)|(solidTotal<<4);
	return -1;
}

bool MooshPit_OnFFC(int LinkX, int LinkY){
	for(int i=1; i<=32; i++){ //Cycle through every FFC
		ffc f = Screen->LoadFFC(i);
		//Check if the FFC is solid
		if(f->Data>0&&!f->Flags[FFCF_CHANGER]&&!f->Flags[FFCF_ETHEREAL]){
			//Check if Link collides with the FFC
			if(RectCollision(LinkX+4, LinkY+9, LinkX+11, LinkY+14, f->X, f->Y, f->X+f->EffectWidth-1, f->Y+f->EffectHeight-1)){
				return true;
			}
		}
	}
	//If Link doesn't collide with any FFC, return false
	return false;
}

void MooshPit_StunEnemies(){
	for(int i=Screen->NumNPCs(); i>=1; i--){ //Cycle through every enemy
		npc n = Screen->LoadNPC(i);
		//Make it so the enemy's stun never falls below 1
		n->Stun = Max(n->Stun, 1);
	}
}

void MooshPit_Init(){
	MooshPit[_MP_LASTX] = Link->X;
	MooshPit[_MP_LASTY] = Link->Y;
	MooshPit[_MP_LASTDMAP] = Game->GetCurDMap();
	MooshPit[_MP_LASTSCREEN] = Game->GetCurDMapScreen();
	MooshPit[_MP_ENTRYX] = Link->X;
	MooshPit[_MP_ENTRYY] = Link->Y;
	MooshPit[_MP_ENTRYDMAP] = Game->GetCurDMap();
	MooshPit[_MP_ENTRYSCREEN] = Game->GetCurDMapScreen();
	MooshPit[_MP_FALLSTATE] = 0;
	MooshPit[_MP_FALLTIMER] = 0;
	Link->CollDetection = true;
	Link->Invisible = false;
}

void MooshPit_Update(){
	int i;
	bool isWarp;
	if(Screen->Flags[SF_MISC]&(1<<SF_MISC_MOOSHPITWARP))
		isWarp = true;

	bool sideview;
	if(Screen->Flags[SF_ROOMTYPE]&100b)
		sideview = true;

	if(Link->Action!=LA_SCROLLING){
		//Update the entry point whenever the screen changes
		if(MooshPit[_MP_ENTRYDMAP]!=Game->GetCurDMap()||MooshPit[_MP_ENTRYSCREEN]!=Game->GetCurDMapScreen()){
			MooshPit[_MP_ENTRYX] = Link->X;
			MooshPit[_MP_ENTRYY] = Link->Y;
			MooshPit[_MP_ENTRYDMAP] = Game->GetCurDMap();
			MooshPit[_MP_ENTRYSCREEN] = Game->GetCurDMapScreen();
		}

		if(MooshPit[_MP_FALLSTATE]==0){ //Not falling in pit
			int onPit = MooshPit_OnPit(Link->X, Link->Y, true);
			//Check if slidey pits are enabled and it's not sideview
			if(MOOSHPIT_ENABLE_SLIDEYPITS&&!IsSideview()){
				if(Link->Z<=0&&onPit>-1){ //If Link is partially on a pit
					int slideVx; int slideVy;
					int reps = 1;
					//Check if it's a frame Link should be moved
					if(MooshPit[_MP_SLIDETIMER]%MOOSHPIT_SLIDEYPIT_FREQ==0||MooshPit[_MP_SLIDETIMER]>=MOOSHPIT_SLIDEYPIT_MAXTIME){
						if((onPit&0111b)==0111b){ //Going up-left
							slideVx = -1;
							slideVy = -1;
						}
						else if((onPit&1011b)==1011b){ //Going up-right
							slideVx = 1;
							slideVy = -1;
						}
						else if((onPit&1101b)==1101b){ //Going down-left
							slideVx = -1;
							slideVy = 1;
						}
						else if((onPit&1110b)==1110b){ //Going down-right
							slideVx = 1;
							slideVy = 1;
						}
						else if((onPit&0011b)==0011b){ //Going up
							slideVy = -1;
						}
						else if((onPit&1100b)==1100b){ //Going down
							slideVy = 1;
						}
						else if((onPit&0101b)==0101b){ //Going left
							slideVx = -1;
						}
						else if((onPit&1010b)==1010b){ //Going right
							slideVx = 1;
						}
						else if((onPit&0001b)==0001b){ //Going up-left
							slideVx = -1;
							slideVy = -1;
						}
						else if((onPit&0010b)==0010b){ //Going up-right
							slideVx = 1;
							slideVy = -1;
						}
						else if((onPit&0100b)==0100b){ //Going down-left
							slideVx = -1;
							slideVy = 1;
						}
						else if((onPit&1000b)==1000b){ //Going down-right
							slideVx = 1;
							slideVy = 1;
						}

						//DEBUG DRAWS
						//VX
						// Screen->DrawInteger(6, 0, 0, FONT_Z1, 0x01, 0x0F, -1, -1, slideVx, 0, 128);
						//VY
						// Screen->DrawInteger(6, 0, 8, FONT_Z1, 0x01, 0x0F, -1, -1, slideVy, 0, 128);
						//ONPIT BITS
						// Screen->DrawInteger(6, 0, 16, FONT_Z1, 0x01, 0x0F, -1, -1, (onPit&1000b)>>3, 0, 128);
						// Screen->DrawInteger(6, 8, 16, FONT_Z1, 0x01, 0x0F, -1, -1, (onPit&0100b)>>2, 0, 128);
						// Screen->DrawInteger(6, 16, 16, FONT_Z1, 0x01, 0x0F, -1, -1, (onPit&0010b)>>1, 0, 128);
						// Screen->DrawInteger(6, 24, 16, FONT_Z1, 0x01, 0x0F, -1, -1, (onPit&0001b), 0, 128);

						//If Link is over the max slide time, increase the speed every 4 frames
						if(MooshPit[_MP_SLIDETIMER]>=MOOSHPIT_SLIDEYPIT_MAXTIME)
							reps += Floor((MooshPit[_MP_SLIDETIMER]-MOOSHPIT_SLIDEYPIT_MAXTIME)/MOOSHPIT_SLIDEYPIT_ACCELFREQ);
					}

					for(i=0; i<reps; i++){
						if(slideVx<0&&CanWalk(Link->X, Link->Y, DIR_LEFT, 1, false)){
							Link->X--;
						}
						else if(slideVx>0&&CanWalk(Link->X, Link->Y, DIR_RIGHT, 1, false)){
							Link->X++;
						}
						if(slideVy<0&&CanWalk(Link->X, Link->Y, DIR_UP, 1, false)){
							Link->Y--;
						}
						else if(slideVy>0&&CanWalk(Link->X, Link->Y, DIR_DOWN, 1, false)){
							Link->Y++;
						}
					}
					MooshPit[_MP_SLIDETIMER]++;
				}
				else{
					MooshPit[_MP_SLIDETIMER] = 0;
				}
			}
			if(onPit>-1){
				//Combine solid combo bits with pit bits
				onPit |= (onPit>>4);
				//Remove non pit bits
				onPit &= 1111b;
			}
			if(Link->Z<=0&&onPit==15){ //If Link steps on a pit
				int underLink;
				if(!sideview){
					underLink = ComboAt(Link->X+8, Link->Y+12);
					if(Screen->ComboT[underLink]!=CT_HOLELAVA){
						for(i=0; i<4; i++){
							underLink = ComboAt(Link->X+15*(i%2), Link->Y+8+7*Floor(i/2));
							if(Screen->ComboT[underLink]==CT_HOLELAVA)
								break;
						}
					}
				}
				else{
					underLink = ComboAt(Link->X+8, Link->Y+8);
					if(Screen->ComboT[underLink]!=CT_HOLELAVA){
						for(i=0; i<4; i++){
							underLink = ComboAt(Link->X+15*(i%2), Link->Y+15*Floor(i/2));
							if(Screen->ComboT[underLink]==CT_HOLELAVA)
								break;
						}
					}
				}

				lweapon fall;

				//Check if the combo is lava
				if(ComboFI(underLink, CF_LAVA)){
					//Play sound and display animation
					Game->PlaySound(SFX_FALLLAVA);
					fall = CreateLWeaponAt(LW_SCRIPT10, Link->X, Link->Y);
					if(!MOOSHPIT_NO_GRID_SNAP){
						fall->X = ComboX(underLink);
						fall->Y = ComboY(underLink);
					}
					fall->UseSprite(SPR_FALLLAVA);
					fall->CollDetection = false;
					fall->DeadState = fall->ASpeed*fall->NumFrames;

					//Mark as lava damage
					MooshPit[_MP_DAMAGETYPE] = 1;
				}
				//Otherwise it's a pit
				else{
					//Play sound and display animation
					Game->PlaySound(SFX_FALLHOLE);
					fall = CreateLWeaponAt(LW_SCRIPT10, Link->X, Link->Y);
					if(!MOOSHPIT_NO_GRID_SNAP){
						fall->X = ComboX(underLink);
						fall->Y = ComboY(underLink);
						if(isWarp){
							Link->X = ComboX(underLink);
							Link->Y = ComboY(underLink);
						}
					}
					fall->UseSprite(SPR_FALLHOLE);
					fall->CollDetection = false;
					fall->DeadState = fall->ASpeed*fall->NumFrames;

					//Mark as hole damage
					MooshPit[_MP_DAMAGETYPE] = 0;
				}

				MooshPit[_MP_FALLX] = Link->X;
				MooshPit[_MP_FALLY] = Link->Y;

				//Cooldown should last as long as the fall animation
				MooshPit[_MP_FALLSTATE] = 1;
				MooshPit[_MP_FALLTIMER] = Max(MOOSHPIT_MIN_FALL_TIME, fall->DeadState+MOOSHPIT_EXTRA_FALL_TIME);

				//Render Link invisible and intangible
				Link->Invisible = true;
				Link->CollDetection = false;

				NoAction();
			}
			else if(MooshPit_OnPit(Link->X, Link->Y, false)==-1&&Link->Action!=LA_FROZEN){ //All other times, while Link is on solid ground, record Link's last position
				if(sideview){
					//Link has no Z value in sideview, so we check if he's on a platform instead
					if(OnSidePlatform(Link->X, Link->Y)){
						MooshPit[_MP_LASTDMAP] = Game->GetCurDMap();
						MooshPit[_MP_LASTSCREEN] = Game->GetCurDMapScreen();
						MooshPit[_MP_LASTX] = Link->X;
						MooshPit[_MP_LASTY] = Link->Y;
					}
				}
				else{
					if(Link->Z<=0){
						MooshPit[_MP_LASTDMAP] = Game->GetCurDMap();
						MooshPit[_MP_LASTSCREEN] = Game->GetCurDMapScreen();
						MooshPit[_MP_LASTX] = Link->X;
						MooshPit[_MP_LASTY] = Link->Y;
					}
				}
			}
		}
		else if(MooshPit[_MP_FALLSTATE]==1){ //Falling animation
			if(MooshPit[_MP_FALLTIMER]>0)
				MooshPit[_MP_FALLTIMER]--;

			if(MOOSHPIT_STUN_ENEMIES_WHILE_FALLING)
				MooshPit_StunEnemies();

			Link->Jump = 0;
			Link->Z = 0;

			//Keep Link invisible just in case
			Link->Invisible = true;
			Link->CollDetection = false;
			NoAction();
			if(MooshPit[_MP_FALLTIMER]==0){
				MooshPit[_MP_SLIDETIMER] = 0;
				if(!isWarp||MooshPit[_MP_DAMAGETYPE]==1){ //If the pit isn't a warp, deal damage and move Link back to the return point
					//If the entry would dump Link back in the pit, dump him out at the failsafe position
					if(MooshPit_OnPit(MooshPit[_MP_ENTRYX], MooshPit[_MP_ENTRYY], false)==15){
						if(MOOSHPIT_NO_REENTER_STAIRS){
							//Call a script to place an FFC under Link to prevent reentering stairs
							int scriptName[] = "MooshPit_StairsFix";
							int ffcNum = RunFFCScript(Game->GetFFCScript(scriptName), 0);
							if(ffcNum>0){
								ffc f = Screen->LoadFFC(ffcNum);
								f->Flags[FFCF_ETHEREAL] = false;
								f->X = MooshPit[_MP_LASTX];
								f->Y = MooshPit[_MP_LASTY];
							}
						}

						Link->X = MooshPit[_MP_LASTX];
						Link->Y = MooshPit[_MP_LASTY];

						//If the failsafe position was on a different screen, warp there
						if(Game->GetCurDMap()!=MooshPit[_MP_LASTDMAP]||Game->GetCurDMapScreen()!=MooshPit[_MP_LASTSCREEN]){
							Link->PitWarp(MooshPit[_MP_LASTDMAP], MooshPit[_MP_LASTSCREEN]);
						}

						Link->Invisible = false;
						Link->CollDetection = true;
					}
					else{
						if(MOOSHPIT_NO_REENTER_STAIRS){
							//Call a script to place an FFC under Link to prevent reentering stairs
							int scriptName[] = "MooshPit_StairsFix";
							int ffcNum = RunFFCScript(Game->GetFFCScript(scriptName), 0);
							if(ffcNum>0){
								ffc f = Screen->LoadFFC(ffcNum);
								f->Flags[FFCF_ETHEREAL] = false;
								f->X = MooshPit[_MP_ENTRYX];
								f->Y = MooshPit[_MP_ENTRYY];
							}
						}

						//Move Link to the entry and make him visible
						Link->X = MooshPit[_MP_ENTRYX];
						Link->Y = MooshPit[_MP_ENTRYY];

						Link->Invisible = false;
						Link->CollDetection = true;
					}

					//Subtract HP based on damage type
					if(MooshPit[_MP_DAMAGETYPE]==1)
						Link->HP -= DAMAGE_FALLLAVA;
					else
					Link->HP -= DAMAGE_FALLHOLE;
					//Play hurt sound and animation
					Link->Action = LA_GOTHURTLAND;
					Link->HitDir = -1;
					Game->PlaySound(SFX_OUCH);

					MooshPit[_MP_FALLSTATE] = 0;
				}
				else{
					MooshPit[_MP_FALLSTATE] = 2;
					MooshPit[_MP_FALLTIMER] = 1;
					ffc warp = Screen->LoadFFC(FFC_MOOSHPIT_AUTOWARPA);
					warp->Data = CMB_MOOSHPIT_AUTOWARPA;
					warp->Flags[FFCF_CARRYOVER] = false;
				}
			}
		}
		else if(MooshPit[_MP_FALLSTATE]==2){ //Just warped
			if(sideview){
				Link->X = MooshPit[_MP_FALLX];
				Link->Y = 0;
			}
			else{
				Link->X = MooshPit[_MP_FALLX];
				Link->Y = MooshPit[_MP_FALLY];
				Link->Z = 176;
			}
			Link->Invisible = false;
			Link->CollDetection = true;

			if(MOOSHPIT_NO_MOVE_WHILE_FALLING){
				MooshPit[_MP_FALLSTATE] = 3;
				NoAction();
			}
			else
			MooshPit[_MP_FALLSTATE] = 0;
			MooshPit[_MP_FALLTIMER] = 0;
		}
		else if(MooshPit[_MP_FALLSTATE]==3){ //Falling into a new room (no action)
			if(MOOSHPIT_STUN_ENEMIES_WHILE_FALLING)
				MooshPit_StunEnemies();

			NoAction();
			if(IsSideview()){
				if(OnSidePlatform(Link->X, Link->Y))
					MooshPit[_MP_FALLSTATE] = 0;
			}
			else{
				if(Link->Z<=0)
					MooshPit[_MP_FALLSTATE] = 0;
			}
		}
	}
}

void MooshPit_ResetEntry(){
	MooshPit[_MP_ENTRYX] = Link->X;
	MooshPit[_MP_ENTRYY] = Link->Y;
	MooshPit[_MP_ENTRYDMAP] = Game->GetCurDMap();
	MooshPit[_MP_ENTRYSCREEN] = Game->GetCurDMapScreen();
}

ffc script MooshPit_StairsFix{
	void run(){
		this->Flags[FFCF_ETHEREAL] = false;
		while(LinkCollision(this)){
			Waitframe();
		}
		this->X = 0;
		this->Y = 0;
		this->Data = 0;
	}
}

//%MGSO% HEADER_END MooshPit

//%MGSO% HEADER_START Confusion

const int CR_CONFUSION = 7; //The counter to use for confusion. CR_SCRIPT# values are 7-31.

global script Init
{
	void run()
	{
		Game->MCounter[CR_CONFUSION]=65535; //Max
	}
}



void UpdateConfusion()
{
	if(Link->Drunk > 0)
		{
		Game->Counter[CR_CONFUSION]=Link->Drunk;
		Link->Drunk=0;
	}
	if(Game->Counter[CR_CONFUSION]>0)
		{
		Game->Counter[CR_CONFUSION]--;
		if(Link->InputUp != Link->InputDown)
			{
			Link->InputUp = !Link->InputUp;
			Link->InputDown = !Link->InputDown;
		}
		if(Link->InputLeft != Link->InputRight)
			{
			Link->InputLeft = !Link->InputLeft;
			Link->InputRight = !Link->InputRight;
		}
	}
}


item script RemoveConfusion
{
	void run()
	{
		Game->Counter[CR_CONFUSION]=NULL;
	}
}
//%MGSO% HEADER_END Confusion

//%MGSO% HEADER_START SolidFFC

//Global Constants
const int MISC_SOLIDFFC		  = 14; //A misc value between 0 and 15 to denote a ffc as solid.
const int MISC_SFFC_X			= 0;  //This can be used by other ffcs as long as they're not solid.
const int SFFC_SIDEVIEWTHRESHOLD = 12; //Sideview X Overlap: used for hitdetection.
const int CRUSH_DAMAGE		   = 16;  //Damage in 16ths of a heart dealt to link when he is crushed.
const int SF_SIDEWARP			= 2;  //The flag to denote that Left/Right sidewarps are used on a screen.
const int BIG_LINK			   = 0;
const int CT_LADDER			  = 0;  //If not using CT_RIGHTSTATUE

//Don't touch me, don't even think about setting these variables. HEY!
float SFFC_LinkX;
float SFFC_LinkY;

//NEVER USE THIS, JUST CALL 'Screen->isSolid()' INSTEAD!
bool isSolid(int x, int y)
{
	return Screen->isSolid(x,y);
}
// this utility is used by the ffcs to check if the platform can move link.
bool CanMoveLink(int x){
	if(x > 0) x+=Link->X+16;
	else if(x < 0) x+=Link->X-1;
	if(x<0) return (Game->GetCurScreen()%16==0 && ScreenFlag(SF_MISC, SF_SIDEWARP));
	if(x>240) return (Game->GetCurScreen()%16==15 && ScreenFlag(SF_MISC,SF_SIDEWARP));
	int mask;
	if(x < Link->X) mask = 1100b;
	else mask = 11b;
	if(Cond(BIG_LINK || IsSideview(),false,true)){
		if(Link->Y % 16 < 8) mask &= ~101b;
	}
	return (Screen->ComboS[ComboAt(x, Link->Y)]&mask)==0 && !OnLadder();
}

// You can customize these functions to suit your needs.
// this utility is used to check if link is doing something that would interfer with him using an item.
bool LinkBusy()
{
	return (Link->Action==LA_ATTACKING||Link->Action == LA_CHARGING||Link->Action==LA_FROZEN);
}

// this utility is used to check if link using the feather.
bool UseFeather()
{
	return !LinkBusy() && ((GetEquipmentA()==I_ROCSFEATHER && Link->PressA) || (GetEquipmentB()==I_ROCSFEATHER && Link->PressB));
}

// this utility is used to check if link is on a sideview ladder.
bool OnLadder()
{
	int ct = Screen->ComboT[ComboAt(CenterLinkX(),CenterLinkY())];
	return (ct == Cond(CT_LADDER==0,CT_RIGHTSTATUE,CT_LADDER));
}


//Editing anything beneath this point may cause sickness, coma, brain anuerysm, or death.
//Do so at your own risk and don't hold me responsible. Have a good day! ^_^

void SolidFFCs(int startx, int starty, int linkxpos, int linkypos, bool dragged)
{
	int reservedx = Link->X;
	int reservedy = Link->Y;
	bool linkmoved[4]; //Up Down Left Right
	int edge[2];
	bool crushed;
	for(int i = 1; i <= 32 && !crushed; i++)
	{
		ffc f = Screen->LoadFFC(i);
		if(!f->Misc[MISC_SOLIDFFC]) continue;
		if(!SFFC_LinkCollision(f, edge)) continue;
		if(!SFFC_SetDirection(f, linkmoved, edge, linkxpos, linkypos))
			{
			crushed = SFFC_CrushLink(f, linkmoved, edge, startx, starty, dragged);
			continue;
		}
		crushed = SFFC_CrushLink(f, linkmoved, edge, startx, starty, dragged);
		if(!crushed)
			{
			if(edge[0]==DIR_UP || edge[0]==DIR_DOWN)
				{
				if(!IsSideview())
					{
					SFFC_LinkY += edge[1];
					if(Abs(SFFC_LinkY) >= 1) Link->Y += Floor(SFFC_LinkY);
					SFFC_LinkY -= Floor(SFFC_LinkY);
				}
				else if(edge[0]==DIR_UP)
				{
					if(!(OnLadder() && UseFeather()))
						Link->Jump=0; //Negate dat dang gravity
				}
				if(Link->InputLeft || Link->InputRight) Link->X = reservedx;
			}
			else if(edge[0]==DIR_LEFT ||edge[0]==DIR_RIGHT)
			{
				SFFC_LinkX += edge[1];
				if(Abs(SFFC_LinkX) >= 1) Link->X += Floor(SFFC_LinkX);
				SFFC_LinkX -= Floor(SFFC_LinkX);
				if(Link->InputUp || Link->InputDown || IsSideview()) Link->Y=reservedy;
			}
			reservedx=Link->X;
			reservedy=Link->Y;
		}
	}
}

//As usual Sideview gravity breaks everything even solid ffcs. XD
int SFFC_SideviewShenanigans(int linkxpos, int linkypos)
{
	bool linkmoved[4]; //Up Down Left Right
	int edge[2];
	float dragged;
	for(int i = 1; i <= 32; i++)
	{
		ffc f = Screen->LoadFFC(i);
		if(!f->Misc[MISC_SOLIDFFC]) continue;
		if(!SFFC_LinkCollision(f, edge) || !SFFC_SetDirection(f, linkmoved, edge, linkxpos, linkypos))
			{
			f->Misc[MISC_SFFC_X] = f->X;
			continue;
		}
		if(edge[0]==DIR_UP)
			{
			if(!OnLadder())
				{
				if(UseFeather())
					{
					itemdata feather = Game->LoadItemData(I_ROCSFEATHER);
					Link->Jump = feather->InitD[0];
					Game->PlaySound(feather->UseSound);
					f->Misc[MISC_SFFC_X] = f->X;
					break; //Cause it should only happen once per frame.
				}
				else
				{
					if(Link->Jump<=0) Link->Jump=0;
					Link->Y = f->Y-16;
				}
				linkypos = Link->Y;
			}
			if(CanMoveLink(f->X-f->Misc[MISC_SFFC_X]))
				{
				SFFC_LinkX += f->X-f->Misc[MISC_SFFC_X];
				if(Abs(SFFC_LinkX) >= 1)
					{
					Link->X += Floor(SFFC_LinkX);
					SFFC_LinkX -= Floor(SFFC_LinkX);
				}
				linkxpos = Link->X;
				dragged=0.9999;
			}
			else
			{
				linkxpos = Link->X;
				Link->Jump=0;
				dragged=0;
			}
		}
		else if(edge[0]==DIR_DOWN && Link->Jump>0)
		{
			Link->Jump=0;
		}
		f->Misc[MISC_SFFC_X] = f->X;
	}
	return (linkxpos|(linkypos<<8))+dragged;
}

//Link Collision
bool SFFC_LinkCollision(ffc f, int edge)
{
	int linktop = Link->Y+Cond(BIG_LINK || IsSideview(), 0, 8)>>0;
	int linkbottom = Link->Y+15>>0;
	int linkleft = Link->X>>0;
	int linkright = Link->X+15>>0;
	int top = HitboxTop(f)>>0;
	int bottom = HitboxBottom(f)>>0;
	int left = HitboxLeft(f)>>0;
	int right = HitboxRight(f)>>0;
	int mod=0;
	if(IsSideview()) mod = SFFC_SIDEVIEWTHRESHOLD;
	// horizontal
	if(linktop < bottom && linkbottom > top)
		{
		if(IsSideview()) mod = 16-mod; //Less math.
		if(CenterLinkX() < CenterX(f)) // Left Side
			{
			edge[0]=DIR_LEFT;
			return (linkright >= left+mod);
		}
		else //Right Side
		{
			edge[0]=DIR_RIGHT;
			return (linkleft <= right-mod);
		}
	}
	// vertical
	else if(linkleft < right && linkright > left)
	{
		if(CenterLinkY() < CenterY(f)) // Top Side
			{
			edge[0]=DIR_UP;
			if(IsSideview()) return linkbottom+1 >= top && (linkleft > left-mod && linkleft < left+mod+(f->TileWidth-1)*16);
			else return (linkbottom >= top);
		}
		else //Bottom Side
		{
			edge[0]=DIR_DOWN;
			return (linktop <= bottom);
		}
	}
	else return false;
}

bool SFFC_SetDirection(ffc f, bool linkmoved, int edge, int linkxpos, int linkypos)
{
	//Move link to his old position.
	int x = Link->X;
	int y = Link->Y;
	Link->X = linkxpos;
	Link->Y = linkypos;
	//Then check for collisions again.
	bool ret = SFFC_LinkCollision(f, edge);
	//If we get here we know he didn't walk on the ffc and we got stuff to do.
	if(edge[0]==DIR_UP) edge[1] = -Abs(HitboxTop(f)-(Link->Y+15));
	else if(edge[0]==DIR_DOWN) edge[1] = Abs(HitboxBottom(f)-(Link->Y+Cond(BIG_LINK || IsSideview(),0,8)));
	else if(edge[0]==DIR_LEFT) edge[1] = -Abs(HitboxLeft(f)-(Link->X+15));
	else if(edge[0]==DIR_RIGHT) edge[1] = Abs(HitboxRight(f)-Link->X);
	linkmoved[edge[0]] = true;
	if(!ret)
		{
		if(Link->X >= HitboxLeft(f)-15 && Link->X <= HitboxRight(f) &&
			(Link->InputLeft||Link->InputRight)) Link->X=x;
		else if(Link->Y >= HitboxTop(f)-15 && Link->Y+Cond(BIG_LINK || IsSideview(),0,8) <= HitboxBottom(f) &&
		(Link->InputUp||Link->InputDown) || IsSideview()) Link->Y=y;
	}
	return ret;
}

bool SFFC_CrushLink(ffc f, bool linkmoved, int edge, int linkx, int linky, bool dragged)
{
	// Solid Combos
	bool crush; //Canwalk sucks, do it yourself guys. :)
	if(!IsSideview()) dragged = false;
	if(edge[0]==DIR_UP)
		{
		crush = Screen->isSolid(Floor(CenterLinkX()), Floor(Link->Y+Cond(BIG_LINK || IsSideview(), 0,8)+edge[1])) && !dragged;
		if(IsSideview() && crush) crush = (Floor(Link->Y)+16+edge[1]>=HitboxTop(f)); //Squash Bug Fix.
	}
	else if(edge[0]==DIR_DOWN)
	crush = Screen->isSolid(Floor(CenterLinkX()), Floor(Link->Y+15+edge[1]));
	else if(edge[0]==DIR_LEFT)
	crush = Screen->isSolid(Floor(Link->X+edge[1]), Floor(Link->Y+Cond(BIG_LINK || IsSideview(), 0,8)));
	else if(edge[0]==DIR_RIGHT)
	crush = Screen->isSolid(Floor(Link->X+15+edge[1]), Floor(Link->Y+Cond(BIG_LINK || IsSideview(), 0,8)));
	// Solid FFCs
	if(!crush)
		{
		for(int i; i < 4; i++)
		{
			if(linkmoved[i] && i==OppositeDir(edge[0]))
				{
				crush=true;
				break;
			}
		}
	}
	// Crushing Behavior
	if(crush)
		{
		Link->X = Clamp(linkx,0,240);
		Link->Y = Clamp(linky,0,160);
		Link->HP -= CRUSH_DAMAGE;
		Link->Action = LA_GOTHURTLAND;
		Link->HitDir = -1;
		Game->PlaySound(SFX_OUCH);
	}
	return crush;
}

ffc script SolidFFC
{
	void run()
	{
		this->Misc[MISC_SOLIDFFC] = 1;
		this->Misc[MISC_SFFC_X] = this->X;
	}
}
//%MGSO% HEADER_END SolidFFC

global script MGSO_Combined
{
	void run()
	{
		//%MGSO% INIT_START ScrollingBackgrounds

		ScrollingBG_Init();
		//%MGSO% INIT_END ScrollingBackgrounds

		//%MGSO% INIT_START MovingPlatforms

		//%MGSO% INIT_END MovingPlatforms

		//%MGSO% INIT_START MooshPit

		MooshPit_Init();
		//%MGSO% INIT_END MooshPit

		//%MGSO% INIT_START Confusion

		//%MGSO% INIT_END Confusion

		//%MGSO% INIT_START SolidFFC

		int olddmap = Game->GetCurDMap();
		int oldscreen = Game->GetCurScreen();
		int startx = Link->X;
		int starty = Link->Y;
		int linkxpos = startx;
		int linkypos = starty;
		bool dragged;
		//%MGSO% INIT_END SolidFFC

		while(true)
		{
			//%MGSO% UPDATE1_START ScrollingBackgrounds

			ScrollingBG_Update();

			//%MGSO% UPDATE1_END ScrollingBackgrounds

			//%MGSO% UPDATE1_START MovingPlatforms

			NesMovementFix();
			//%MGSO% UPDATE1_END MovingPlatforms

			//%MGSO% UPDATE1_START MooshPit

			MooshPit_Update();
			//%MGSO% UPDATE1_END MooshPit

			//%MGSO% UPDATE1_START Confusion

			//Waitdraw();
			UpdateConfusion();
			//%MGSO% UPDATE1_END Confusion

			//%MGSO% UPDATE1_START SolidFFC

			if((Link->Action!=LA_SCROLLING) && (olddmap != Game->GetCurDMap() || oldscreen != Game->GetCurScreen()))
				{
				olddmap = Game->GetCurDMap();
				oldscreen = Game->GetCurScreen();
				startx = Link->X;
				starty = Link->Y;
			}
			if(IsSideview())
				{
				//A fix for something I should of done different D:
				float linkposition = SFFC_SideviewShenanigans(linkxpos, linkypos);
				linkxpos = linkposition&0xFF;
				linkypos = (linkposition>>8)&0xFF;
				if((linkposition%1)*10000) dragged=true;
				else dragged=false;
			}
			//%MGSO% UPDATE1_END SolidFFC
			Waitdraw();
			//%MGSO% UPDATE2_START ScrollingBackgrounds


			//%MGSO% UPDATE2_END ScrollingBackgrounds

			//%MGSO% UPDATE2_START MovingPlatforms

			MovingPlatforms();
			//%MGSO% UPDATE2_END MovingPlatforms

			//%MGSO% UPDATE2_START MooshPit

			//%MGSO% UPDATE2_END MooshPit

			//%MGSO% UPDATE2_START Confusion

			//%MGSO% UPDATE2_END Confusion

			//%MGSO% UPDATE2_START SolidFFC

			SolidFFCs(startx, starty, linkxpos, linkypos, dragged);
			linkxpos = Link->X;
			linkypos = Link->Y;
			//%MGSO% UPDATE2_END SolidFFC

			Waitframe();
		}
	}
	//%MGSO% FUNCTIONS_START ScrollingBackgrounds

	//%MGSO% FUNCTIONS_END ScrollingBackgrounds

	//%MGSO% FUNCTIONS_START MovingPlatforms

	//%MGSO% FUNCTIONS_END MovingPlatforms

	//%MGSO% FUNCTIONS_START MooshPit

	//%MGSO% FUNCTIONS_END MooshPit

	//%MGSO% FUNCTIONS_START Confusion

	//%MGSO% FUNCTIONS_END Confusion

	//%MGSO% FUNCTIONS_START SolidFFC

	//%MGSO% FUNCTIONS_END SolidFFC
}

//start Bomb Arrows

lweapon script BombArrow
{
	void run(int bombDamage)
	{
		//Initialize the arrow
		this->X = Hero->X + dirX(Hero->Dir) * 8;
		this->Y = Hero->Y + dirY(Hero->Dir) * 8;
		this->Dir = Hero->Dir;
		//Loop while it lives
		while(this->DeadState != WDS_DEAD)
		{
			int x = this->X + 4, y = this->Y + 4;
			for(int q = 0; q < 3; ++q)
			{
				for(int p = 0; p < 3; ++p)
				{
					if(Screen->isSolid(x,y)
						|| ComboFI(ComboAt(x,y),CF_BOMB))
					{
						//Kill the arrow; it collided with something
						this->DeadState = WDS_DEAD;
						q = 3;
						break;
					}
					y += 4;
				}
				x += 4;
			}
			if(this->DeadState == WDS_DEAD) break;
			Waitframe();
		}
		//When the arrow dies, explode!
		lweapon bomb = CreateLWeaponAt(LW_BOMBBLAST, this->X, this->Y);
		bomb->Damage = bombDamage;
	}

	//start extra functions
	/**
	* Returns 1 if the dir is rightward, -1 if leftward, 0 if neither
	*/
	int dirX(int dir) //start
	{
		switch(dir)
		{
			case DIR_RIGHT: case DIR_RIGHTUP: case DIR_RIGHTDOWN:
				return 1;
			case DIR_LEFT: case DIR_LEFTUP: case DIR_LEFTDOWN:
				return -1;
			default:
				return 0;
		}
	} //end

	/**
	* Returns 1 if the dir is downward, -1 if upward, 0 if neither
	*/
	int dirY(int dir) //start
	{
		switch(dir)
		{
			case DIR_DOWN: case DIR_LEFTDOWN: case DIR_RIGHTDOWN:
				return 1;
			case DIR_UP: case DIR_LEFTUP: case DIR_RIGHTUP:
				return -1;
			default:
				return 0;
		}
	} //end
	//end extra functions
}

//end Bomb Arrows

//Pushable Pillars

const int PILLAR_SENSITIVITY=8; //Number of frames the block needs to be pushed before it starts moving

ffc script PushablePillars{
	void run(int orientation, int distance){ //Horizontal/Vertical pushing
	distance=distance*16;
	int undercombo;
	int framecounter=0;
	int pushcounter=0;
	int anicounter=0;
	int anitile=0;
	int originaltile=this->Data;
	int pushspeed=1;
	int width=this->TileWidth;
	int height=this->TileHeight;

		Waitframe();
		undercombo=GetLayerComboD(1,this->Y+(this->X>>4));
		if(orientation==1){ SetSolidCombo(3,this->X,this->Y,width,height,this->Data); } //Horizontally
		if(orientation==2){ SetSolidCombo(1,this->X,this->Y,width,height,this->Data); } //Vertically

		while(true){
			if((Link->X==this->X-16 && (Link->Y<this->Y+4+((height-1)*16) && Link->Y>this->Y-4)
			&& Link->InputRight && Link->Dir==DIR_RIGHT && orientation==1) || // Right

			(Link->X==this->X+16 && (Link->Y<this->Y+4+((height-1)*16) && Link->Y>this->Y-4)
			&& Link->InputLeft && Link->Dir==DIR_LEFT && orientation==1) || // Left

			(Link->Y==this->Y-16 && (Link->X<this->X+4+((width-1)*16) && Link->X>this->X-4)
			&& Link->InputDown && Link->Dir==DIR_DOWN && orientation==2) || // Down

			(Link->Y==this->Y+8 && (Link->X<this->X+4+((width-1)*16) && Link->X>this->X-4) //Change the 8 to 16 if you use big Link
			&& Link->InputUp && Link->Dir==DIR_UP && orientation==2)
			){ // Up
		framecounter++;
		}
		else{ framecounter=0; }

		if(framecounter>=PILLAR_SENSITIVITY){

			if(Link->Dir==DIR_RIGHT){
				while(
				this->X<240 &&
				!ComboFI(this->X+16,this->Y,CF_NOBLOCKS) &&
				NoSolidBlocks(4,this->X,this->Y,width,height)==true &&
				pushcounter<distance
				){
					if(pushcounter==0){ Game->PlaySound(SFX_PUSHBLOCK); }
					if(pushcounter<distance/2){ NoAction(); }
					if(pushcounter%4==0 && pushcounter!=0){ anitile+=1; }
					if(anitile>3){ anitile=0; }
					SetSolidCombo(4,this->X,this->Y,width,height,undercombo);
					this->Vx=pushspeed;
					this->Data=originaltile+anitile;
					pushcounter+=pushspeed;
					Waitframe();
					if(pushcounter%16==0){ SetUnderCombo(4,this->X-16,this->Y,width,height); }
				}
			this->Vx=0;
			this->Data=originaltile;
			pushcounter=0;
			anitile=0;
			SetSolidCombo(4,this->X,this->Y,width,height,this->Data);
			}

			else if(Link->Dir==DIR_LEFT){
				while(
				this->X>0 &&
				!ComboFI(this->X-1,this->Y,CF_NOBLOCKS) &&
				NoSolidBlocks(3,this->X,this->Y,width,height)==true &&
				pushcounter<distance
				){
					if(pushcounter==0){ Game->PlaySound(SFX_PUSHBLOCK); }
					if(pushcounter<distance/2){ NoAction(); }
					if(pushcounter%4==0 && pushcounter!=0){ anitile-=1; }
					if(anitile<0){ anitile=3; }
					SetSolidCombo(3,this->X,this->Y,width,height,undercombo);
					this->Vx=-pushspeed;
					this->Data=originaltile+anitile;
					pushcounter+=pushspeed;
					Waitframe();
					if(pushcounter%16==0){ SetUnderCombo(3,this->X+16,this->Y,width,height); }
				}
			this->Vx=0;
			this->Data=originaltile;
			pushcounter=0;
			anitile=0;
			SetSolidCombo(3,this->X,this->Y,width,height,this->Data);
			}

			else if(Link->Dir==DIR_DOWN){
				while(
				this->Y<160 &&
				!ComboFI(this->X, this->Y+16, CF_NOBLOCKS) &&
				NoSolidBlocks(2,this->X,this->Y,width,height)==true &&
				pushcounter<distance
				){
					if(pushcounter==0){ Game->PlaySound(SFX_PUSHBLOCK); }
					if(pushcounter<distance/2){ NoAction(); }
					if(pushcounter%4==0 && pushcounter!=0){ anitile+=4; }
					if(anitile>12){ anitile=0; }
					SetSolidCombo(2,this->X,this->Y,width,height,undercombo);
					this->Vy=pushspeed;
					this->Data=originaltile+anitile;
					pushcounter+=pushspeed;
					Waitframe();
					if(pushcounter%16==0){ SetUnderCombo(2,this->X,this->Y-16,width,height); }
				}
			this->Vy=0;
			this->Data=originaltile;
			pushcounter=0;
			anitile=0;
			SetSolidCombo(2,this->X,this->Y,width,height,this->Data);
			}

			else if(Link->Dir==DIR_UP){
				while(
				this->Y>0 &&
				!ComboFI(this->X, this->Y-1, CF_NOBLOCKS) &&
				NoSolidBlocks(1,this->X,this->Y,width,height)==true &&
				pushcounter<distance
				){
					if(pushcounter==0){ Game->PlaySound(SFX_PUSHBLOCK); }
					if(pushcounter<distance/2){ NoAction(); }
					if(pushcounter%4==0 && pushcounter!=0){ anitile-=4; }
					if(anitile<0){ anitile=12; }
					SetSolidCombo(1,this->X,this->Y,width,height,undercombo);
					this->Vy=-pushspeed;
					this->Data=originaltile+anitile;
					pushcounter+=pushspeed;
					Waitframe();
					if(pushcounter%16==0){ SetUnderCombo(1,this->X,this->Y+16,width,height); }
				}
			this->Vy=0;
			this->Data=originaltile;
			pushcounter=0;
			anitile=0;
			SetSolidCombo(1,this->X,this->Y,width,height,this->Data);
			}

		 framecounter=0;
		 }

		 Waitframe();
	  }
   }
}


bool NoSolidBlocks(int direction, int xpos, int ypos, int width, int height){
int size=1;
	if(direction==1 || direction==2){ size=width; } //Vertical pushing
	if(direction==3 || direction==4){ size=height; } //Horizontal pushing

	for(int i=size-1; i>=0; i--){
		if(xpos%16==0 && ypos%16==0){
			if(direction==1){ if(Screen->ComboS[ypos-16+((xpos+(i*16))>>4)]!=0000b){ return(false); } }
			if(direction==2){ if(Screen->ComboS[ypos+16+((xpos+(i*16))>>4)]!=0000b){ return(false); } }
			if(direction==3){ if(Screen->ComboS[ypos+(i*16)+((xpos-16)>>4)]!=0000b){ return(false); } }
			if(direction==4){ if(Screen->ComboS[ypos+(i*16)+((xpos+16)>>4)]!=0000b){ return(false); } }
		}
	}
	return(true);
}

int SetSolidCombo(int direction, int xpos, int ypos, int width, int height, int data){
int size=1;
	if(direction==1 || direction==2){ size=width; } //Vertical pushing
	if(direction==3 || direction==4){ size=height; } //Horizontal pushing

	for(int i=size-1; i>=0; i--){
		if(xpos%16==0 && ypos%16==0){
			if(direction==1){ Screen->ComboD[ypos+((xpos+(i*16))>>4)]=data; }
			if(direction==2){ Screen->ComboD[ypos+((xpos+(i*16))>>4)]=data; }
			if(direction==3){ Screen->ComboD[ypos+(i*16)+(xpos>>4)]=data; }
			if(direction==4){ Screen->ComboD[ypos+(i*16)+(xpos>>4)]=data; }
		}
	}
}

int SetUnderCombo(int direction, int xpos, int ypos, int width, int height){
int size=1;
	if(direction==1 || direction==2){ size=width; } //Vertical pushing
	if(direction==3 || direction==4){ size=height; } //Horizontal pushing

	for(int i=size-1; i>=0; i--){
		if(xpos%16==0 && ypos%16==0){
			if(direction==1){ Screen->ComboD[ypos+((xpos+(i*16))>>4)]=GetLayerComboD(1,ComboAt(xpos+(i*16),ypos)); }
			if(direction==2){ Screen->ComboD[ypos+((xpos+(i*16))>>4)]=GetLayerComboD(1,ComboAt(xpos+(i*16),ypos)); }
			if(direction==3){ Screen->ComboD[ypos+(i*16)+(xpos>>4)]=GetLayerComboD(1,ComboAt(xpos,ypos+(i*16))); }
			if(direction==4){ Screen->ComboD[ypos+(i*16)+(xpos>>4)]=GetLayerComboD(1,ComboAt(xpos,ypos+(i*16))); }
			if(direction==1){ Screen->ComboT[ypos+((xpos+(i*16))>>4)]=GetLayerComboT(1,ComboAt(xpos+(i*16),ypos)); }
			if(direction==2){ Screen->ComboT[ypos+((xpos+(i*16))>>4)]=GetLayerComboT(1,ComboAt(xpos+(i*16),ypos)); }
			if(direction==3){ Screen->ComboT[ypos+(i*16)+(xpos>>4)]=GetLayerComboT(1,ComboAt(xpos,ypos+(i*16))); }
			if(direction==4){ Screen->ComboT[ypos+(i*16)+(xpos>>4)]=GetLayerComboT(1,ComboAt(xpos,ypos+(i*16))); }
		}
	}
}


																																							//Different Armos

ffc script differentArmos{
	void run ( int newTile, int cset ){
		while ( true ){
			for ( int i = Screen->NumNPCs(); i > 0; i-- ){
				npc enem = Screen->LoadNPC(i);
				if ( enem->ID == NPC_ARMOS && (enem->Misc[15] & 0x10000) == 0  ){ //check some flag...
					enem->CSet = cset;
					enem->OriginalTile = newTile;
					enem->Misc[15] |= 0x10000;
				}
			}
			Waitframe();
		}
	}
}

																																						   //Perm Push Blocks

//Instructions:
//1. Make a new combo with inherent flag 16 (or any secret flag)
//2. Set this FFC to the above combo
//3. When secrets are triggered by blocks, this script will make it permanent
ffc script blockPermSecrets{
	void run(){
		int thisCombo = this->Data;
		while(!Screen->State[ST_SECRET]){
			if(this->Data != thisCombo) Screen->State[ST_SECRET] = true;
			Waitframe();
		}
	}
}


																																						   //MogShop

const int MogShop_DefaultFailMessage = 1; // Default message to play when Link can't afford the item

const int MogShop_PriceTag = 1; // use 0 if you don't want to display price tags, otherwise use 1
const int MogShop_FontColour = 0x01; // colour of the price tag font (the 2 digits after "0x" is the code for your colour)
const int MogShop_FontOutline = 0x0F; // colour of the price tag font's outline
const int MogShop_FontType = 16; // which font to use (0 is the Z1 font, 16 is the LA font. you might have to look up std_constants.zh or just experiment)
const int MogShop_FontYOffset = -8; // positional offset of the price tag on the Y axis relative to the FFC

const int MogShop_SoldOutComboID = 1054; // ID of the combo for the FFC to be when the item is sold out (can't use 0)
const int MogShop_SoldOutComboCSet = 8; // CSet of the combo

const int MogShop_InteractComboID = 0; // ID of the combo to show above Link's head when he's standing in front of the item. Use 0 if you don't want any.
const int MogShop_InteractComboCSet = 8; // CSet of the combo

ffc script MogShop{
	void run(int ShopItem, int InfoMessage, int Price, int Currency, int OnlyOnceID, int FailMessage, int CollisionStyle){
		// Saves the width and height of the FFC for collision checks
		int Width = 16;
		int Height = 16;
		if(this->EffectWidth!=16)
			Width = this->EffectWidth;
		else if(this->TileWidth>1)
			Width = this->TileWidth*16;
		if(this->EffectHeight!=16)
			Height = this->EffectHeight;
		else if(this->TileHeight>1)
			Height = this->TileHeight*16;
		// Determine collision check position
		int HitX = this->X;
		int HitY = this->Y;
		if ( CollisionStyle != 0 )
			HitY = this->Y + 8;

		// Disable the shop if the item is sold out
		int SoldOutComboID = MogShop_SoldOutComboID;
		if ( SoldOutComboID < 0 )
			SoldOutComboID = 1;
		if ( OnlyOnceID >= 0 ) {
			if ( Screen->D[OnlyOnceID] == 1 ) {
				this->Data = SoldOutComboID;
				this->CSet = MogShop_SoldOutComboCSet;
				while(true){
					DrawOverUpdate(this, HitX, HitY, CollisionStyle);
					Waitframe();
				}
			}
		}

		// Determine currency
		int CounterToUse = Currency;
		if ( Currency <= 0 )
			CounterToUse = 1;

		// Create price tag string
		int PriceTag[100];
		itoa(PriceTag, Price);

		// Determine price tag layer
		int PriceTagLayer;
		if ( CollisionStyle != 0 )
			PriceTagLayer = 6;

		while(true){
			// Check collision with the item
			bool CanInteract;
			if ( LinkCanInteract() ) {
				// Facing Up
				if(Link->Dir==DIR_UP&&Link->Y>=HitY&&Link->Y<=HitY+Height-8&&Link->X>=HitX-8&&Link->X<=HitX+Width-8)
					CanInteract = true;
				else if ( CollisionStyle == 0 ) { // Only allow other directions when CollisionStyle is 0
					// Facing Down
					if(Link->Dir==DIR_DOWN&&Link->Y>=HitY-16&&Link->Y<=HitY+Height-16&&Link->X>=HitX-8&&Link->X<=HitX+Width-8)
						CanInteract = true;
					// Facing Left
					else if(Link->Dir==DIR_LEFT&&Link->Y>=HitY-8&&Link->Y<=HitY+Height-9&&Link->X>=HitX&&Link->X<=HitX+Width)
						CanInteract = true;
					// Facing Right
					else if(Link->Dir==DIR_RIGHT&&Link->Y>=HitY-8&&Link->Y<=HitY+Height-9&&Link->X>=HitX-16&&Link->X<=HitX+Width-16)
						CanInteract = true;
				}
			}

			DrawOverUpdate(this, HitX, HitY, CollisionStyle);

			// Draw price tag
			if ( MogShop_PriceTag == 1 ) {
				Screen->DrawString(PriceTagLayer, this->X+8 +1, this->Y+MogShop_FontYOffset, MogShop_FontType, MogShop_FontOutline, -1, TF_CENTERED, PriceTag, OP_OPAQUE);
				Screen->DrawString(PriceTagLayer, this->X+8 -1, this->Y+MogShop_FontYOffset, MogShop_FontType, MogShop_FontOutline, -1, TF_CENTERED, PriceTag, OP_OPAQUE);
				Screen->DrawString(PriceTagLayer, this->X+8, this->Y+MogShop_FontYOffset +1, MogShop_FontType, MogShop_FontOutline, -1, TF_CENTERED, PriceTag, OP_OPAQUE);
				Screen->DrawString(PriceTagLayer, this->X+8, this->Y+MogShop_FontYOffset -1, MogShop_FontType, MogShop_FontOutline, -1, TF_CENTERED, PriceTag, OP_OPAQUE);
				Screen->DrawString(PriceTagLayer, this->X+8, this->Y+MogShop_FontYOffset, MogShop_FontType, MogShop_FontColour, -1, TF_CENTERED, PriceTag, OP_OPAQUE);
			}

			// Handle interaction
			if ( CanInteract ) {
				if ( Link->PressA ) {
					Link->InputA = false;
					Link->PressA = false;
					Screen->Message(InfoMessage);
				}
				else if ( Link->PressR ) {
					Link->InputR = false;
					Link->PressR = false;

					// Check if affordable
					if ( Game->Counter[CounterToUse] >= Price && (CounterToUse != CR_LIFE || Game->Counter[CR_LIFE] - Price > 0) ) {
						Game->DCounter[CounterToUse] -= Price;
						item drop = CreateItemAt(ShopItem, Link->X, Link->Y);
						SetItemPickup(drop, IP_HOLDUP, true);

						if ( OnlyOnceID >= 0 ) { // Check if it can only be bought once
							Screen->D[OnlyOnceID] = 1;
							this->Data = SoldOutComboID;
							this->CSet = MogShop_SoldOutComboCSet;
							while(true){
								DrawOverUpdate(this, HitX, HitY, CollisionStyle);
								Waitframe();
							}
						}
					}
					else { // Can't afford
						if ( FailMessage > 0 )
							Screen->Message(FailMessage);
						else
							Screen->Message(MogShop_DefaultFailMessage);
					}
				}
				else if ( MogShop_InteractComboID > 0 )
					Screen->FastCombo(6, Link->X, Link->Y-16, MogShop_InteractComboID, MogShop_InteractComboCSet, OP_OPAQUE);
			}
			Waitframe();
		}
	}
	bool LinkCanInteract(){
		if ( Link->Action != LA_NONE && Link->Action != LA_WALKING )
			return false;
		if ( Link->Z > 0 )
			return false;
		return true;
	}
	void DrawOverUpdate(ffc this, int HitX, int HitY, int CollisionStyle){
		// Toggle draw-over if CollisionStyle is not 0
		if ( CollisionStyle != 0 ) {
			if ( Link->Y < HitY )
				this->Flags[FFCF_OVERLAY] = true;
			else
				this->Flags[FFCF_OVERLAY] = false;
		}
	}
}

																																		   //Don't move - Character Direction Script

  //Character Direction Script

ffc script dontMove{
	void run(int dir){
		while(true){
			Link->Dir = dir;
			WaitNoAction();
		}
	}
}

																																		  //PlaySound

 //Trigger SFX Script

ffc script TriggerSFX{
	void run(int sfx){
		int loc = ComboAt(this->X,this->Y);
		int orig = Screen->ComboD[loc];
		while(Screen->ComboD[loc] == orig) Waitframe();
		Game->PlaySound(sfx);
	}
}


																																		  //SFX On Screen Entry

// D0 - The SFX ID that you want to play.
ffc script OnEntrySound{

	void run(int sfx){

		// Play the sound effect.
		Game->PlaySound(sfx);

		// Quit the script.
		Quit();
	}

}

																																		 //True Push Block Under Combo

//D0: If D0 >0, set to the map to use as reference for under combos
//D1: If D0 >0, set to the screen to use as reference for under combos (convert screen numbers from Hex to Decimal)
ffc script TruePushblockUnderCombo{
	void run(int refMap, int refScreen){
		int i;
		int pos;
		int cd; int cc; int cf; int ci;
		int pushBlockX;
		int pushBlockY;
		bool wasPushBlock; //Keeps track of whether a push block has started moving

		int underCMB[176];
		int underCS[176];
		int underFlag[176];

		//Mark which flags are push blocks
		bool pushFlags[105];
		pushFlags[CF_PUSHUPDOWN] = true;
		pushFlags[CF_PUSH4WAY] = true;
		pushFlags[CF_PUSHLR] = true;
		pushFlags[CF_PUSHUP] = true;
		pushFlags[CF_PUSHDOWN] = true;
		pushFlags[CF_PUSHLEFT] = true;
		pushFlags[CF_PUSHRIGHT] = true;
		pushFlags[CF_PUSHUPDOWNNS] = true;
		pushFlags[CF_PUSHLEFTRIGHTNS] = true;
		pushFlags[CF_PUSH4WAYNS] = true;
		pushFlags[CF_PUSHUPNS] = true;
		pushFlags[CF_PUSHDOWNNS] = true;
		pushFlags[CF_PUSHLEFTNS] = true;
		pushFlags[CF_PUSHRIGHTNS] = true;
		pushFlags[CF_PUSHUPDOWNINS] = true;
		pushFlags[CF_PUSHLEFTRIGHTINS] = true;
		pushFlags[CF_PUSH4WAYINS] = true;
		pushFlags[CF_PUSHUPINS] = true;
		pushFlags[CF_PUSHDOWNINS] = true;
		pushFlags[CF_PUSHLEFTINS] = true;
		pushFlags[CF_PUSHRIGHTINS] = true;

		//Set initial values for all combos on the screen
		for(i=0; i<176; i++){
			cd = Screen->ComboD[i];
			cc = Screen->ComboC[i];
			cf = Screen->ComboF[i];
			ci = Screen->ComboI[i];
			//Set combos underneath a push block
			if(pushFlags[cf] || pushFlags[ci]){
				//If a reference screen is set, draw from that
				if(refMap>0){
					underCMB[i] = Game->GetComboData(refMap, refScreen, i);
					underCS[i] = Game->GetComboCSet(refMap, refScreen, i);
					underFlag[i] = Game->GetComboFlag(refMap, refScreen, i);
				}
				//Otherwise use under combo
				else{
					underCMB[i] = Screen->UnderCombo;
					underCS[i] = Screen->UnderCSet;
					underFlag[i] = 0;
				}
			}
			else{
				underCMB[i] = cd;
				underCS[i] = cc;
				underFlag[i] = cf;
			}
		}

		while(true){
			//If there's a push block on the screen, manage undercombos
			if(Screen->MovingBlockX>-1){
				//If the block just started moving, set the undercombo
				if(!wasPushBlock){
					pos = ComboAt(Screen->MovingBlockX+8, Screen->MovingBlockY+8);
					Screen->ComboD[pos] = underCMB[pos];
					Screen->ComboC[pos] = underCS[pos];
					Screen->ComboF[pos] = underFlag[pos];
				}
				pushBlockX = Screen->MovingBlockX;
				pushBlockY = Screen->MovingBlockY;
				wasPushBlock = true;
			}
			else{
				wasPushBlock = false;

				for(i=0; i<176; i++){
					cd = Screen->ComboD[i];
					cc = Screen->ComboC[i];
					cf = Screen->ComboF[i];
					ci = Screen->ComboI[i];
					//Only update combos in the array if they aren't covered by a push block
					if(!(pushFlags[cf] || pushFlags[ci])){
						underCMB[i] = cd;
						underCS[i] = cc;
						underFlag[i] = cf;
					}
				}
			}
			Waitframe();
		}
	}
}

																														  //Item Bundle Script

// This script is a pickup script that will give some items.
// This was mostly made to bundle the Bow and Arrows into one item,
// but it could have other uses.
// Bundle this with an item that increases a counter to also increase counters.
// 		D0-D7: Items to give.
//		D0: If D0 is negative, it will display an item pickup message containing the positive version of the number entered...
item script itemBundle{
	void run(int item1, int item2, int item3, int item4, int item5, int item6, int item7, int item8)
	{
		if(item1 > 0)
			Link->Item[item1] = true;
		if(item2 > 0)
			Link->Item[item2] = true;
		if(item3 > 0)
			Link->Item[item3] = true;
		if(item4 > 0)
			Link->Item[item4] = true;
		if(item5 > 0)
			Link->Item[item5] = true;
		if(item6 > 0)
			Link->Item[item6] = true;
		if(item7 > 0)
			Link->Item[item7] = true;
		if(item8 > 0)
			Link->Item[item8] = true;

		// Display Item pickup message?
		if(item1 < 0)
		{
			Screen->Message(item1 * -1);
		}
	}//!End void run()
}//!End item script itemBundle

																												//TieredItemPickup

item script TieredItemPickup{
	 void run(int lowTier, int secondTier, int thirdTier, int fourthTier, int fifthTier, int sixthTier, int highTier, int m){
			 if (Link->Item[sixthTier]){
				   Link->Item[highTier] = true;
				   Screen->Message(m);
			 }
			 else if (Link->Item[fifthTier]){
				   Link->Item[sixthTier] = true;
				   Screen->Message(m);
			  }
			 else if (Link->Item[fourthTier]){
				   Link->Item[fifthTier] = true;
				   Screen->Message(m);
			  }
			 else if (Link->Item[thirdTier]){
				   Link->Item[fourthTier] = true;
				   Screen->Message(m);
			  }
			 else if (Link->Item[secondTier]){
				   Link->Item[thirdTier] = true;
				   Screen->Message(m);
			  }
			 else if (Link->Item[lowTier]){
				   Link->Item[secondTier] = true;
				   Screen->Message(m);
			  }
			 else {
				   Link->Item[lowTier]= true;
				   Screen->Message(m);
			  }
		}
}