Zelda 3 Follower v0.6

/////////////////////////////
/// Zelda 3 Follower      ///
/// v0.6                  ///
/// 10th April, 2019      ///
/// By: ZoriaRPG          ///
/// Made for: JudasRising ///
/////////////////////////////
// v0.1 : Initial
// v0.2 : Changed hardcoded > 3 frame cap to use FOLLOWER_MAX_FRAME in drawing loops.
// v0.3 : Fix scrolling positions and positions onContinue
// v0.4 : The follower's tile is now set by the combo of the ffc 'GetZelda'. (It's combo tile, -4.)
//      : Added the ability for the follower to play a message, and give an item to Link, when Link
//      : delivers them to their destination.
//  : Added the ability to show a message when you collect the npc.
// v0.5 : The follower CSet is now set by the ffc when you collect him.
// v0.6 : Renamed scripts and functions, and moved global functions into local functions of ffc script Follower.


//Settings
const int FOLLOWER_ZELDA_MIDI_DURATION  = 300;
const int FOLLOWER_ZELDA_MIDI       = 1;
const int FOLLOWER_MAX_FRAME        = 3; //4-frame walking animation
//Binary flags for Screen->D
const int FOLLOWER_SHOWED_MESSAGE   = 10b;
const int FOLLOWER_GAVE_ITEM        = 1b;

//Array and array indices.
int TheFollower[128] = {-1, -1};

const int FOLLOWER_MIDI_TIMER   = 0;
const int FOLLOWER_RESCUED  = 1;
const int FOLLOWER_ACTIVE   = 2;
const int FOLLOWER_UPDATE   = 3;
const int FOLLOWER_FRAME    = 4;
const int FOLLOWER_SUBFRAME     = 5;

const int FOLLOWER_ORIG_MIDI    = 6;
const int FOLLOWER_BASE_TILE    = 7;
const int FOLLOWER_CSET     = 8;

const int FOLLOWER_X        = 10;
const int FOLLOWER_X1       = 11;
const int FOLLOWER_X2       = 12;
const int FOLLOWER_X3       = 13;
const int FOLLOWER_X4       = 14;
const int FOLLOWER_X5       = 15;
const int FOLLOWER_X6       = 16;
const int FOLLOWER_X7       = 17;
const int FOLLOWER_X8       = 19;
const int FOLLOWER_X9       = 20;
const int FOLLOWER_X10      = 21;
const int FOLLOWER_X11      = 22;
const int FOLLOWER_X12      = 23;
const int FOLLOWER_X13      = 23;
const int FOLLOWER_X14      = 24;
const int FOLLOWER_X15      = 26;
const int FOLLOWER_X16      = 27;
const int FOLLOWER_X17      = 28;
const int FOLLOWER_X18      = 29;
const int FOLLOWER_X19      = 30;
const int FOLLOWER_X20      = 31;

const int FOLLOWER_Y        = 40;
const int FOLLOWER_Y1       = 41;
const int FOLLOWER_Y2       = 42;
const int FOLLOWER_Y3       = 43;
const int FOLLOWER_Y4       = 44;
const int FOLLOWER_Y5       = 45;
const int FOLLOWER_Y6       = 46;
const int FOLLOWER_Y7       = 47;
const int FOLLOWER_Y8       = 48;
const int FOLLOWER_Y9       = 49;
const int FOLLOWER_Y10      = 50;
const int FOLLOWER_Y11      = 51;
const int FOLLOWER_Y12      = 52;
const int FOLLOWER_Y13      = 53;
const int FOLLOWER_Y14      = 54;
const int FOLLOWER_Y15      = 55;
const int FOLLOWER_Y16      = 56;
const int FOLLOWER_Y17      = 57;
const int FOLLOWER_Y18      = 58;
const int FOLLOWER_Y19      = 59;
const int FOLLOWER_Y20      = 60;

