import "std.zh"

//v0.8.2




//Game Functions

int GetCurScreen(){
	return Game->GetCurScreen();
}

int GetCurDMap(){
	return Game->GetCurDMap();
}

int GetCurDMap(){
	return Game->GetCurDMap();
}

int GetCurMap(){ 
	return Game->GetCurMap();
}

int GetCurDMapScreen(){
	return Game->GetCurDMapScreen();
}

int GetCurLevel(){
	return Game->GetCurLevel();
}


int NumDeaths(){
	return Game->NumDeaths;
}

void NumDeaths(int num){
	Game->NumDeaths = num;
}

int Cheat(){
	return Game->Cheat;
}

void Cheat(int cheatLevel){
	Game->Cheat = cheatLevel;
}

int Time(){
	return Game->Time;
}

void Time(int t){
	Game->Time = t;
}

bool TimeValid(){
	return Game->TimeValid;
}

void TimeValid(bool t){
	Game->TimeValid = t;
}

bool HasPlayed(){
	return Game->HasPlayed;
}

void HasPlayed(bool a){
	Game->HasPlayed = a;
}

bool Standalone(){
	return Game->Standalone;
}

int ContinueDMap(){
	return Game->ContinueDMap;
}

void ContinueDMap(int dmap){
	Game->ContinueDMap = dmap;
}

int ContinueScreen(){
	return Game->ContinueScreen;
}

void ContinueScreen(int scr){
	Game->ContinueScreen = scr;
}

int LastEntranceDMap(){
	return Game->LastEntranceDMap;
}

void LastEntranceDMap(int dmap){
	Game->LastEntranceDMap = dmap;
}

int LastEntranceScreen(){
	return Game->LastEntranceScreen;
}

void LastEntranceScreen(int scr){
	Game->LastEntranceScreen = scr;
}

int Counter(int ctr){
	return Game->Counter[ctr];
}

void Counter(int ctr, int val){
	Game->Counter[ctr] = val;
}

void Counter(int ctr, bool bump){
	if ( bump ) {
		Game->Counter[ctr]++;
	}
	else Game->Counter[ctr]--;
}

void Counter(int ctr, bool bump, int val){
	if ( bump ) {
		Game->Counter[ctr] += val;
	}
	else Game->Counter[ctr] -= val;
}

int MCounter(int ctr){
	return Game->MCounter[ctr];
}

void MCounter(int ctr, int val){
	Game->MCounter[ctr] = val;
}

void MCounter(int ctr, bool bump){
	if ( bump ) {
		Game->MCounter[ctr]++;
	}
	else Game->MCounter[ctr]--;
}

void MCounter(int ctr, bool bump, int val){
	if ( bump ) {
		Game->MCounter[ctr] += val;
	}
	else Game->MCounter[ctr] -= val;
}

int DCounter(int ctr){
	return Game->DCounter[ctr];
}

void DCounter(int ctr, int val){
	Game->DCounter[ctr] = val;
}

void DCounter(int ctr, bool bump){
	if ( bump ) {
		Game->DCounter[ctr]++;
	}
	else Game->DCounter[ctr]--;
}

void DCounter(int ctr, bool bump, int val){
	if ( bump ) {
		Game->DCounter[ctr] += val;
	}
	else Game->DCounter[ctr] -= val;
}


int NumHeartPieces(){
	return Game->Generic[GEN_HEARTPIECES];
}

void NumHeartPieces(int num){
	Game->Generic[GEN_HEARTPIECES] = num;
}

void NumHeartPieces(int num, bool increase){
	Game->Generic[GEN_HEARTPIECES] += num;
}

int MagicDrainRate(){
	return Game->Generic[GEN_MAGICDRAINRATE] ;
}

void MagicDrainRate(int amount){
	Game->Generic[GEN_MAGICDRAINRATE] = amount;
}

int CanSlash(){
	return Game->Generic[GEN_CANSLASH];
}

void CanSlash(bool canSlash){
	if ( canSlash ) {
		Game->Generic[GEN_CANSLASH] = 1;
	}
	else {
		Game->Generic[GEN_CANSLASH] = 0;
	}
}

