ZScript: Flying Fortress Alpha 0.3

int _____GRAM[1024];
const int LOOPS_Q = 1023;


int Fortresses[27]; //tmer, dir, speed, x, y, dmap, screen

const int FORTRESS_TIMER = 0;
const int FORTRESS_DIR = 1;
const int FORTRESS_SPEED = 2;
const int FORTRESS_X = 3;
const int FORTRESS_Y = 4;
const int FORTRESS_DMAP_ID = 5;
const int FORTRESS_SCREEN_ID = 6;
const int FORTRESS_TILE = 7;
const int FORTRESS_CSET = 8;
const int FORTRES_SCALE = 9; //Scale it, blast you!
const int FORTRESS_SHADOW_TILE = 10;
const int FORTRESS_SHADOW_ = 11; //More scaling effects, for perspective.

const int FORTRESS_DMAP_OFFSET = 12;  // Multiply this * Fortress ID, then add element.

const int NUM_FORTRESSES = 9;

const int FORTRESS_MOVE_TMER_MIN = 120;
const int FORTRESS_MOVE_TMER_MAX = 400;

const int FORTRESS_MOVE_DIST_MIN = 6;
const int FORTRESS_MOVE_DIST_MAX = 14;

//! Let's hardcode some DMAPS! Z

const int FF_DMAP_SCREEN_VALID = 0;
const int FF_DMAP_SCREEN_INVALID = -1;
const int FF_DMAP_SCREEN_BOUNDARY = 1; //1 or higher is a screen boundary.

//A virtual DMap. 0s are empty space, 1s are screens, 2s are boundaries.
//Should each edge and corner be a unique value

/*
-1 empty space
0 has sceens on each side

1 cannot turn up
2 cannot turn down
4 cannot turn right
8 cannot turn up


*/
const int NOT_VALID_SCREEN = -1;
const int CANNOT_TURN_UP = 1;
const int CANNOT_TURN_DOWN = 2;
const int CANNOT_TURN_RIGHT = 4;
const int CANNOT_TURN_LEFT = 8;

//A virtual map with the edges marked.
int virtual_map_1[]={
    9,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,
    8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
    8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
    8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
    8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
    8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
    8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
    10,2,2,2,2,2,2,2,2,2,2,2,2,2,2,6 }

//Determines a random, legal directions, based on values on a vritual map.
int FindLegalTurn(int virtual_map, int screen){
    if ( virtual_map[screen] == 1 ) {  //cannot turn up
        return ( Choose(DIR_RIGHT, DIR_LEFT, DIR_DOWN) );
    }
    if ( virtual_map[screen] == 2 ) { //cannot tuen down
        return ( Choose(DIR_RIGHT, DIR_LEFT, DIR_UP) );
    }
    if ( virtual_map[screen] == 4 ) { //cannot turn right
        return ( Choose(DIR_LEFT, DIR_DOWN, DIR_UP) );
    }
    if ( virtual_map[screen] == 5 ) { //cannot turn up or right
        return ( Choose(DIR_DOWN, DIR_LEFT) );
    }
    if ( virtual_map[screen] == 6 ) { //cannot turn down or right
        return ( Choose(DIR_UP, DIR_LEFT) );
    }
    if ( virtual_map[screen] == 8 ) { //cannot turn left
        return ( Choose(DIR_RIGHT, DIR_DOWN, DIR_UP) );
    }
    if ( virtual_map[screen] == 9 ) { //cannot turn left or up
        return ( Choose(DIR_RIGHT, DIR_DOWN) );
    }
    if ( virtual_map[screen] == 10 ) { //cannot turn left or down
        return ( Choose(DIR_RIGHT, DIR_UP) );
    }
    return Rand(0,3); //Otherwise, return a random direction.
}


const int FORTRESS_1_TILE = 100;
const int FORTRESS_SHADOW_TILE = 101;
const int FORTRESS_SHADOW_Y_OFFSET = 70;
const int FORTRESS_DRAW_LAYER = 6;
const int FORTRESS_SHADOW_DRAW_LAYER = 6;
const int FORTRESS_TILEWIDTH = 1;
const int FORTRESS_TILEHEIGHT = 1;

const int FORTRESS_SHADOW_CSET = 0;