const int FOLLOWER_DIR      = 70;
const int FOLLOWER_DIR1     = 71;
const int FOLLOWER_DIR2     = 72;
const int FOLLOWER_DIR3     = 73;
const int FOLLOWER_DIR4     = 74;
const int FOLLOWER_DIR5     = 75;
const int FOLLOWER_DIR6     = 76;
const int FOLLOWER_DIR7     = 77;
const int FOLLOWER_DIR8     = 78;
const int FOLLOWER_DIR9     = 79;
const int FOLLOWER_DIR10    = 80;
const int FOLLOWER_DIR11    = 81;
const int FOLLOWER_DIR12    = 82;
const int FOLLOWER_DIR13    = 83;
const int FOLLOWER_DIR14    = 84;
const int FOLLOWER_DIR15    = 85;
const int FOLLOWER_DIR16    = 86;
const int FOLLOWER_DIR17    = 87;
const int FOLLOWER_DIR18    = 88;
const int FOLLOWER_DIR19    = 89;
const int FOLLOWER_DIR20    = 90;

// When Link collides with this ffc, it triggers the follower.
//
// When you use this, add a second ffc on the screen with the combo of the follower, and then
// set the Link property of the ffc running the script to the ffc ID of the second ffc.
//
// The second, linked ffc is used to draw the follower until you collect them, and it also sets
// both the tiles to draw, and the CSet to use when drawing the follower.
//
// You can Link this to itself, but then Link will need to walk onto the follower image to 'collect' them.
ffc script Follower
{
    void run(int sfx, int msg)
    {
        ffc f = Screen->LoadFFC(this->Link);
        while(1)
        {
            if ( Collision(this) && TheFollower[FOLLOWER_RESCUED] < 0)
            {
                //f->Data = 0;
                TheFollower[FOLLOWER_RESCUED] = 2;
                Game->PlaySound(sfx);
                TheFollower[FOLLOWER_BASE_TILE] = Game->ComboTile(f->Data)-4;
                TheFollower[FOLLOWER_CSET] = f->CSet;
                if ( msg ) Screen->Message(msg);

                //break;//Quit();
            }
            if ( TheFollower[FOLLOWER_ACTIVE] > 15 )
            {
                f->Data = 0;
            }
            Waitframe();
        }
    }
    void wait(int num, int x, int y, int til)
    {
        for (; num >= 0; --num)
        {
            Screen->FastTile(2, x, y, til, TheFollower[FOLLOWER_CSET], 128 );
            Waitframe();
        }
    }
    //Returns true if the player is holding, or pressed a directional key or button.
    bool pressedDPad()
    {
        if ( Link->InputUp ) return true;
        if ( Link->InputDown ) return true;
        if ( Link->InputLeft ) return true;
        if ( Link->InputRight ) return true;
        if ( Link->PressUp ) return true;
        if ( Link->PressDown ) return true;
        if ( Link->PressLeft ) return true;
        if ( Link->PressRight ) return true;
        if ( Link->InputAxisUp ) return true;
        if ( Link->InputAxisDown ) return true;
        if ( Link->InputAxisLeft ) return true;
        if ( Link->InputAxisRight ) return true;
        if ( Link->PressAxisUp ) return true;
        if ( Link->PressAxisDown ) return true;
        if ( Link->PressAxisLeft ) return true;
        if ( Link->PressAxisRight ) return true;
        return false;
    }
    //Zelda follows in Link's path with an 8 frame delay before updating
    void draw()
    {
        if ( !TheFollower[FOLLOWER_ACTIVE] ) return;
        if ( pressedDPad() )
        {
            ++TheFollower[FOLLOWER_ACTIVE];
            if ( TheFollower[FOLLOWER_ACTIVE] > 100000 ) TheFollower[FOLLOWER_ACTIVE] = 8; //Don't roll over

        }



        if ( Link->Action == LA_GOTHURTLAND ) return; //Don't update if Link was hurt and pushed back.

        if ( pressedDPad() )
        {
            ++TheFollower[FOLLOWER_SUBFRAME];
            if ( TheFollower[FOLLOWER_SUBFRAME]&1 )
            {
                ++TheFollower[FOLLOWER_FRAME];
                if ( TheFollower[FOLLOWER_FRAME] > FOLLOWER_MAX_FRAME ) TheFollower[FOLLOWER_FRAME] = 0;
            }

            TheFollower[FOLLOWER_X] = Link->X;
            TheFollower[FOLLOWER_Y] = Link->Y;
            TheFollower[FOLLOWER_DIR] = Link->Dir;
            for ( int q = FOLLOWER_X12; q >= FOLLOWER_X; --q )
            {
                TheFollower[q] = TheFollower[q-1];
            }
            for ( int q = FOLLOWER_Y12; q >= FOLLOWER_Y; --q )
            {
                TheFollower[q] = TheFollower[q-1];
            }
            for ( int q = FOLLOWER_DIR12; q >= FOLLOWER_DIR; --q )
            {
                TheFollower[q] = TheFollower[q-1];
            }

        }
        if ( TheFollower[FOLLOWER_ACTIVE] < 16 ) return; //Wait 8 frames to begin.
        //Draw tiles
        int the_tile;

        the_tile = TheFollower[FOLLOWER_BASE_TILE] + (TheFollower[FOLLOWER_DIR12]*4) + TheFollower[FOLLOWER_FRAME];
        //Based on X, Y, Dir and Frame
        Screen->FastTile(2, TheFollower[FOLLOWER_X12], TheFollower[FOLLOWER_Y12],
                    the_tile, TheFollower[FOLLOWER_CSET], 128 );


        //...then Update the frame

    }


    //Called to initialise the follower.
    void rescue(int follower_midi, int dur)
    {
        if ( TheFollower[FOLLOWER_RESCUED] < 2 ) return;

        --TheFollower[FOLLOWER_RESCUED];
        if ( !dur ) dur = FOLLOWER_ZELDA_MIDI_DURATION;
        if ( !follower_midi ) follower_midi = FOLLOWER_ZELDA_MIDI;
        TheFollower[FOLLOWER_ACTIVE] = 1;
        if ( TheFollower[FOLLOWER_MIDI_TIMER] == -1 )
        {

            TheFollower[FOLLOWER_ORIG_MIDI] = Game->DMapMIDI[Game->GetCurDMap()];
            TheFollower[FOLLOWER_MIDI_TIMER] = dur;
            Game->PlayMIDI(follower_midi);
        }
        else
        {
            --TheFollower[FOLLOWER_MIDI_TIMER];
            if ( TheFollower[FOLLOWER_MIDI_TIMER] < 1 )
            {
                Game->PlayMIDI(TheFollower[FOLLOWER_ORIG_MIDI]);
                TheFollower[FOLLOWER_MIDI_TIMER] = 0;
            }
        }

    }

    // Clears the follower positions if Link dies, if the playe presses F6, and so forth.
    // Called in active, continue, and exit scripts.
    // Use in Link's Init script if using 2.55.
    void clear()
    {
        for ( int q = FOLLOWER_X; q <= FOLLOWER_X20; ++q )
        {
            TheFollower[q] = Link->X;
        }
        for ( int q = FOLLOWER_Y; q <= FOLLOWER_Y20; ++q )
        {
            TheFollower[q] = Link->Y;
        }
        for ( int q = FOLLOWER_DIR; q <= FOLLOWER_DIR20; ++q )
        {
            TheFollower[q] = Link->Dir;
        }
    }

    // Called in the active script during scrolling to prevent the follower from drawing at the wrong position.
    void scroll()
    {
        if ( Link->Action != LA_SCROLLING ) return;
        for ( int q = FOLLOWER_X; q <= FOLLOWER_X20; ++q )
        {
            TheFollower[q] = Link->X;
        }
        for ( int q = FOLLOWER_Y; q <= FOLLOWER_Y20; ++q )
        {
            TheFollower[q] = Link->Y;
        }
        for ( int q = FOLLOWER_DIR; q <= FOLLOWER_DIR20; ++q )
        {
            TheFollower[q] = Link->Dir;
        }
    }
}


