a30502355 Global Temppatch for Alpha 17

namespace tempPatches
{
    const int BASE_LINK_Z = 1;
}

// ghost.zh
// Version 2.8.0

const int SCRIPT_BARRIERS = 7;
const int BARRIER_A_RAISED           = 4656;
const int BARRIER_B_RAISED           = 4657;
const int BARRIER_A_LOWERED          = 4658;
const int BARRIER_B_LOWERED          = 4659;
const int BARRIER_A_ANIMRAISE        = 4660;
const int BARRIER_B_ANIMRAISE        = 4661;
const int BARRIER_A_ANIMLOWER        = 4662;
const int BARRIER_B_ANIMLOWER        = 4663;
const int BARRIER_A_WALKABLE         = 4664;
const int BARRIER_B_WALKABLE         = 4665;
const int BARRIER_A_SWITCH           = 4666;
const int BARRIER_B_SWITCH           = 4667;
const int BARRIER_SWITCH_DUMMY = 177;
const int BARRIER_SWITCH_DUMMY_HP = 32767;

const int BIG_LINK                  = 0;

// Pegasus Boots Constants
const int CF_DASH                   = 102;
const int INV_COMBO_ID          = 4669;
const int DashSFXLength             = 9;
const int SFX_DASH                  = 79;
const int SFX_HITWALL               = 3;
const int SFX_PEGASUSBREAK          = 74;
const int T_DUST                    = 660;
const int DustAFrames               = 4;
const int DustASpeed                = 4;
const int DustCSet                  = 8;
const int I_ROCSFEATHER_INCREASER   = 124;
const int DASH_SWORD_DMG            = 8;
const int DASH_SWORD_MULT           = 2;
const int SPRITE_SWORD1         = 0;
const int SPRITE_SWORD2         = 1;
const int SPRITE_SWORD3         = 2;
const int SPRITE_SWORD4         = 3;
const int NPC_ITEMSET               = 178;
const int SPRITE_BUSH_CUT           = 54;
const int SPRITE_FLOWER_CUT         = 54;
const int SPRITE_GRASS_CUT          = 54;
const int CanDrown                  = 1;


bool barriers[511]; // false = blue barriers raised, true = red barriers raised
// to draw while Scrolling
int scrollDir;
int scrollCounter;
int drawX;
int drawY;

//Pegasus Boots Global variables
int PegasusDash = -1;
bool PegasusCollision;
int DashCounter;
int StoreInput;
int StoreHP;

int dashSwordTile = 0; // for drawing dashsword while scrolling, script sets these.
int dashSwordCSet = 0;

                              //!!!!!!!!!!!!! this array size needs to be set, the number inside the []
int Dust_Array[2];            // Array size should be max number of dust animations active at one time
                              // Formula is ( (DustAFrames*DustASpeed) / 4 )

//END Pegasus Boots global variables