void DrawFortress(int fortress_id, int tile){
    //if it is on this dmap
    if ( FortressDMap(fortress_id) == Game->GetCurDMap() ) {
        //...and this screen
        if ( FortressScreen(fortress_id) == Game->GetCurScreen() ) {
            //Draw it
            Screen->DrawTile(FORTRESS_DRAW_LAYER,FortressTile(fortress_id), FortressX(fortress_id), FortressY(fortress_id),
            FORTRESS_TILEWIDTH, FORTRESS_TILEHEIGHT, FortressCSet(fortress_id), FortressScale(fortress_id), FortressScale(fortress_id),
            0, 0, 0, 0, true, OP_OPAQUE);
            //Draw its shadow.

            Screen->DrawTile(FORTRESS_DRAW_LAYER,FortressShadowTile(fortress_id), FortressX(fortress_id), FortressY(fortress_id)+FORTRESS_SHADOW_Y_OFFSET,
            FORTRESS_TILEWIDTH, FORTRESS_TILEHEIGHT, FORTRESS_SHADOW_CSET, FortresShadowScale(fortress_id), FortresShadowScale(fortress_id),
            0, 0, 0, 0, true, OP_OPAQUE);
        }
    }
}

bool FortressCanMove(int fortress_id, int virtual_map, int screen){
    int dir = FortressDir(fortress_id);
    int scr = FortressScreen(fortress_id);
    //If the fortress is on a screen edge, check if that is a dmap edge, too.
    if ( FortressAtScreenEdge(fortress_id, FortressDir(fortress_id) ){
        if ( dir == DIR_LEFT ) {
            if ( virtual_map[scr] >= 8 ) return false;
            return true;
        }
        if ( dir == DIR_RIGHT ){
            if ( virtual_map[scr] >= 4 &&  virtual_map[scr] <= 6 ) return false;
            return true;
        }
        if ( dir == DIR_DOWN ) {
            if ( virtual_map[scr] == 10 || virtual_map[scr] == 2 || virtual_map[scr] == 6 ) return false;
            return true;
        }
        if ( dir == DIR_UP ) {
            if ( virtual_map[scr] == 9 || virtual_map[scr] == 1 || virtual_map[scr] == 5 ) return false;
            return true;
        }
    }
    return true; //The fortress is not on a screen edge, so it can move freely.
}

//Moves the fortress based on its speed, and changes its direction if it cannot move.
void MoveFortress(int fortress_id, int virtual_map){
    if ( FortressCanMove(fortress_id) ) {
        if ( FortressDir(fortress_id) == DIR_LEFT ) {
            //Move left
            FortressX(fortress_id, FortressX(fortress_id)-FortressSpeed(fortress_id));
        }
        if ( FortressDir(fortress_id) == DIR_RIGHT ) {
            //Move right
            FortressX(fortress_id, FortressX(fortress_id)+FortressSpeed(fortress_id));
        }
        if ( FortressDir(fortress_id) == DIR_UP ) {
            //Move up
            FortressY(fortress_id, FortressY(fortress_id)-FortressSpeed(fortress_id));
        }
        if ( FortressDir(fortress_id) == DIR_DOWN ) {
            //Move down
            FortressY(fortress_id, FortressY(fortress_id)+FortressSpeed(fortress_id));
        }
    }
    else {
        //Change the direction.
        FortressDir( fortress_id, FindLegalTurn(fortress_id, virtual_map) );
    }
}

int virtual_map_0[]={
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }



//Main fortress function. Call once per fortress, pointing to its id and the virtual map that it uses.
void DoFortress(int fortress_id, int virtual_map){
    DoFortressTmers(fortress_id);
    MoveFortress(fortress_id, virtual_map);
    DrawFortress(fortress_id);
}


global script test_fortress{
    void run(){
        while(true){
            for ( _____GRAM[LOOPS_Q] = 0; _____GRAM[LOOPS_Q]  < 9; _____GRAM[LOOPS_Q]++ ) {
                DoFortress(q);
            }
            Waitdraw();
            Waitframe();
        }
    }
}

void DoFortressTmers(int fortress_id){
    if FortressTimer(fortress_id) <= 0 ) {
        TurnFortress(fortress_id);
    }
    else {
        FortressTime(fortress_id, FortressTIme(fortress_id)-1); //Reduce the timer.
    }
}


