Future ZScript needs to allow NON-CONSTANT globals to be set

[ZoriaRPG]

I was so furious when I posted that I didn't even think about it. Too late now though.

No chance of recompiling it the way that you had it before?

Here's a little bonus... How to make a global complex object, of sorts.

RPG.zh/RPG_Player_Sprites.zlib

///Player Sprites v1.1 for RPG.zh 0.97.6

//This .zlib creates a weapon sprite, using lweapon Player, that is always above Link, and acts as a stNad-in for his sprite. 
//The reason for using a sprite, is that it is animated.

import "std.zh"
int PlayerSprites[3074] = {88}; //Why 3074? It's a merged array. See constants at 136 to 143.

const int OLD_LINK_TILE = 1;
const int ZQ_LAST_TILE = 65519;
const int ZQ_BLANK_TILE = 65518;

const int TILES_BACKUP = 62560;
const int TILES_BLANK = 65000;

const int BASE_TILE = 35620;
const int TILE_LENGTH = 260; //EACH TILE PAGE CONTAINS 259 TILES.

const int ZQ_SPRITE_BLANK = 255;

//Conditional Constants
const int COND_DALEK = 4;
const int SPRITE_DALEK_SAUCER = 0;

//bool IsInvisible;
//bool TilesCopiedInvis;
//bool TilesCopiedVis = true;

//int LastLinkX; //These are no longer needed.
//int LastLinkY;
//bool LinkMoved;
//int PlayerFrameDelay; //These need to be in an array, to match the size of PlayerSprites (512)
//int PlayerFrame;

//int IsInvisible[512]; //Array to hold if Link should be invisible, per DMAP.
//int SpriteAnimFrameDelay[512];
//int SpriteAnimFrames[512];



//Sets the starting frame.
void SetPlayerSpriteFrames(int dmap, int frames){
	PlayerSprites[dmap+EW_PLAYER_SPRITE_ANIM] = frames;
}

int GetPlayerSpriteFrames(int dmap){
	return PlayerSprites[dmap+EW_PLAYER_SPRITE_ANIM];
}

void IncreasePSF(int dmap){
	PlayerSprites[dmap+EW_PLAYER_SPRITE_ANIM]++;
}

void SetPlayerSpriteAnimDelay(int dmap, int delay){
	PlayerSprites[dmap+EW_PLAYER_SPRITE_ANIM_DELAY] = delay;
}

int GetPlayerSpriteAnimDelay(int dmap){
	return PlayerSprites[dmap+EW_PLAYER_SPRITE_ANIM_DELAY];
}

void SetPlayerSpriteAnimDelayDuration(int dmap, int dur){
	PlayerSprites[dmap+EW_PLAYER_TIME_OF_DELAY] = dur;
}

int GetPlayerSpriteAnimDelayDuration(int dmap){
	return PlayerSprites[dmap+EW_PLAYER_TIME_OF_DELAY];
}

//Sets the number of frames.
void SetPlayerSpriteNumberOfFrames(int dmap, int frames){
	PlayerSprites[dmap+EW_PLAYER_NUMBER_OF_FRAMES] = frames;
}

int GetPlayerSpriteNumberOfFrames(int dmap){
	return PlayerSprites[dmap+EW_PLAYER_NUMBER_OF_FRAMES];
}
	
	

void IncreasePSAD(int dmap){
	PlayerSprites[dmap+EW_PLAYER_SPRITE_ANIM_DELAY]++;
}

void SetIsInvisible(int dmap, bool setting){
	int set;
	if ( setting ) set = 1;
	PlayerSprites[dmap+EW_PLAYER_INVISIBLE] = set;
}

void SetIsInvisible(int dmap, int value){
	PlayerSprites[dmap+EW_PLAYER_INVISIBLE] = value;
}

bool GetIsInvisible(int dmap){
	bool set = PlayerSprites[dmap+EW_PLAYER_INVISIBLE];
	if ( set ) return true;
	else return false;
}

//Call in ~Init to set up sprites for each DMAP.
void SetPlayerSpriteOptions(int dmap, int sprite, bool invis, int frames, int delay, int numFrames, int framesDur){
	SetPlayerSprite(dmap,sprite);
	SetIsInvisible(dmap,invis);
	SetPlayerSpriteFrames(dmap,frames);
	SetPlayerSpriteAnimDelay(dmap,delay);
	SetPlayerSpriteNumberOfFrames(dmap,numFrames);
	SetPlayerSpriteAnimDelayDuration(dmap,framesDur);
}