// Function that makes preparations for barriers on each screen and starts an FFC script
void Barriers_NewScreen()
{

    // Search for a barrier-related combo
    for (int i = 0; i <= 175; ++i)
    {
        int cd = Screen->ComboD[i];
        if (cd == BARRIER_A_RAISED || cd == BARRIER_A_LOWERED || cd == BARRIER_A_SWITCH ||
            cd == BARRIER_B_RAISED || cd == BARRIER_B_LOWERED || cd == BARRIER_B_SWITCH)
        {
            // A barrier-related combo was found

            // Make initial changes to combos
            if (barriers[Game->GetCurDMap()])
            {
                for (int j = i; j <= 175; ++j)
                {
                    int cd = Screen->ComboD[j];
                    if (cd == BARRIER_A_RAISED) Screen->ComboD[j] = BARRIER_A_LOWERED;
                    else if (cd == BARRIER_B_LOWERED) Screen->ComboD[j] = BARRIER_B_RAISED;
                    else if (cd == BARRIER_A_SWITCH) Screen->ComboD[j] = BARRIER_B_SWITCH;}}
                else {
                    for (int j = i; j <= 175; j++) {
                        int cd = Screen->ComboD[j];
                        if (cd == BARRIER_B_RAISED) Screen->ComboD[j] = BARRIER_B_LOWERED;
                        else if (cd == BARRIER_A_LOWERED) Screen->ComboD[j] = BARRIER_A_RAISED;
                        else if (cd == BARRIER_B_SWITCH) Screen->ComboD[j] = BARRIER_A_SWITCH;}}

                    // So run FFCscript to control barriers
                    int args[] = {0,0,0,0,0,0,0,0};
                    RunFFCScript(SCRIPT_BARRIERS, args);
                    break;}
            }}

            // This lets you toggle barriers on any dmap
            bool ToggleBarriers(int dmap) {
                if (dmap == Game->GetCurDMap()) ToggleBarriers();
                else barriers[dmap] = !barriers[dmap];
                return barriers[dmap];}

            // This toggles barriers on the current dmap
            bool ToggleBarriers() {

                int curdmap = Game->GetCurDMap();
                if (!barriers[curdmap]) {
                    barriers[curdmap] = true;
                    for (int i = 0; i <= 175; i++) {
                        int cd = Screen->ComboD[i];
                        if (cd == BARRIER_A_RAISED || cd == BARRIER_A_WALKABLE || cd == BARRIER_A_ANIMRAISE) {
                            Screen->ComboD[i] = BARRIER_A_ANIMLOWER;}
                        else if (cd == BARRIER_B_LOWERED || cd == BARRIER_B_ANIMLOWER) {
                            Screen->ComboD[i] = BARRIER_B_ANIMRAISE;}
                        else if (cd == BARRIER_A_SWITCH) {Screen->ComboD[i] = BARRIER_B_SWITCH;}}}
                        else {
                            barriers[curdmap] = false;
                            for (int i = 0; i <= 175; i++) {
                                int cd = Screen->ComboD[i];
                                if (cd == BARRIER_B_RAISED || cd == BARRIER_B_WALKABLE || cd == BARRIER_B_ANIMRAISE) {
                                    Screen->ComboD[i] = BARRIER_B_ANIMLOWER;}
                                else if (cd == BARRIER_A_LOWERED || cd == BARRIER_A_ANIMLOWER) {
                                    Screen->ComboD[i] = BARRIER_A_ANIMRAISE;}
                                else if (cd == BARRIER_B_SWITCH) {Screen->ComboD[i] = BARRIER_A_SWITCH;}}}

                                return barriers[curdmap];
                            }

                            ffc script Barriers {
                                void run() {

                                    // Initialize storage for bswitch hit dummies
                                    int bswitch_count;
                                    npc bswitch[8];

                                    for (int i = 0; i <= 175; i++) {
                                        if (Screen->ComboD[i] == BARRIER_A_SWITCH || Screen->ComboD[i] == BARRIER_B_SWITCH) {
                                            npc bs = CreateNPCAt(BARRIER_SWITCH_DUMMY, ComboX(i), ComboY(i));
                                            bs->HitWidth = 8; // Smaller hit box to avoid annoying collisions with Link
                                            bs->HitHeight = 8;
                                            bs->HP = BARRIER_SWITCH_DUMMY_HP;
                                            bswitch[bswitch_count++] = bs;}}

                                        // Change raised barriers to walkable ones if Link enters screen on a raised barrier
                                        int lcombo = LinkOnComboD();
                                        bool onbarrier = (lcombo == BARRIER_A_RAISED || lcombo == BARRIER_B_RAISED);
                                        if (onbarrier) for (int i = 0; i < 176; i++) {
                                            if (Screen->ComboD[i] == BARRIER_A_RAISED) {Screen->ComboD[i] = BARRIER_A_WALKABLE;}
                                            else if (Screen->ComboD[i] == BARRIER_B_RAISED) {Screen->ComboD[i] = BARRIER_B_WALKABLE;}}

                                            while (true) {

                                                // Detect hits on bswitches, and change combos accordingly
                                                for (int j = 0; j < bswitch_count; j++) {
                                                    if (bswitch[j]->HP < BARRIER_SWITCH_DUMMY_HP) {
                                                        bswitch[j]->HP = BARRIER_SWITCH_DUMMY_HP;
                                                        ToggleBarriers();
                                                        break;}} //break so that only one bswitch hit may register per frame


                                                    // Make barriers walkable if Link is on raised barriers, or unwalkable if not
                                                    lcombo = LinkOnComboD();
                                                    if (!onbarrier && (lcombo == BARRIER_A_RAISED || lcombo == BARRIER_B_RAISED)) {
                                                        onbarrier = true;
                                                        for (int i = 0; i <= 175; i++) {
                                                            if (Screen->ComboD[i] == BARRIER_A_RAISED) {Screen->ComboD[i] = BARRIER_A_WALKABLE;}
                                                            else if (Screen->ComboD[i] == BARRIER_B_RAISED) {Screen->ComboD[i] = BARRIER_B_WALKABLE;}}}
                                                            else if (onbarrier && !(lcombo == BARRIER_A_WALKABLE || lcombo == BARRIER_B_WALKABLE)) {
                                                                onbarrier = false;
                                                                for (int i = 0; i <= 175; i++) {
                                                                    if (Screen->ComboD[i] == BARRIER_A_WALKABLE) {Screen->ComboD[i] = BARRIER_A_RAISED;}
                                                                    else if (Screen->ComboD[i] == BARRIER_B_WALKABLE) {Screen->ComboD[i] = BARRIER_B_RAISED;}}}

                                                                    Waitframe();}


                                                            }}



                                                            item script PegasusBoots{
                                                                void run(){

                                                                    if(ComboFI(Link->X+8,Link->Y + Cond(BIG_LINK==0, 12, 8),CF_DASH)) Quit();  // can't dash on non-solid dash combos

                                                                    if(CanDrown == 0 && IsWater(TouchedComboLoc()) ) Quit();  // stop beside non-drownable water

                                                                    if(Link->Action == LA_SWIMMING || Link->Action == LA_DROWNING) Quit();  // can't use dash when in water

                                                                    if(IsJumping()) Quit();  // can't initiate dash while jumping

                                                                    // Link won't dash if facing up or down in sideview
                                                                    if(IsSideview()){
                                                                        if(Link->Dir == DIR_UP || Link->Dir == DIR_DOWN) Quit();
                                                                    }

                                                                    PegasusDash = Link->Dir;

                                                                    if(Link->InputB && !Link->InputA) StoreInput = 2;
                                                                    else if(Link->InputA && !Link->InputB) StoreInput = 1;

                                                                }
                                                            }


                                                            // Stops dashing, no collision.  Easy for other scripts to call.
                                                            void StopDash(){
                                                                PegasusDash = -1;
                                                                DashCounter = 0;
                                                            }


                                                            // takes care of all the PegasusBoots functions
                                                            // call it in your global while loop, above the waitdraw and waitframe.
                                                            void PegasusBoots(){
                                                                lweapon mysword;

                                                                int loc = ComboAt(Link->X+8,Link->Y + Cond(BIG_LINK==0, 12, 8));

                                                                // this fixes the bug that makes Link dive immediately after dashing into water with flippers
                                                                if(DashCounter < 0){
                                                                    DashCounter++;

                                                                    if(Link->Action == LA_SWIMMING){
                                                                        Link->InputA = false;
                                                                    }else if(Link->Action == LA_DIVING){
                                                                    Link->Action == LA_SWIMMING;
                                                                    Link->InputA = false;
                                                                }else{
                                                                DashCounter = 0;
                                                            }
                                                        }

                                                        // fixs a bug with drownable water and diagonal movement off
                                                        if(CanDrown == 1 && IsWater(loc)
                                                        && Link->Action != LA_SWIMMING && Link->Action != LA_DROWNING && Link->Action != LA_DIVING){

                                                            if(Link->Dir == DIR_UP) Link->InputUp = true;
                                                            else if(Link->Dir == DIR_DOWN) Link->InputDown = true;
                                                            else if(Link->Dir == DIR_LEFT) Link->InputLeft = true;
                                                            else if(Link->Dir == DIR_RIGHT) Link->InputRight = true;
                                                        }


                                                        if(PegasusDash >= 0){
                                                            if(!PegasusCollision){
                                                                if( (Link->Action != LA_SCROLLING && ((StoreInput == 1 && !Link->InputA) || (StoreInput == 2 && !Link->InputB)))
                                                                || StoreHP > Link->HP || Link->Action == LA_RAFTING
                                                                || Link->Action == LA_DROWNING || Link->Action == LA_SWIMMING || Link->Action == LA_DIVING
                                                                || (CanDrown == 0 && IsWater(TouchedComboLoc())) || (CanDrown == 1 && IsWater(loc)) ){

                                                                    StopDash();

                                                                    if(Link->Action == LA_SWIMMING) DashCounter = -20;
                                                                }

                                                                if(!UsingItem(I_ROCSFEATHER_INCREASER))
                                                                NoAction();

                                                                if(Link->Item[I_ROCSFEATHER] && !Link->Item[I_ROCSFEATHER_INCREASER]){
                                                                    Link->Item[I_ROCSFEATHER_INCREASER]=true;
                                                                }

                                                                // Link runs on spot for 10 frames before dash happens
                                                                if(Link->Action != LA_SCROLLING && DashCounter > 10){
                                                                    if(PegasusDash == DIR_UP && DashCheck(Link->X+8,Link->Y+6,true) != 2){
                                                                        Link->Y--;
                                                                        drawY--;
                                                                        Link->InputUp = true;
                                                                    }
                                                                    else if(PegasusDash == DIR_DOWN && DashCheck(Link->X+8,Link->Y+17,true) != 2){
                                                                        Link->Y++;
                                                                        drawY++;
                                                                        Link->InputDown = true;
                                                                    }
                                                                    else if(PegasusDash == DIR_LEFT && DashCheck(Link->X,Link->Y+12,false) != 2){
                                                                        Link->X--;
                                                                        drawX--;
                                                                        Link->InputLeft = true;
                                                                    }
                                                                    else if(PegasusDash == DIR_RIGHT && DashCheck(Link->X+16,Link->Y+12,false) != 2){
                                                                        Link->X++;
                                                                        drawX++;
                                                                        Link->InputRight = true;
                                                                    }
                                                                    else{
                                                                        PegasusCollision = true;
                                                                        DashCounter = 0;
                                                                    }
                                                                }//end DashCounter if

                                                                // do stuff if not jumping
                                                                if( !IsJumping() ){

                                                                    // handles breaking of solid Pegasus combos
                                                                    if(ComboFI(loc,CF_DASH) && Screen->ComboS[loc] == 1111b){
                                                                        Screen->ComboD[loc]=INV_COMBO_ID;
                                                                        if(Screen->ComboF[loc] == CF_DASH) Screen->ComboF[loc] = 0;
                                                                        Game->PlaySound(SFX_PEGASUSBREAK);
                                                                    }

                                                                    DustDrawTile();  // use new dust draw code that works while scrolling
                                                                    // DustDrawLW(); // use old dust draw code that doesn't work while scrolling (quest rule "no screen scrolling" on)

                                                                    if(DashCounter%DashSFXLength == 0) Game->PlaySound(SFX_DASH);
                                                                }

                                                                // draws dashSword when scrolling
                                                                if(Link->Action == LA_SCROLLING && dashSwordTile > 0){

                                                                    if(PegasusDash == DIR_UP)
                                                                    Screen->DrawTile(0,drawX+InFrontX(DIR_UP,6),drawY+InFrontY(DIR_UP,6),
                                                                    dashSwordTile,1,1,dashSwordCSet,-1,-1,0,0,0,0,true,128);
                                                                    else if(PegasusDash == DIR_DOWN)
                                                                    Screen->DrawTile(0,drawX+InFrontX(DIR_DOWN,6),drawY+InFrontY(DIR_DOWN,6),
                                                                    dashSwordTile,1,1,dashSwordCSet,-1,-1,0,0,0,3,true,128);
                                                                    else if(PegasusDash == DIR_LEFT)
                                                                    Screen->DrawTile(0,drawX+InFrontX(DIR_LEFT,6),drawY+InFrontY(DIR_LEFT,6)+3,
                                                                    dashSwordTile,1,1,dashSwordCSet,-1,-1,0,0,0,1,true,128);
                                                                    else if(PegasusDash == DIR_RIGHT)
                                                                    Screen->DrawTile(0,drawX+InFrontX(DIR_RIGHT,6),drawY+InFrontY(DIR_RIGHT,6)+3,
                                                                    dashSwordTile,1,1,dashSwordCSet,-1,-1,0,0,0,0,true,128);
                                                                }

                                                                int swordEquip = LinkSwordEquip();

                                                                if(swordEquip > -1 && DashCounter>10){
                                                                    // draws dashSword when not scrolling

                                                                    mysword = LoadLWeaponOf(LW_SCRIPT3);
                                                                    if(!mysword->isValid()) mysword = Screen->CreateLWeapon(LW_SCRIPT3);

                                                                    if(swordEquip==I_SWORD4){
                                                                        mysword->UseSprite(SPRITE_SWORD4);
                                                                    }else if(swordEquip==I_SWORD3){
                                                                    mysword->UseSprite(SPRITE_SWORD3);
                                                                }else if(swordEquip==I_SWORD2){
                                                                mysword->UseSprite(SPRITE_SWORD2);
                                                            }else{
                                                            mysword->UseSprite(SPRITE_SWORD1);
                                                        }//end sprite if

                                                        if(DASH_SWORD_MULT > 0){
                                                            itemdata itm = Game->LoadItemData(swordEquip);
                                                            mysword->Damage = itm->Power * DASH_SWORD_MULT;
                                                        }
                                                        else mysword->Damage = DASH_SWORD_DMG;

                                                        mysword->X = Link->X+InFrontX(PegasusDash, 6);
                                                        mysword->Y = Link->Y+InFrontY(PegasusDash, 6);

                                                        mysword->Dir = PegasusDash;
                                                        if(mysword->Dir < 2){ //dir is up or down
                                                            if(mysword->Dir == DIR_DOWN) mysword->Flip = 3;
                                                        }
                                                        else{ //dir is left or right
                                                            mysword->OriginalTile += 1;
                                                            mysword->Tile = mysword->OriginalTile;
                                                            if(mysword->Dir == DIR_LEFT) mysword->Flip = 1;
                                                            mysword->Y += 3;
                                                        }//end dir if

                                                        // save our sword sprite for when scrolling
                                                        dashSwordTile = mysword->Tile;
                                                        dashSwordCSet = mysword->OriginalCSet;

                                                        // slash stuff while dashing with sword
                                                        DoDashSlash(ComboAt(TouchedX()+InFrontX(mysword->Dir,4),TouchedY()+InFrontY(mysword->Dir,4)));
                                                    }
                                                    else{ // we don't have dashSword

                                                        mysword = LoadLWeaponOf(LW_SCRIPT3);
                                                        Remove(mysword);

                                                        dashSwordTile = 0;
                                                        dashSwordCSet = 0;
                                                    }//end mysword if

                                                }//end !PegasusCollision if

                                                else{ //is PegasusCollision, DashCounter has been reset to 0.
                                                    NoAction();

                                                    // knockback code
                                                    if(PegasusDash == DIR_UP && DashCheck(Link->X+8,Link->Y+18,true) == 0) Link->Y++;
                                                    else if(PegasusDash == DIR_DOWN && DashCheck(Link->X+8,Link->Y+6,true) == 0) Link->Y--;
                                                    else if(PegasusDash == DIR_LEFT && DashCheck(Link->X+18,Link->Y+8,false) == 0) Link->X++;
                                                    else if(PegasusDash == DIR_RIGHT && DashCheck(Link->X-2,Link->Y+8,false) == 0) Link->X--;

                                                    if(DashCounter == 1){
                                                        Screen->ClearSprites(SL_LWPNS);
                                                        Game->PlaySound(SFX_HITWALL);
                                                        Screen->Quake = 10;
                                                    }
                                                    else if(DashCounter == 10){
                                                        StopDash();
                                                        PegasusCollision = false;
                                                    }

                                                    if(DashCounter < 5) Link->Z++;
                                                }// end PegasusCollision if/else

                                                DashCounter++;
                                            }// end PegasusDash if

                                            else{ // !PegasusDash
                                                mysword = LoadLWeaponOf(LW_SCRIPT3);
                                                Remove(mysword);

                                                dashSwordTile = 0;
                                                dashSwordCSet = 0;

                                                if(Link->Item[I_ROCSFEATHER_INCREASER]) Link->Item[I_ROCSFEATHER_INCREASER]=false;
                                            }//end PegasusDash if/else

                                            StoreHP = Link->HP;
                                        }//end function


                                        // next two functions draw dust when dashing.  first one allows drawing during scrolling. the second is the old code, and currently unused.
                                        void DustDrawTile(){
                                            if(PegasusDash < 0) return;

                                            int dX;
                                            int dY;

                                            if(DashCounter%4 == 0){
                                                for(int i = 0; i < SizeOfArray(Dust_Array); i++){
                                                    if(Dust_Array[i] == 0){
                                                        Dust_Array[i] = 1;
                                                        break;
                                                    }
                                                }
                                            }

                                            for(int i = 0; i < SizeOfArray(Dust_Array); i++){
                                                if(Dust_Array[i]==0) continue;

                                                if(PegasusDash == DIR_UP){
                                                    dX = drawX;
                                                    if(Dust_Array[i] < 4) dY = drawY+8;
                                                    else dY = drawY+8+3+(Dust_Array[i]-1);

                                                }else if(PegasusDash == DIR_DOWN){
                                                dX = drawX;

                                                if(Dust_Array[i] < 4) dY = drawY;
                                                else dY = drawY-3-(Dust_Array[i]-1);

                                            }else if(PegasusDash == DIR_LEFT){

                                            if(Dust_Array[i] < 4) dX = drawX;
                                            else dX = drawX+3+(Dust_Array[i]-1);

                                            dY = drawY+8;

                                        }else if(PegasusDash == DIR_RIGHT){

                                        if(Dust_Array[i] < 4) dX = drawX;
                                        else dX = drawX-3-(Dust_Array[i]-1);

                                        dY = drawY+8;
                                    }

                                    Screen->FastTile(1, dX, dY, T_DUST+ Floor(Dust_Array[i]/DustASpeed), DustCSet, 128);

                                    if(Dust_Array[i] == DustAFrames*DustASpeed) Dust_Array[i] = 0;
                                    else Dust_Array[i]++;
                                }
                            }

                            void DustDrawLW(){
                                if(PegasusDash < 0) return;

                                lweapon Dust;
                                if(DashCounter%4 == 0){
                                    for(int j=1;j<=Screen->NumLWeapons();j++){
                                        Dust = Screen->LoadLWeapon(j);
                                        if(Dust->ID != LW_SCRIPT10) continue;
                                        if(PegasusDash < 1) Dust->Y-=3;
                                        else if(PegasusDash < 2) Dust->Y+=3;
                                        else if(PegasusDash < 3) Dust->X-=3;
                                        else if(PegasusDash < 4) Dust->X+=3;
                                    }//end for loop

                                    Dust = Screen->CreateLWeapon(LW_SCRIPT10);
                                    Dust->OriginalTile = T_DUST;
                                    Dust->CSet = DustCSet;
                                    Dust->Y = Link->Y+8;
                                    Dust->X = Link->X;
                                    Dust->NumFrames = DustAFrames;
                                    Dust->ASpeed = DustASpeed;
                                    Dust->DeadState = DustAFrames*DustASpeed;
                                }//end dust if
                            }


                            // Check whether Link can dash onto a combo
                            int DashCheck(int x, int y, bool xy){
                                int xoffset; int yoffset;
                                bool Solid;

                                if(xy) xoffset = 4;
                                else yoffset = 3;

                                if(Screen->isSolid(x-xoffset,y-yoffset) || Screen->isSolid(x+xoffset,y+yoffset)) Solid = true;

                                if(Solid && CanDashSlash(x,y) ) Solid = false;

                                //Not solid and not a Dash combo return 0
                                if(!Solid && !ComboFI(x-xoffset,y-yoffset,CF_DASH) && !ComboFI(x+xoffset,y+yoffset,CF_DASH)) return 0;

                                //Is solid and is a Dash combo return 1
                                else if(Solid && (ComboFI(x-xoffset,y-yoffset,CF_DASH) || ComboFI(x+xoffset,y+yoffset,CF_DASH))) return 1;

                                //Is either solid without a Dash combo, or not solid with a Dash combo
                                else return 2;
                            }


                            //fixes a bug where you can't initiate a dash next to a slashable solid combo
                            bool CanDashSlash(int x, int y){
                                if(LinkSwordEquip() == -1) return false;

                                int loc;
                                loc = ComboAt(x, y);

                                // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                                // can add more combo types here by adding     || Screen->ComboT[loc] == CT_
                                // CT_ types you might consider CT_SLASH, CT_SLASHNEXT, CT_SLASHNEXTITEM if those are solid in your quest

                                if(Screen->ComboT[loc] == CT_BUSH || Screen->ComboT[loc] == CT_BUSHNEXT )
                                return true;

                                return false;
                            }

                            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                            // replaces the code in old Pegasus boots function for dash cutting through slashable combos.
                            // allows easier customization to suit your needs.

                            void DoDashSlash(int loc){
                                int ctype = Screen->ComboT[loc];
                                int sprite;
                                int itmset = IS_COMBOS; // item set 12 (tall grass by default)

                                bool playsound = false;

                                // add sprites to certain types
                                if(ctype == CT_BUSH || ctype == CT_BUSHNEXT) sprite = SPRITE_BUSH_CUT;
                                else if(ctype == CT_TALLGRASS || ctype == CT_TALLGRASSNEXT) sprite = SPRITE_GRASS_CUT;
                                else if(ctype == CT_FLOWERS) sprite = SPRITE_FLOWER_CUT;

                                // no sprite is typically associated with Slash type combos, but it could be added.

                                // itemset is changed here to the default for these types.  could add more item sets based on type
                                if(ctype == CT_SLASHITEM || ctype == CT_SLASHNEXTITEM) itmset = 10; // default for these combo types

                                //these types default to undercombo
                                if(ctype == CT_BUSH || ctype == CT_TALLGRASS || ctype == CT_FLOWERS || ctype == CT_SLASH || ctype == CT_SLASHITEM){
                                    Screen->ComboD[loc] = Screen->UnderCombo;
                                    playsound = true;
                                }

                                //these types default to next combo
                                if(ctype == CT_BUSHNEXT || ctype == CT_TALLGRASSNEXT || ctype == CT_FLOWERS || ctype == CT_SLASHNEXT || ctype == CT_SLASHNEXTITEM){
                                    Screen->ComboD[loc] += 1;
                                    playsound = true;
                                }

                                //no functionality added for Continuous type combos.

                                if(playsound){
                                    CreateGraphicAt(sprite,ComboX(loc),ComboY(loc));

                                    Game->PlaySound(SFX_GRASSCUT); // could have different sounds for different types too by modifyng above.
                                    ItemSetAt(itmset,loc);
                                }//end playsound if
                            }


                            //returns the item# of an equipped sword.  checks and returns A button first, then B button.  returns -1 if no sword equipped.
                            int LinkSwordEquip(){
                                itemdata itm = Game->LoadItemData( GetEquipmentA() );

                                if(itm->Family==IC_SWORD) return GetEquipmentA();

                                itm = Game->LoadItemData(GetEquipmentB());

                                if(itm->Family==IC_SWORD) return GetEquipmentB();

                                return -1;
                            }

                            // the combo that link is touching in the direction he's facing
                            int TouchedComboLoc(){
                                int loc;
                                loc = ComboAt( TouchedX(), TouchedY() );
                                return loc;
                            }

                            // the x coord that link is touching in the direction he's facing
                            int TouchedX(){
                                int x = 0;
                                if(Link->Dir == DIR_UP || Link->Dir == DIR_DOWN) x = Link->X+8;
                                else if(Link->Dir == DIR_LEFT)  x = Link->X-1;
                                else if(Link->Dir == DIR_RIGHT) x = Link->X+17;
                                return x;
                            }

                            // the y coord that link is touching in the direction he's facing
                            int TouchedY(){
                                int y = 0;
                                if(Link->Dir == DIR_UP)         y = Link->Y+7;
                                else if(Link->Dir == DIR_DOWN)  y = Link->Y+17;
                                else if(Link->Dir == DIR_LEFT || Link->Dir == DIR_RIGHT)  y = Link->Y+8;
                                return y;
                            }

                            // draws a sprite as a non-damaging eweapon
                            int CreateGraphicAt(int sprite, int x, int y){
                                eweapon e = Screen->CreateEWeapon(EW_SCRIPT1);
                                e->HitXOffset = 500;
                                e->UseSprite(sprite);
                                e->DeadState = Max(1,e->NumFrames*e->ASpeed);
                                e->X = x;
                                e->Y = y;
                                return e->DeadState;
                            }

                            //creates and kills an enemy of type NPC_ITEMSET to fake an itemdropset.
                            void ItemSetAt(int itemset,int loc){
                                npc e = Screen->CreateNPC(NPC_ITEMSET);
                                e->ItemSet = itemset;
                                if(e->isValid()){
                                    e->X = loc%16*16;
                                    e->Y = loc-loc%16;
                                }
                                e->HP = HP_SILENT;
                            }


                            // utility function returns true if Link is jumping, necessary because SideView gravity sucks
                            // might need tweaking depending on other SideView scripts you use.

                            bool IsJumping(){
                                if(IsSideview()){
                                    if(Link->Action == LA_SWIMMING || Link->Action == LA_DIVING || Link->Action == LA_DROWNING) return false;
                                    if(Link->Jump != 0) return true;
                                    if(!OnSidePlatform(Link->X,Link->Y)) return true;
                                }
                                else{
                                    if(Link->Z > tempPatches::BASE_LINK_Z) return true;
                                }

                                return false;
                            }


                            // Allows drawing tiles to correct position on Link when scrolling
                            // Sets drawX/drawY either to Link X/Y when not scrolling, or the visual position when scrolling.
                            // currently only used by Pegasus Boots (which is also setting drawX/drawY to Link's new x/y as he dashes)

                            void ScrollFix(){
                                //function by Saffith

                                if(Link->Action==LA_SCROLLING){
                                    if(scrollDir==-1)
                                    {
                                        if(Link->Y>160)
                                        {
                                            scrollDir=DIR_UP;
                                            scrollCounter=45;
                                        }
                                        else if(Link->Y<0)
                                        {
                                            scrollDir=DIR_DOWN;
                                            scrollCounter=45;
                                        }
                                        else if(Link->X>240)
                                        {
                                            scrollDir=DIR_LEFT;
                                            scrollCounter=65;
                                        }
                                        else
                                        {
                                            scrollDir=DIR_RIGHT;
                                            scrollCounter=65;
                                        }
                                    }

                                    if(scrollDir==DIR_UP && scrollCounter<45 && scrollCounter>4)
                                    drawY+=4;
                                    else if(scrollDir==DIR_DOWN && scrollCounter<45 && scrollCounter>4)
                                    drawY-=4;
                                    else if(scrollDir==DIR_LEFT && scrollCounter<65 && scrollCounter>4)
                                    drawX+=4;
                                    else if(scrollDir==DIR_RIGHT && scrollCounter<65 && scrollCounter>4)
                                    drawX-=4;

                                    scrollCounter--;
                                }
                                else
                                {
                                    drawX=Link->X;
                                    drawY=Link->Y;
                                    if(scrollDir!=-1)
                                    scrollDir=-1;
                                }
                            }

                            void LREx1Ex2ItemSwitch()
                            {
                                if (Link->PressL && Link->Action != LA_SCROLLING)
                                {
                                    Link->SelectBWeapon(DIR_LEFT);
                                }
                                if (Link->PressR && Link->Action != LA_SCROLLING)
                                {
                                    Link->SelectBWeapon(DIR_RIGHT);
                                }
                                if (Link->PressEx1 && Link->Action != LA_SCROLLING)
                                {
                                    Link->SelectAWeapon(DIR_LEFT);
                                }
                                if (Link->PressEx2 && Link->Action != LA_SCROLLING)
                                {
                                    Link->SelectAWeapon(DIR_RIGHT);
                                }
                            }



                            int LinkOnComboD() {
                                return Screen->ComboD[ComboAt(Link->X+8, Link->Y+13)];
                            }


                            item script GhostZHClockScript
                            {
                                void run(int duration)
                                {
                                    if(duration<=0)
                                    __ghzhData[__GHI_CLOCK_TIMER]=-1;
                                    else
                                    __ghzhData[__GHI_CLOCK_TIMER]=duration;
                                }
                            }



                            //Constants used by Ice Combos
                            const int CT_ICECOMBO = 142; //The combo type "Script1 by default"
                            const int ICE_ACCELERATION = 1;
                            const int ICE_DECELERATION = 1;
                            const int ICE_MAXSTEP     = 150;

                            //Declare global variables used by Ice Combos.
                            bool isScrolling;
                            bool onice;
                            float Ice_X;
                            float Ice_Y;
                            int Ice_XStep;
                            int Ice_YStep;
                            //End declaration

                            //Active Script


                            //Initializes global variables used for ice combos.
                            void Setup_IceCombos()
                            {
                                isScrolling = false;
                                onice = false;
                                Ice_X = 0;
                                Ice_Y = 0;
                                Ice_XStep = 0;
                                Ice_YStep = 0;
                            }

                            //Adds Ice Combo functionally to CT_ICECOMBO;
                            void Update_IceCombos(int oldscreen)
                            {
                                //Update Variables
                                if(Link->Action != LA_SCROLLING)
                                {
                                    if(isScrolling || oldscreen != Game->GetCurScreen() || (!onice && OnIce()))
                                    {
                                        Ice_X = Link->X;
                                        Ice_Y = Link->Y;
                                        if(isScrolling)
                                        isScrolling = false;
                                        else
                                        {
                                            Ice_XStep = 0;
                                            Ice_YStep = 0;
                                        }
                                    }
                                    onice = OnIce();
                                }
                                else
                                {
                                    isScrolling = true;
                                    return;
                                }

                                //Ice Physics
                                if(onice)
                                {
                                    //Y Adjustment
                                    if(Link_Walking() && (Link->InputUp || Link->InputDown))
                                    {
                                        if(Link->InputUp && !Link->InputDown)
                                        Ice_YStep -= ICE_ACCELERATION;
                                        else if(!Link->InputUp && Link->InputDown)
                                        Ice_YStep += ICE_ACCELERATION;
                                    }
                                    else if(Ice_YStep != 0)
                                    Ice_YStep = Cond(Abs(Ice_YStep) - ICE_DECELERATION > 0, Ice_YStep - Sign(Ice_YStep)*ICE_DECELERATION, 0);
                                    Ice_YStep = Clamp(Ice_YStep, -ICE_MAXSTEP, ICE_MAXSTEP);

                                    //X Adjustment
                                    if(Link_Walking() && (Link->InputLeft || Link->InputRight))
                                    {
                                        if(Link->InputLeft && !Link->InputRight)
                                        Ice_XStep -= ICE_ACCELERATION;
                                        else if(!Link->InputLeft && Link->InputRight)
                                        Ice_XStep += ICE_ACCELERATION;
                                    }
                                    else if(Ice_XStep != 0)
                                    Ice_XStep = Cond(Abs(Ice_XStep) - ICE_DECELERATION > 0, Ice_XStep -Sign(Ice_XStep)*ICE_DECELERATION, 0);
                                    Ice_XStep = Clamp(Ice_XStep, -ICE_MAXSTEP, ICE_MAXSTEP);

                                    //Reset the Ice Position to Link's Actual Position if he's hurt or hopping out of water.
                                    if(Link->Action == LA_GOTHURTLAND || Link->Action == LA_HOPPING)
                                    {
                                        Ice_X = Link->X;
                                        Ice_Y = Link->Y;
                                    }

                                    //Initialize variables for solidity checking.
                                    int newx = (Ice_X + Ice_XStep/100)<<0;
                                    int newy = (Ice_Y + Ice_YStep/100)<<0;

                                    //Vertical Edge
                                    if(newx < Ice_X<<0)
                                    {
                                        for(int y = Ice_Y+Cond(BIG_LINK, 0, 8); y < (Ice_Y<<0) + 16 && Ice_XStep != 0; y++)
                                        {
                                            if(Screen->isSolid(newx, y))
                                            Ice_XStep = 0;
                                        }
                                    }
                                    else if(newx > Ice_X<<0)
                                    {
                                        for(int y = Ice_Y+8; y < (Ice_Y<<0) + 16 && Ice_XStep != 0; y++)
                                        {
                                            if(Screen->isSolid(newx+15, y))
                                            Ice_XStep = 0;
                                        }
                                    }

                                    //Horizontal Edge
                                    if(newy < Ice_Y<<0)
                                    {
                                        for(int x = Ice_X; x < (Ice_X<<0) + 16 && Ice_YStep != 0; x++)
                                        {
                                            if(Screen->isSolid(x, newy+Cond(BIG_LINK, 0, 8)))
                                            {
                                                Ice_YStep = 0;
                                            }
                                        }
                                    }
                                    else if(newy > Ice_Y<<0)
                                    {
                                        for(int x = Ice_X; x < (Ice_X<<0) + 16 && Ice_YStep != 0; x++)
                                        {
                                            if(Screen->isSolid(x, newy+15))
                                            {
                                                Ice_YStep = 0;
                                            }
                                        }
                                    }

                                    Ice_X += Ice_XStep/100;
                                    Ice_Y += Ice_YStep/100;
                                    Link->X = Ice_X;
                                    Link->Y = Ice_Y;
                                }
                                else
                                {
                                    Ice_XStep = 0;
                                    Ice_YStep = 0;
                                }
                            }

                            //Function used to check if Link is over a ice combo.
                            bool OnIce()
                            {
                                if(Link->Z != tempPatches::BASE_LINK_Z)
                                return false;
                                else
                                {
                                    int comboLoc = ComboAt(Link->X + 8, Link->Y + 12);
                                    if(Screen->ComboT[comboLoc] == CT_ICECOMBO)
                                    return true;
                                    else if(Screen->LayerScreen(1) != -1 && GetLayerComboT(1, comboLoc) == CT_ICECOMBO)
                                    return true;
                                    else if(Screen->LayerScreen(2) != -1 && GetLayerComboT(2, comboLoc) == CT_ICECOMBO)
                                    return true;
                                    else
                                    return false;
                                }
                            }

                            //Returns true, if keyboard input is moving Link.
                            bool Link_Walking()
                            {
                                if(UsingItem(I_HAMMER)) return false;
                                else return (Link->Action == LA_WALKING || Link->Action == LA_CHARGING || Link->Action == LA_SPINNING);
                            }



                            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 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 = 89; //Sprite for Link falling in a hole
                            const int SPR_FALLLAVA = 90; //Sprite for Link falling in lava

                            const int SFX_FALLHOLE = 87; //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 = 6391; //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_NO_GRID_SNAP = 0; //Set to 1 to prevent Link's falling sprite from snapping to the combo grid.

                            bool MooshPit_OnPit(int LinkX, int LinkY, bool countFFCs){
                                if(Link->Action==LA_FROZEN)
                                return false;

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

                                bool sideview;
                                if(Screen->Flags[SF_ROOMTYPE]&100b)
                                sideview = true;
                                //wew lad
                                int width = MOOSHPIT_LINKHITBOXWIDTH;
                                int height = MOOSHPIT_LINKHITBOXHEIGHT;
                                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 = LinkX+7-width/2+width;
                                            Y = LinkY+7-height/2+height;
                                        }
                                        else{
                                            X = LinkX+7-width/2+width;
                                            Y = LinkY+11-height/2+height;
                                        }

                                        //If one corner of Link's hitbox isn't on a pit, return false
                                        if(Screen->ComboT[ComboAt(X, Y)]!=CT_HOLELAVA){
                                            return false;
                                        }
                                    }
                                }
                                return true;
                            }

                            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_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()
{
    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
            LogPrint("FallState == 0 %s \n", "checking if over a pit");
            LogPrint("Link is over a pit 2? %s \n", ( (MooshPit_OnPit(Link->X, Link->Y, true)) ? "true" : "false"));

            if(Link->Z<=tempPatches::BASE_LINK_Z&&MooshPit_OnPit(Link->X, Link->Y, true))
            {
                LogPrint("Link is over a pit 3? %s \n", ( (MooshPit_OnPit(Link->X, Link->Y, true)) ? "true" : "false"));

                //If Link steps on a pit
                int underLink;
                if(!sideview)
                underLink = ComboAt(Link->X+8, Link->Y+12);
                else
                underLink = ComboAt(Link->X+8, Link->Y+8);
                StopDash();

                lweapon fall;

                //Check if the combo is lava
                if(ComboFI(underLink, CF_LAVA))
                {
                    LogPrint("We should be %s \n", "playing a sound for 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
                {
                    LogPrint("We should be %s \n", "playing a sound for a pit");
                    //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);
                    }
                    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();
                StopDash();
            }
            else if(!MooshPit_OnPit(Link->X, Link->Y, false)&&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<=tempPatches::BASE_LINK_Z){
                        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]--;

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

            //Keep Link invisible just in case
            Link->Invisible = true;
            Link->CollDetection = false;
            NoAction();
            StopDash();
            if(MooshPit[MP_FALLTIMER]==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)){
                        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{
                        //Move Link to the start 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;

            MooshPit[MP_FALLSTATE] = 0;
            MooshPit[MP_FALLTIMER] = 0;
        }
    }
}

                            void MooshPit_ResetEntry(){
                                MooshPit[MP_ENTRYX] = Link->X;
                                MooshPit[MP_ENTRYY] = Link->Y;
                                MooshPit[MP_ENTRYDMAP] = Game->GetCurDMap();
                                MooshPit[MP_ENTRYSCREEN] = Game->GetCurDMapScreen();
                            }

                            //Set this to the item's ID.
                            const int POTION_ID = 146;

                            //Set this to the number of the sound effect to be played when the medicine takes effect.
                            const int POTION_SFX = 22;

                            //Set to 1 if you want a message to be displayed when the medicine takes effect.
                            //Set to 0 if you don't want a message to be displayed.
                            const int DISPLAY_MESSAGE = 1;

                            //Set this to the number of the message that will be displayed when the medicine takes effect.
                            const int MESSAGE = 1;



                            void onScreenChange()
{
    Game->SkipF6 = false;
}


global script slot2
{
    void run()
    {
        TraceS("@Running globl");
        // Initialize variables used to listen on screen changes
        int curscreen = -1; int lastScreen = Game->GetCurScreen();
        int lastMap = Game->GetCurMap();
        int oldscreen = Game->GetCurScreen();
        StartGhostZH();

        while (true)
        {
            ScrollFix();
            UpdateGhostZH1();
            PegasusBoots();
            PushAnimation();
            LogPrint("Link->Z is %d \n ", Link->Z);
            LogPrint("DashCounter is %d \n ", DashCounter);
            LogPrint("Link is over a pit? %s \n", ( (MooshPit_OnPit(Link->X, Link->Y, true)) ? "true" : "false"));
            MooshPit_Update();

            if (Link->HP <= 0 && Link->Item[POTION_ID])
            {
                Link->HP = Link->MaxHP;
                Link->Item[POTION_ID] = false;
                Game->PlaySound(POTION_SFX);

                if (DISPLAY_MESSAGE > 0) {
                    Screen->Message(MESSAGE);
                }
            }
            if(lastScreen != Game->GetCurScreen() || lastMap != Game->GetCurMap())
            {
                onScreenChange();
                lastScreen = Game->GetCurScreen();
                lastMap = Game->GetCurMap();
            }
            Waitdraw();
            UpdateGhostZH2();
            // Keep track of screen changes
            // Run a Barrier script on every screen change
            if (Game->GetCurScreen() != curscreen)
            {
                curscreen = Game->GetCurScreen();
                Barriers_NewScreen();
            }
            LREx1Ex2ItemSwitch();


            Update_IceCombos(oldscreen);
            oldscreen = Game->GetCurScreen();



            Waitframe();

        }

    }
}

global script Init
{
    void run()
    {
        MooshPit_Init();
    }
}