const int FORTRESS_WIDTH = 8;  //Sprite dimensions.
const int FORTRESS_HEIGHT = 8;
const int FORTRESS_Z_LOCATION = 100; //must match this Z to enter.

bool FortressAtScreenEdge(int fortress_id, int dir){
    if ( dir == DIR_LEFT && FottressX(fortress_id) <= 0+FORTRESS_WIDTH ) return true;
    if ( dir == DIR_RIGHT && FortressX(fortress_id) >= 256 ) return true;
    if ( dir == DIR_UP && FortressY(fortress_id)+FORTRESS_HEIGHT < 0 ) return true;
    if ( dir == DIR_DOWN && FortrwessY(fortress_id) >= 176 ) return true;
    return false;
}
//Turns the fortress if its timer expires.
bool TurnFortress(int fortress_id) { {
    //Choose a direction other than the present diretion.
    int dir;
    do { //Pick a random direction that differs from this direction.
        dir = Rand(0,7);
    } while ( dir != FortressDir(fortress_id);
    FortressDir(fortress_id, dir); //Change the direction.
    //Reset the turn timer to a randomised value. .
    FortressTimer(fortress_id, FortressTime(FORTRESS_TIME_MIN, FORTRESS_TIME_MAX, FORTRESS_TIME_FRACTIONAL_MIN, FORTRESS_TIME_FRACTIONAL_MAX) );
}

const int FORTRESS_TIME_MIN = 0; //minutes
const int FORTRESS_TIME_MAX = 3; //minutes
const int FORTRESS_TIME_FRACTIONAL_MIN = 10; //seconds
const int FORTRESS_TIME_FRACTIONAL_MAX = 59; //seconds

//Accessors for Fortresses[]
int FortressX(int fort_id){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_X]; }
int FortressY(int fort_id){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_Y]; }
int FortressDir(int fort_id){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_DIR]; }
int FortressSpeed(int fort_id){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_SPEED]; }
int FortressDMap(int fort_id){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_DMAP_ID]; }
int FortressScreen(int fort_id){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_SCREEN_ID]; }
int FortressTimer(int fort_id){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_TIMER]; }
void FortressX(int fort_id, int v){ Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_X] = VBound(v,0,255); }
void FortressY(int fort_id, int v){ Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_Y] = VBound(v,0,175); }
void FortressDir(int fort_id, int v){ Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_DIR] = VBound(v,0,7); }
void FortressSpeed(int fort_id, int v){ Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_SPEED] = Abs(v); }
void FortressDMap(int fort_id, int v){ Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_DMAP_ID] = v; }
void FortressScreen(int fort_id, int v){ Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_SCREEN_ID] = VBound(v,0,255); }
void FortressTimer(int fort_id, int v){ Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_TIMER] = Abs(v); }
void FortressY(int fort_id, int v){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_Y] = VBound(v,0,175); }
int FortressY(int fort_id){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_Y]; }
int FortressTile(int fortress_id){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_TILE]; }
void FortressTile(int fortress_id, int tile(){ Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_TILE] = tile; }
int FortressCSet(int fortress_id){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_CSET]; }
void FortressCSet(int fortress_id, int v){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_CSET] = v; }
int FortresScale(int fortress_id){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_SCALE]; }
void FortressScale(int fortress_id, int scale) { Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_SCALE] = scale; }
int FortressShadowTile(int fortress_id){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_SHADOW_TILE]; }
void FortressShadowTile(int fortress_id, int tile) { Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_SHADOW_TILE] = tile; }
int FortresShadowScale(int fortress_id){ return Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_SHADOW_SCALE]; }
void FortressShadowScale(int fortress_id, int scale) { Fortresses[(FORTRESS_DMAP_OFFSET*fort_id)+FORTRESS_SHADOW_SCALE] = scale; }

//Set the turn timer.
int FortressTime(int time_min, time_max, int frac_time, int frac_max){
    int t = Rand(time_min,time_max); int tt = (Rand(frac_time, frac_max) / 60);
    Return (t+tt)*60;
}

//! For world-wrapping, in a future version