int WarpLevel(){
	return Game->Generic[GEN_WARPLEVEL];
}

void WarpLevel(int warpSpot){
	Game->Generic[GEN_WARPLEVEL] = warpSpot;
}

int HeartPiecesPerHC(){
	return Game->Generic[GEN_HCPPERHC];
}

void HeartPiecesPerHC(int num){
	Game->Generic[GEN_HCPPERHC] = num;
}

int ContinueHearts(){
	return Game->Generic[GEN_CONTINUEHEARTS];
}

void ContinueHearts(int hearts){
	Game->Generic[GEN_CONTINUEHEARTS] = hearts;
}

int ContinueIsPercent(){
	return Game->Generic[GEN_CONTINUEISPERCENT];
}

void ContinueIsPercent(int perc){
	Game->Generic[GEN_CONTINUEISPERCENT] = perc;
}

int LevelKeys(int lvl){
	return Game->LKeys[lvl];
}

void LevelKeys(int lvl, int amt){
	Game->LKeys[lvl] += amt;
}

void LevelKeys(int lvl, int amt, bool set){
	Game->LKeys[lvl] = amt;
}

//Shortcuts to Class and Namespace functions

//Screen functions.

int ComboD(int pos){
	return Screen->ComboD[pos];
}

int ComboT(int pos){
	return Screen->ComboT[pos];
}

int ComboF(int pos){
	return Screen->ComboF[pos];
}

int ComboI(int pos){
	return Screen->ComboI[pos];
}

int ComboC(int pos){
	return Screen->ComboC[pos];
}

int ComboS(int pos){
	return Screen->ComboS[pos];
}


void ComboD(int pos, int comboID){
	Screen->ComboD[pos] = comboID;
}

void ComboT(int pos, int type){
	Screen->ComboT[pos] = type;
}

void ComboF(int pos, int flag){
	Screen->ComboF[pos] = flag;
}

void ComboI(int pos, int inhFlag){
	Screen->ComboI[pos] = inhFlag;
}

void ComboC(int pos, int cset){
	Screen->ComboC[pos] = cset;
}

void ComboS(int pos, int solidity){
	Screen->ComboS[pos] = solidity;
}

bool GetComboD(int pos, int comboID){
	if ( Screen->ComboD[pos] == comboID ) return true;
	return false;
}

bool GetComboT(int pos, int type){
	if ( Screen->ComboT[pos] == type ) return true;
	return false;
}

bool GetComboF(int pos, int flag){
	if ( Screen->ComboF[pos] == flag ) return true;
	return false;
}

bool GetComboI(int pos, int inhFlag){
	if ( Screen->ComboI[pos] == inhFlag ) return true;
	return false;
}

bool GetComboC(int pos, int cset, int check){
	if ( Screen->ComboC[pos] == cset ) return true;
	return false;
}

bool GetComboS(int pos, int solidity){
	if ( Screen->ComboS[pos] == solidity ) return true;
	return false;
}

void SetComboD(int pos, int comboID){
	Screen->ComboD[pos] = comboID;
}

void SetComboT(int pos, int type){
	Screen->ComboT[pos] = type;
}

void SetComboF(int pos, int flag){
	Screen->ComboF[pos] = flag;
}

void SetComboI(int pos, int inhFlag){
	Screen->ComboI[pos] = inhFlag;
}

void SetComboC(int pos, int cset){
	Screen->ComboC[pos] = cset;
}

void SetComboS(int pos, int solidity){
	Screen->ComboS[pos] = solidity;
}


int Wavy(){
	return Screen->Wavy;
}

void Wavy(int dur){
	Screen->Wavy = dur;
}

void Wavy(int dur, int frames){
	for ( int q = 0; q < frames; q++ ){
		Screen->Wavy = dur - q;
		//Do we need a Waitframe here?
	}
}

int Quake(){
	return Screen->Quake;
}

void Quake(int dur){
	Screen->Quake = dur;
}