const int FOLLOWER_REGISTER = 1;

ffc script LeaveFollower
{
    void run(int msg, int itm)
    {
        this->Data = CMB_INVISIBLE;
        //bool matched = false;
        //if ( TheFollower[FOLLOWER_ACTIVE] ) this->Data = CMB_INVISIBLE;
        if ( TheFollower[FOLLOWER_ACTIVE] ) TheFollower[FOLLOWER_ACTIVE] = 0;
        //else ;
        int the_tile; bool playedmsg = false;

        while ( 1 ) //TheFollower[FOLLOWER_X12] != this->X && TheFollower[FOLLOWER_Y12] != this->Y )
        {
            if ( TheFollower[FOLLOWER_X12] < this->X ) { ++TheFollower[FOLLOWER_X12]; TheFollower[FOLLOWER_DIR12] = DIR_RIGHT; }
            if ( TheFollower[FOLLOWER_X12] > this->X ) { --TheFollower[FOLLOWER_X12]; TheFollower[FOLLOWER_DIR12] = DIR_LEFT; }

            if ( TheFollower[FOLLOWER_Y12] < this->Y ) { ++TheFollower[FOLLOWER_Y12]; TheFollower[FOLLOWER_DIR12] = DIR_DOWN; }
            if ( TheFollower[FOLLOWER_Y12] > this->Y ) { --TheFollower[FOLLOWER_Y12]; TheFollower[FOLLOWER_DIR12] = DIR_UP; }
            ++TheFollower[FOLLOWER_FRAME];
            if ( TheFollower[FOLLOWER_FRAME] > FOLLOWER_MAX_FRAME ) TheFollower[FOLLOWER_FRAME] = 0;
            the_tile = TheFollower[FOLLOWER_BASE_TILE] + (TheFollower[FOLLOWER_DIR12]*4) + TheFollower[FOLLOWER_FRAME];
            if ( TheFollower[FOLLOWER_X12] == this->X && TheFollower[FOLLOWER_Y12] == this->Y ) { TheFollower[FOLLOWER_DIR12] = DIR_DOWN; TheFollower[FOLLOWER_FRAME] = 0; }
            Follower.wait(2,TheFollower[FOLLOWER_X12],TheFollower[FOLLOWER_Y12],the_tile);
            if ( TheFollower[FOLLOWER_X12] == this->X )
            {
                if ( TheFollower[FOLLOWER_Y12] == this->Y )
                {
                    if ( msg )
                    {
                        if ( !(Screen->D[FOLLOWER_REGISTER]&FOLLOWER_SHOWED_MESSAGE) )
                        {


                            Screen->D[FOLLOWER_REGISTER] |= FOLLOWER_SHOWED_MESSAGE;
                            Screen->Message(msg);
                        }
                    }
                    if ( itm )
                    {
                        if ( !(Screen->D[FOLLOWER_REGISTER]&FOLLOWER_GAVE_ITEM) )
                        {


                            Screen->D[FOLLOWER_REGISTER] |= FOLLOWER_GAVE_ITEM;
                            item giveit = Screen->CreateItem(itm);
                            giveit->X = Link->X;
                            giveit->Y = Link->Y;
                            giveit->Pickup = IP_HOLDUP;

                        }
                    }
                }
            }
        }

    }

}

//Example global script.
global script FollowerActive
{
    void run()
    {
        Follower.clear();
        while(1)
        {
            Follower.rescue(FOLLOWER_ZELDA_MIDI, FOLLOWER_ZELDA_MIDI_DURATION);
            Follower.draw();
            Follower.scroll();
            Waitdraw();
            Waitframe();
        }
    }
}





global script FollowerResume
{
    void run()
    {
        //int ss[]="Running onContinue";
        //TraceS(ss);
        Follower.clear();
    }
}