int virtual_map[114]; //nine dmaps screen, x, y, left_bound, rightbound, topbound, bottombound* dmaps];
const int DMAP1 = 0;
const int DMAP_COLS = 12;
//start ( dmap, start screen, screen_left, screen_right, screen_up, screen_down, dma_left, dmap_right, dmap_down, dmap_up, x, y ) * dmap count
int virtualmap_dmap-connections[numdmaps];

//Call in init script to set up all the boundaries, dest screens, and so forth.
void SetMapBound(int ptr, int type, int screen, bool wrapdmap, int wrapto){
    //Set the screen that is the left most, and the screen on the right of the dmap to wrap into.
    //If we are wrapping to another dmap, we need to know it.
    if ( type == BOUND_LEFT ) {

        //We need to automatically set up wraps to dmaps using GetWrapDMap()

        ptr[FLF_MAP_BOUND_LEFT = screen; //the screen at which we start the wrap
        ptr[FLF_MAP_BOUND_LEFT_WRAPTO_SCREEN] = wrapto; //the screen at which we end the map
        if ( wrapdmap ) ptr[FLF_MAP_BOUND_LEFT_WRAPTO_DMAP] = GetWrapDMap(Game->GetCurDMap(DIR_LEFT); //the dmap on which we end the wrap.
        ptr[FLF_X] = 255; //We wrapped left from x=0, so we wrap to x = 255.
    }
    if ( type == BOUND_RIGHT ) {
        ptr[FLF_MAP_BOUND_RIGHT = screen; //the screen at which we start the wrap
        ptr[FLF_MAP_BOUND_RIGHT_WRAPTO_SCREEN] = wrapto; //the screen at which we end the map
        if ( wrapdmap ) ptr[FLF_MAP_BOUND_RIGHT_WRAPTO_DMAP] = GetWrapDMap(Game->GetCurDMap(DIR_RIGHT);  //the dmap on which we end the wrap.
        ptr[FLF_X] = 0; //We wrapped left from x=255, so we wrap to x = 0.
    }
    if ( type == BOUND_UP ) {
        ptr[FLF_MAP_BOUND_UP = screen; //the screen at which we start the wrap
        ptr[FLF_MAP_BOUND_UP_WRAPTO_SCREEN] = wrapto; //the screen at which we end the map
        if ( wrapdmap != -1 ) ptr[FLF_MAP_BOUND_UP_WRAPTO_DMAP] = GetWrapDMap(Game->GetCurDMap(DIR_UP); //the dmap on which we end the wrap.
        ptr[FLF_Y] = 175; //We wrapped left from y=0, so we wrap to Y = 175.
    }
    if ( type == BOUND_DOWN ) {
        ptr[FLF_MAP_BOUND_DOWN = screen; //the screen at which we start the wrap
        ptr[FLF_MAP_BOUND_DOWN_WRAPTO_SCREEN] = wrapto; //the screen at which we end the map
        if ( wrapdmap != -1 ) ptr[FLF_MAP_BOUND_DOWN_WRAPTO_DMAP] = GetWrapDMap(Game->GetCurDMap(DIR_DOWN);  //the dmap on which we end the wrap.
        ptr[FLF_Y] = 0; //We wrapped left from y=175, so we wrap to Y = 0.
    }
}

/*
int WrapDMap(int dmap){
    int dmap = Game->GetCurDMap();

    //checck ths table to see if we are on the edge of a dmap and wrappinf to another one,
    //if so, return its value
    //otherwise, return the current dmap.

    int dmap1[128]={
        0,0,0,0,0,0
}
*/
const int DMAP_COLS = 4; //Actual columns
const int DMAP_ROWS = 4; //Actual rows
int GetWrapDMap(int source, int dir){
    int virtual_dmaps[ (4_dirs +1 )* NumDMaps] {


        //Layout of the world by DMap IDs.

        0,  0,  0,  0,
        0,  0,  0,  0,
        0,  0,  0,  0,
        0,  0,  0,  0,

        //Left position from each

        3,  0,  1,  2,
        7,  4,  5,  6,
        11, 8,  9,  10,
        15, 12, 13, 14,

        //Right position from each

        1,  2,  3,  0,
        5,  6,  7,  4,
        9,  10, 11, 8,
        13, 14, 15, 12,

        //Down position from each

        4,  5,  6,  7,
        8,  9,  10, 11,
        12, 13, 14, 15,
        0,  1,  2,  3,

        //Up position from each

        12, 13, 14, 15,
        0,  1,  2,  3,
        8,  9,  10, 11,
        7,  8,  9,  10,
    }

    if ( dir == DIR_LEFT ) return [virtual_dmaps[pos+((DMAP_COLS*DMAP_ROWS)*1)];
    if ( dir == DIR_RIGHT ) return [virtual_dmaps[pos+((DMAP_COLS*DMAP_ROWS)*2)];
    if ( dir == DIR_DOWN ) return [virtual_dmaps[pos+((DMAP_COLS*DMAP_ROWS)*3)];
    if ( dir == DIR_UP ) return [virtual_dmaps[pos+((DMAP_COLS*DMAP_ROWS)*4)];
    return -1;//Error
}




//If our DMap is square, this part is easier.
int virtual_maps[]={    0,  0x1F,    0,     0x1F,
            0,  0x1F,    0,     0x1F,
            0,  0x1F,    0,     0x1F,
            0,  0x1F,    0,     0x1F,
            0,  0x1F,    0,     0x1F,
            0,  0x1F,    0,     0x1F,
            0,  0x1F,    0,     0x1F,
            0,  0x1F,    0,     0x1F,
            0,  0x1F,    0,     0x1F,

}; //Topleft, Topright, BottomLeft, BottomRight Screen IDs




//! Deprecated --------------------------------------------------------------------------------------------------------

bool TurnFortress(int fortress_id) {
    if ( ( FortressAtScreenEdge(fortres_id), FortressDir(fortress_id) ) || FortressTimer(fortress_id) <= 0 ) {
        //Choose a direction other than the present diretion.
        int dir;
        do { //Pick a random direction that differs from this direction.
            dir = Rand(0,7);
        } while ( dir != FortressDir(fortress_id);
        FortressDir(fortress_id, dir); //Change the direction.
    }
}

int MoveForetressSpeed()


//Edge of Boundary Screen
bool FortressAtDMapEdge(int virtual_map){



}

void SetFortressTimers(int ptr){
    nt sz = SzeOfArray(ptr);
    for ( int q = 0; q < sz; q += NUM_FORTRESSES )  ptr[q] = Rand(FORTRESS_MOVE_TMER_MIN,FORTRESS_MOVE_TMER_MAX);
}
void DoFortressTmers(int ptr){
    int sz = SizeOfArray(ptr);
    for ( int q = 0; q < sz; q += NUM_FORTRESSES ) {
        if ( ptr[q] <= 0 ) { MoveFortress(q); ptr[q] = Rand(FORTRESS_MOVE_TMER_MIN,FORTRESS_MOVE_TMER_MAX); }
        else ptr[q]--;
    }
}

int MoveFortressDir(int ptr) {
    int dirs[4] = {UP, DOWN, LEFT, RIGHT};
    int dir = dirs[Rand(0,4)]; //What about angles?
    //
}


//I forgot what this was supposed to do, ans I may as well start fresh after I resolve DMap boundaries.
void MoveFortress(int ptr){
    int distx = Rand(FORTRESS_MOVE_DIST_MIN, FORTRESS_MOVE_DIST_MAX);
    int disty = Rand(FORTRESS_MOVE_DIST_MIN, FORTRESS_MOVE_DIST_MAX);
    bool neg = RandB();
    if ( neg )
    //Avoid jiter somehow?
}

void MoveFortress(int id)}

const int FLF_MAP_

//! THis function is Not finished
//Boundary Screen?
bool FortressAtDMapBoundary(int fortress_id, int virtual_map, int offset){

    //Map out the screens of this DMap.
    int map[4];
    for ( int q = 0; q < 3; q++ ) {
        map[q] = virtual_map[(offset*4)+q];
    }

    int edges[4];

    if ( FortressScreen(fortress_id) % map[0] == 0 ) edges[0] = 1; //on left side of dmap. //Will this work of the DMap has an offset???

    //Decide which screens are dmap boundaries.

    //If the fortress is on one of these screens, return true.
}