global script Init{
	void run(){
		Link->Invisible = true;
		SetPlayerSpriteOptions(0,88,true,0,0,6,10);
	}
}

void PlayerTilesCopied(int setting){
	PlayerSprites[SPRITES_COPIED] = setting;
}

int PlayerTilesCopied(){
	return PlayerSprites[SPRITES_COPIED];
}

void PlayerTilesRestored(int setting){
	PlayerSprites[SPRITES_RESTORED] = setting;
}

int PlayerTilesRestored(){
	return PlayerSprites[SPRITES_RESTORED];
}
	
//condense these all into one array, and then use these constants:

const int EW_PLAYER_SPRITE = 0;
const int EW_PLAYER_INVISIBLE = 512;
const int EW_PLAYER_SPRITE_ANIM = 1024;
const int EW_PLAYER_SPRITE_ANIM_DELAY = 1536;
const int EW_PLAYER_NUMBER_OF_FRAMES = 2048;
const int EW_PLAYER_TIME_OF_DELAY = 2560;
const int SPRITES_COPIED = 3072;
const int SPRITES_RESTORED = 3073;

const int INVIS_NOT_COPIED = 1;
const int INVIS_COPIED = 2;
const int VIS_NOT_COPIED = 3;
const int VIS_COPIED = 0;



global script active{
	void run(){
		SetPlayerSpriteOptions(0,88,true,0,0,6,10);
		Link->Invisible = true;
		int SpriteLink[512]={88}; //Populate with the sprite for Link, based on the DMAP.
		int LinkTile;
		int curDMAP;
		while ( true ) {
			//Trace(Link->Tile);
			if ( Game->GetCurDMap() != curDMAP ) curDMAP = Game->GetCurDMap();
			if ( Link->PressEx1 ) {
				if ( !GetIsInvisible( Game->GetCurDMap() ) ) {
					SetIsInvisible(Game->GetCurDMap(),true);
				}
				else SetIsInvisible(Game->GetCurDMap(),false);
			}
			
			//if ( Link->X == LastLinkX && Link->Y == LastLinkY ) LinkMoved = false;
			//if ( Link->X != LastLinkX || Link->Y != LastLinkY ) {
			//	LastLinkY = Link->Y;
			//	LastLinkX = Link->X;
			//	LinkMoved = true;
			//}
			//PlayerFrameDelay++;
			PlayerSprites[curDMAP+EW_PLAYER_SPRITE_ANIM_DELAY]++;
			
			if ( PlayerSprites[curDMAP+EW_PLAYER_SPRITE_ANIM_DELAY] >= PlayerSprites[curDMAP+EW_PLAYER_TIME_OF_DELAY] ) {
				PlayerSprites[curDMAP+EW_PLAYER_SPRITE_ANIM]++;
				PlayerSprites[curDMAP+EW_PLAYER_SPRITE_ANIM_DELAY] = 0;
				
			}
			if ( PlayerSprites[curDMAP+EW_PLAYER_SPRITE_ANIM] >= PlayerSprites[curDMAP+EW_PLAYER_NUMBER_OF_FRAMES] ) PlayerSprites[curDMAP+EW_PLAYER_SPRITE_ANIM] = 0;
			
			
			if ( GetIsInvisible( Game->GetCurDMap() ) && !PlayerTilesCopied() ) {
				for ( int q = 0; q < TILE_LENGTH; q++ ) {
					CopyTile(BASE_TILE+q, TILES_BACKUP+q);
					CopyTile(TILES_BLANK+q, BASE_TILE+q);
				}
				PlayerTilesCopied(1);
				PlayerTilesRestored(0);
			}
			
			if ( !GetIsInvisible(Game->GetCurDMap() ) && !PlayerTilesRestored() ) {
				for ( int q = 0; q < TILE_LENGTH; q++ ) {
					CopyTile(TILES_BACKUP+q, BASE_TILE+q); 
				}
				PlayerTilesCopied(0);
				PlayerTilesRestored(1);
			}
			
			
			LinkTile = Link->Tile;
			//if ( IsInvisible && !TilesCopiedInvis && TilesCopiedVis ) {
			//	TilesCopiedVis = false;
			//	TilesCopiedInvis = true;
			//	for ( int q = 0; q < TILE_LENGTH; q++ ) {
			//		CopyTile(BASE_TILE+q, TILES_BACKUP+q);
			//		CopyTile(TILES_BLANK+q, BASE_TILE+q);
			//	}
			//	
			//}
			//if ( !IsInvisible && TilesCopiedInvis && !TilesCopiedVis ) {
			//	TilesCopiedInvis = false;
			//	TilesCopiedVis = true;
			//	
			//	int S_Rest[]="Restoring Tiles";
			//	TraceS(S_Rest);
			//	for ( int q = 0; q < TILE_LENGTH; q++ ) {
			//		CopyTile(TILES_BACKUP+q, BASE_TILE+q); 
			//		//CopyTile(TILES_BLANK+q, TILES_BACKUP+q);
			//	}
				
				
			//}
			
			//if ( Link->Tile != ZQ_BLANK_TILE ) {
			//	CopyTile(LinkTile,ZQ_LAST_TILE);
			//	CopyTile(ZQ_BLANK_TILE,LinkTile);
			//}
			eweapon PlayerSprite = Screen->CreateEWeapon(EW_SCRIPT10);
			PlayerSprite->X = Link->X;
			PlayerSprite->Y = Link->Y;
			PlayerSprite->CollDetection = false;
			PlayerSprite->Dir = Link->Dir;
			PlayerSprite->Flip = Link->Flip;
			PlayerSprite->Frame = PlayerSprites[curDMAP+EW_PLAYER_SPRITE_ANIM];
			
			int player_sprite;
			if ( PlayerSprites[curDMAP] == 0 ) player_sprite = ZQ_SPRITE_BLANK;
			else player_sprite = PlayerSprites[curDMAP];
			PlayerSprite->UseSprite(player_sprite);
			Waitdraw();
			//if ( LinkMoved) 
			PlayerSprite->DeadState = WDS_DEAD;
			//PlayerSprite(PlayerSprite,SpriteLink);
			Waitframe();
		}
	}
	void PlayerSprite(int SpriteLink, int sprite){
		SpriteLink[0] = sprite;
	}
	
}