void Quake(int dur, int frames){
	for ( int q = 0; q < frames; q++ ){
		Screen->Quake = dur - q;
		//Do we need a Waitframe here?
	}
}

bool Lit(){
	return Screen->Lit;
}

void Lit(bool setting){
	Screen->Lit = setting;
}

//void TriggerSecrets(){
//	return Screen->TriggerSecrets();
//}

void TriggerSecrets(bool triggered){
	Screen->TriggerSecrets();
}

void TriggerSecrets(int state){
	Screen->State[ST_SECRET] = state;
	Screen->TriggerSecrets();
}

//Link Functions

void Warp(int dmap, int screen){
	Link->Warp(dmap,screen);
}


void PitWarp(int dmap, int screen){
	Link->PitWarp(dmap,screen);
}


//Returns if an inventory item is true;
bool Inv(int itm){
	return Link->Item[itm];
}

//Sets Link->Item, safely.
void Inv(int itm, bool setting){
	if ( Link->Item[itm] != setting ) Link->Item[itm] = setting;
}

bool InputStart() {return Link->InputStart;}
bool InputMap() {return Link->InputMap;}
bool InputUp() {return Link->InputUp;}
bool InputDown() {return Link->InputDown;}
bool InputLeft() {return Link->InputLeft;}
bool InputRight() {return Link->InputRight;}
bool InputA() {return Link->InputA;}
bool InputB() {return Link->InputB;}
bool InputL() {return Link->InputL;}
bool InputR() {return Link->InputR;}
bool InputEx1() {return Link->InputEx1;}
bool InputEx2() {return Link->InputEx2;}
bool InputEx3() {return Link->InputEx3;}
bool InputEx4() {return Link->InputEx4;}
bool InputAxisUp() {return Link->InputAxisUp;}
bool InputAxisDown() {return Link->InputAxisDown;}
bool InputAxisLeft() {return Link->InputAxisLeft;}
bool InputAxisRight() {return Link->InputAxisRight;}
bool PressStart() {return Link->PressStart;}
bool PressMap() {return Link->PressMap;}
bool PressUp() {return Link->PressUp;}
bool PressDown() {return Link->PressDown;}
bool PressLeft() {return Link->PressLeft;}
bool PressRight() {return Link->PressRight;}
bool PressA() {return Link->PressA;}
bool PressB() {return Link->PressB;}
bool PressL() {return Link->PressL;}
bool PressR() {return Link->PressR;}
bool PressEx1() {return Link->PressEx1;}
bool PressEx2() {return Link->PressEx2;}
bool PressEx3() {return Link->PressEx3;}
bool PressEx4() {return Link->PressEx4;}
bool PressAxisUp() {return Link->PressAxisUp;}
bool PressAxisDown() {return Link->PressAxisDown;}
bool PressAxisLeft() {return Link->PressAxisLeft;}
bool PressAxisRight() {return Link->PressAxisRight;}

int InputMouseX() {return Link->InputMouseX;}
int InputMouseY() {return Link->InputMouseY;}
int InputMouseB() {return Link->InputMouseB;}
int InputMouseZ() {return Link->InputMouseZ;}