void SetPlayerSprite(int dmap, int sprite){
	PlayerSprites[dmap] = sprite;
}

item script PlayerSprites{ 
	void run(int SpriteLink){
		//PlayerSprites[0]=Rand(1,50);
		//if ( !IsInvisible ) {
		//	IsInvisible = true;
		//}
		//else IsInvisible = false;
		
	}
}


//Link->Invisible = true; //Set Link to be invisible.



//This cannot be imported. The functions must be made local (in scope) to the global active script, for the pointers to work. 
void PlayerSprite(int condition){ //Condition should be tied to one index of GameDynamics, and called as:
	// PlayerSprite(Val(PLAYER_SPRITE));
	if ( Player->Collision ) {
		Player->Collision = false; //Turn collision off go
	}
	if ( Player->X != Link->X ){ //Mirror Link's position, and direction.
		Player->X = Link->X;
	}
	if ( Player->X != Link->Y ){
		Player->X = Link->Y;
	}
	if ( Player->X != Link->Z ){
		Player->X = Link->Z;
	}
	if ( Player->X != Link->Dir ){
		Player->X = Link->Dir;
	}
	if ( Player->X != Link->Flip ){
		Player->X = Link->Flip;
	}
	if ( ! UseSprite( Val(PLAYER_SPRITE) ) ){
		Player->UseSprite(Val(PLAYER_SPRITE));
	}
}	

void ChangePlayerSprite(int sprite){
	Val(PLAYER_SPRITE,sprite);
}

void SetSpriteCondition(int condition){
	if ( COND_DALEK ) {
		ChangePlayerSprite(SPRITE_DALEK_SAUCER);
	}
	//else if 
}

const int BACKUP_LINK_TILES = 32000; //First tile for backup tiles.

void WriteLinkTile(int firstTile){
	//rEADS PRESENT TILE USED BY lINK
//Uses CopyTile to make backup of original tile to specified location	
	//Then  copies specied tile to Tile used by Link
	//effectivel changing Link->Tile
}

int LinkTileOnExit[256]; //Store Link tiles on exit in array.

You can do this with weapons, and ffcs. It'd also work with npcs, but I'm not certain if there's a point to that.