void InputStart(bool val) { Link->InputStart = val;}
void InputMap(bool val) { Link->InputMap = val;}
void InputUp(bool val) { Link->InputUp = val;}
void InputDown(bool val) { Link->InputDown = val;}
void InputLeft(bool val) { Link->InputLeft = val;}
void InputRight(bool val) { Link->InputRight = val;}
void InputA(bool val) { Link->InputA = val;}
void InputB(bool val) { Link->InputB = val;}
void InputL(bool val) { Link->InputL = val;}
void InputR(bool val) { Link->InputR = val;}
void InputEx1(bool val) { Link->InputEx1 = val;}
void InputEx2(bool val) { Link->InputEx2 = val;}
void InputEx3(bool val) { Link->InputEx3 = val;}
void InputEx4(bool val) { Link->InputEx4 = val;}
void InputAxisUp(bool val) { Link->InputAxisUp = val;}
void InputAxisDown(bool val) { Link->InputAxisDown = val;}
void InputAxisLeft(bool val) { Link->InputAxisLeft = val;}
void InputAxisRight(bool val) { Link->InputAxisRight = val;}
void PressStart(bool val) { Link->PressStart = val;}
void PressMap(bool val) { Link->PressMap = val;}
void PressUp(bool val) { Link->PressUp = val;}
void PressDown(bool val) { Link->PressDown = val;}
void PressLeft(bool val) { Link->PressLeft = val;}
void PressRight(bool val) { Link->PressRight = val;}
void PressA(bool val) { Link->PressA = val;}
void PressB(bool val) { Link->PressB = val;}
void PressL(bool val) { Link->PressL = val;}
void PressR(bool val) { Link->PressR = val;}
void PressEx1(bool val) { Link->PressEx1 = val;}
void PressEx2(bool val) { Link->PressEx2 = val;}
void PressEx3(bool val) { Link->PressEx3 = val;}
void PressEx4(bool val) { Link->PressEx4 = val;}
void PressAxisUp(bool val) { Link->PressAxisUp = val;}
void PressAxisDown(bool val) { Link->PressAxisDown = val;}
void PressAxisLeft(bool val) { Link->PressAxisLeft = val;}
void PressAxisRight(bool val) { Link->PressAxisRight = val;}

void InputMouseX(int val) { Link->InputMouseX = val;}
void InputMouseY(int val) { Link->InputMouseY = val;}
void InputMouseB(int val) { Link->InputMouseB = val;}
void InputMouseZ(int val) { Link->InputMouseZ = val;}

void SelectAWeapon(int dir) {
	Link->SelectAWeapon(dir);
}

void SelectBWeapon(int dir) {
	Link->SelectBWeapon(dir);
}

int MovingBlockX(){ return Screen->MovingBlockX;}
int MovingBlockY(){ return Screen->MovingBlockY;}
int MovingBlockCombo(){ return Screen->MovingBlockCombo;}
int MovingBlockCSet(){ return Screen->MovingBlockCSet;}

int UnderCSet(){ return Screen->UnderCSet;}
void UnderCSet(int value){ Screen->UnderCSet = value;}

int UnderCombo(){ return Screen->UnderCombo;}
void UnderCombo(int value){ Screen->UnderCombo = value;}

int RoomType(){return Screen->RoomType;}
int RoomData(){return Screen->RoomData;}
void RoomData(int val){Screen->RoomData = val;}
//void TriggerSecrets(){Screen->TriggerSecrets();}
//bool Lit(){return Screen->Lit;}
void Lit(int val){Screen->Lit = val;}

void SetSideWarp(int warp, int screen, int dmap, int type){
	Screen->SetSideWarp(warp, screen, dmap, type);
}

void SetTileWarp(int warp, int screen, int dmap, int type){
	Screen->SetTileWarp(warp, screen, dmap, type);
}


void GetSideWarpDMap(int warp){
	Screen->GetSideWarpDMap(warp);
}

void GetSideWarpScreen(int warp){
	Screen->GetSideWarpScreen(warp);
}


void GetSideWarpType(int warp){
	Screen-> GetSideWarpType(warp);
}

void GetTileWarpDMap(int warp){
	Screen->GetTileWarpDMap(warp);
}

void GetTileWarpScreen(int warp){
	Screen->GetTileWarpScreen(warp);
}

void GetTileWarpType(int warp){
	Screen->GetTileWarpType(warp);
}

int LayerMap(int n){
	return Screen->LayerMap(n);
}

int LayerScreen(int n){
	return Screen->LayerScreen(n);
}

int NumItems(){
	return Screen->NumItems();
}

void LoadItem(int itm){
	Screen->LoadItem(itm);
}

void CreateItem(int id){
	Screen->CreateItem(id);
}

ffc LoadFFC(int num){
	return Screen->LoadFFC(num);
}

int NumNPCs(){
	return Screen->NumNPCs();
}

void LoadNOC(int num){
	Screen->LoadNPC(num);
}

void CreateNPC(int id){
	Screen->CreateNPC(id);
}

int NumLWeapons(){
	return Screen->NumLWeapons();
}

void LoadLWeapon(int num){
	Screen->LoadLWeapon(num);
}

void CreateLWeapon(int type){
	Screen->CreateLWeapon(type);
}

int NumEWeapons(){
	return Screen->NumEWeapons();
}

void LoadEWeapon(int num){
	Screen->LoadEWeapon(num);
}

void CreateEWeapon(int type){
	Screen->CreateEWeapon(type);
}

bool isSolid(int x, int y){
	return Screen->isSolid(x,y);
}

void ClearSprites(int spritelist){
	Screen->ClearSprites(spritelist);
}

//Drawing

void Rectangle(int layer, int x, int y, int x2, int y2, int color, float scale, int rx, int ry, int rangle, bool fill, int opacity){
	Screen->Rectangle(layer, x, y, x2, y2, color, scale, rx, ry, rangle, fill, opacity);
}

void Circle(int layer, int x, int y, int radius, int color, float scale, int rx, int ry, int rangle, bool fill, int opacity){
	Screen->Circle(layer, x, y, radius, color, scale, rx, ry, rangle, fill, opacity);
}

void Arc(int layer, int x, int y, int radius, int startangle, int endangle, int color, float scale, int rx, int ry, int rangle, bool closed, bool fill, int opacity){
	Screen->Arc(layer, x, y, radius, startangle, endangle, color, scale, rx, ry, rangle, closed, fill, opacity);
}

void Ellipse(int layer, int x, int y, int xradius, int yradius, int color, float scale, int rx, int ry, int rangle, bool fill, int opacity){
	Screen->Ellipse(layer, x, y, xradius, yradius, color, scale, rx, ry, rangle, fill, opacity);
}

void Spline(int layer, int x1, int y1, int x2, int y2, int x3, int y3,int x4, int y4, int color, int opacity){
	Screen->Spline(layer, x1, y1, x2, y2, x3, y3, x4, y4, color, opacity);
}

void Line(int layer, int x, int y, int x2, int y2, int color, float scale, int rx, int ry, int rangle, int opacity){
	Screen->Line(layer, x, y, x2, y2, color, scale, rx, ry, rangle, opacity);
}

void PutPixel(int layer, int x, int y, int color, int rx, int ry, int rangle, int opacity){
	Screen->PutPixel(layer, x, y, color, rx, ry, rangle, opacity);
}

void DrawTile(int layer, int x, int y, int tile, int blockw, int blockh, int cset, int xscale, int yscale, int rx, int ry, int rangle, int flip, bool transparency, int opacity){
	Screen->DrawTile(layer, x, y, tile, blockw, blockh, cset, xscale, yscale, rx, ry, rangle, flip, transparency, opacity);
}


bool working;
int MyArray[10];


item script rubbish{ 
	void run(){
		int x = 1;
		atcive.rubbish(x);
		working = true;
	}
}

global script atcive{
	void run(){
		int MyArray[20];
		int x = SizeOfArray(MyArray);
		Trace(x);
		while ( true ) {
			Trace(MyArray[1]);
			working = false;
			Waitframe();
		}
	}
	void rubbish(int MyArray){
		Trace(SizeOfArray(MyArray));
		MyArray[1] = 100;
	}
}

item script PlayerSprites{ 
	void run(int SpriteLink){
		PlayerSprites[0]=Rand(1,50);
	}
}
int PlayerSprites[100] = {12};

global script active{
	void run(){
		Link->Invisible = true;
		int SpriteLink[1]={12};
		while ( true ) {
			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->UseSprite(PlayerSprites[0]);
			Waitdraw();
			PlayerSprite->DeadState = WDS_DEAD;
			//PlayerSprite(PlayerSprite,SpriteLink);
			Waitframe();
		}
	}
	void PlayerSprite(int SpriteLink, int sprite){
		SpriteLink[0] = sprite;
	}
	
}



bool GetEquipmentA(int item){
	return GetEquipmentA() == item;
}

bool GetEquipmentB(int item){
	return GetEquipmentB() == item;
}