I spent an hour learning how to Git. Help

script/game/99Sec_EnmLib.dnh

@@ -0,0 +1,873 @@
+
+/*
+
+Enemy Waves (Ground):
+
+Small:
+
+Lilypod with 4 frogs on it, firing aimed bullets
+Lilypad with a COOL frog firing spirals
+
+Large:
+
+Hut when destroyed releases 6 frog enemies that fly upwards and start moving towards the player
+
+Enemy Waves (Flying):
+
+Small:
+
+3 lines of small fairies firing aimed bullets
+Horizontal wave of fairies firing aimed fans, followed by horizontal wave firing aimed rings
+Fairies coming from both sides, firing falling bullet lines
+2 tightly-knit lines of small fairies firing aimed fans, alongside a large fairy firing rings
+
+Large:
+
+Two fairies firing line-rings, one following the other
+One giant fairy on spaceship firing aimed line-fans and light rings
+2 giant fairies firing aimed line fans only, one following the other
+	
+*/
+
+int smallEnemyHitbox = 75;
+int largeEnemyHitbox = 110;
+int popcornHitbox = 75;
+
+float smallEnemyHP = 50;
+float largeEnemyHP = 240;
+float largeEnemyAltHP = 180;
+float popcornHP = 50;
+
+float smallEnemyScale = 0.7;
+float largeEnemyScale = 1;
+float popcornScale = 0.7;
+
+function <int> CreateFan (int parent, int way, int graphic, int stack, 
+	float ang, float angspace, float spd1, float spd2, float scaleBullet,
+	int type, bool reflect){
+
+	int objPattern = ObjPatternShot_Create();
+	
+	ObjPatternShot_SetParentObject(objPattern, parent);
+	
+	//if(ObjEnemyBossScene_GetInfo(GetEnemyBossSceneObjectID(), INFO_CURRENT_LIFE) == 0){Obj_Delete(objPattern); return;}
+	
+	ObjPatternShot_SetPatternType(objPattern, type); // PATTERN_FAN or PATTERN_FAN_AIMED
+	ObjPatternShot_SetShotType(objPattern, OBJ_SHOT);
+	ObjPatternShot_SetInitialBlendMode(objPattern, BLEND_ALPHA);
+	
+	ObjPatternShot_SetShotCount(objPattern, way, stack);
+	ObjPatternShot_SetSpeed(objPattern, spd1, spd2);
+	ObjPatternShot_SetAngle(objPattern, ang, angspace);
+	
+	ObjPatternShot_SetBasePointOffset(objPattern, 0, 0);
+	//ObjPatternShot_SetDelay(objPattern, 15);
+	ObjPatternShot_SetGraphic(objPattern, graphic);
+	
+	//Shoot2;
+	let arrayPattern = ObjPatternShot_FireReturn(objPattern);
+	
+	ascent(i in -1..length(arrayPattern)-1){
+		_BulletRescale(arrayPattern[i], scaleBullet, true, 1);
+		_Delay(arrayPattern[i], 10);
+		//Obj_SetRenderPriorityI(arrayPattern[i], 51);
+	}
+	
+	async{
+		wait(300);
+		Obj_Delete(objPattern);
+		return;
+	}
+	
+	return objPattern;
+	
+}
+
+// Overload
+
+function <int> CreateFan (int parent, int way, int graphic, int stack, 
+	float ang, float angspace, float spd1, float spd2, float scaleBullet,
+	float xOffset, float yOffset,
+	int type, bool reflect){
+
+	int objPattern = ObjPatternShot_Create();
+	
+	ObjPatternShot_SetParentObject(objPattern, parent);
+	
+	//if(ObjEnemyBossScene_GetInfo(GetEnemyBossSceneObjectID(), INFO_CURRENT_LIFE) == 0){Obj_Delete(objPattern); return;}
+	
+	ObjPatternShot_SetPatternType(objPattern, type); // PATTERN_FAN or PATTERN_FAN_AIMED
+	ObjPatternShot_SetShotType(objPattern, OBJ_SHOT);
+	ObjPatternShot_SetInitialBlendMode(objPattern, BLEND_ALPHA);
+	
+	ObjPatternShot_SetShotCount(objPattern, way, stack);
+	ObjPatternShot_SetSpeed(objPattern, spd1, spd2);
+	ObjPatternShot_SetAngle(objPattern, ang, angspace);
+	
+	ObjPatternShot_SetBasePointOffset(objPattern, xOffset, yOffset);
+	//ObjPatternShot_SetDelay(objPattern, 15);
+	ObjPatternShot_SetGraphic(objPattern, graphic);
+	
+	//Shoot2;
+	let arrayPattern = ObjPatternShot_FireReturn(objPattern);
+	
+	ascent(i in -1..length(arrayPattern)-1){
+		_BulletRescale(arrayPattern[i], scaleBullet, true, 1);
+		_Delay(arrayPattern[i], 10);
+		//Obj_SetRenderPriorityI(arrayPattern[i], 51);
+	}
+	
+	async{
+		wait(300);
+		Obj_Delete(objPattern);
+		return;
+	}
+	
+	return objPattern;
+	
+}
+
+task _SmallFairyFallingLine(
+	int renderPriority,
+	float enmX, enmY, spdMove, angMove, int graphicBullet,
+	int numLine, float maxspeedBullet, float delayLine, float delayBullet, float scaleBullet
+	){
+	
+	// Spawns enemy.
+	
+	int enm = _CreateEnemy(
+	enmX, enmY, enmX, enmY, 5,
+	smallEnemyScale, smallEnemyScale,
+	smallEnemyHP, smallEnemyHitbox, 0,
+	texEnm,
+	768, 0, 1024, 256);
+	
+	Obj_SetRenderPriorityI(enm, renderPriority);
+	
+	ObjMove_SetSpeed(enm, spdMove);
+	ObjMove_SetAngle(enm, angMove);
+	
+	ObjEnemy_SetDamageRate(enm, 0, 0);
+	
+	wait(5);
+	
+	ObjEnemy_SetAutoDelete(enm, true);
+	
+	async{
+	
+		wait(5);
+		
+		while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
+			
+			if(ObjMove_GetX(enm) < STG_WIDTH && ObjMove_GetX(enm) > 0){
+			
+				loop(numLine){
+				
+					int bullet = CreateShotA2(ObjMove_GetX(enm), ObjMove_GetY(enm), 0, 90, maxspeedBullet/30, maxspeedBullet, graphicBullet, 10);
+					
+					_BulletRescale(bullet, scaleBullet, true, 1);
+					_Delay(bullet, 10);
+					
+					if(ObjEnemy_GetInfo(enm, INFO_LIFE) <= 0){Obj_Delete(bullet);}
+					else{
+						Shoot1;
+					}
+				
+					wait(delayBullet);
+					
+				}
+				
+				wait(delayLine);
+			
+			}
+			
+			else{yield;}
+			
+		}
+	
+	}
+	
+	_EnemyItemDrop(
+	enm, true,
+	5, 3,
+	10+(GetCommonData("Rank", 1)-1)*2, 6+(GetCommonData("Rank", 1)-1)*1, 
+	120, smallEnemyHitbox*2
+	);
+	
+}
+
+task _SmallFairyAimedFan(
+	int renderPriority,
+	float enmX, float enmY, float spdMove, float angMove, int graphicBullet, float angspaceFan,
+	float speedFan1, float speedFan2, int widthFan, int stackFan, int delayFan, float scaleBullet
+	){
+
+	// Spawns enemy.
+	
+	int enm = _CreateEnemy(
+	enmX, enmY, enmX, enmY, 5,
+	smallEnemyScale, smallEnemyScale,
+	smallEnemyHP, smallEnemyHitbox, 0,
+	texEnm,
+	256, 0, 512, 256);
+	
+	Obj_SetRenderPriorityI(enm, renderPriority);
+	
+	ObjMove_SetSpeed(enm, spdMove);
+	ObjMove_SetAngle(enm, angMove);
+	
+	ObjEnemy_SetDamageRate(enm, 0, 0);
+	
+	wait(5);
+	
+	ObjEnemy_SetAutoDelete(enm, true);
+	
+	async{
+	
+		wait(5);
+		
+		while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
+			
+			if(ObjMove_GetY(enm) < 10*STG_HEIGHT/12-100 && ObjMove_GetY(enm) > STG_HEIGHT/9){
+			
+				int bullet = CreateFan(enm, widthFan, graphicBullet, stackFan, 
+				0, angspaceFan, speedFan1, speedFan2, scaleBullet,
+				PATTERN_FAN_AIMED, false);
+				
+				if(ObjEnemy_GetInfo(enm, INFO_LIFE) <= 0){Obj_Delete(bullet);}
+				else{
+					Shoot1;
+				}
+				
+				wait(delayFan);
+			
+			}
+			
+			else{yield;}
+			
+		}
+	
+	}
+	
+	_EnemyItemDrop(
+	enm, true,
+	5, 3,
+	10+(GetCommonData("Rank", 1)-1)*2, 6+(GetCommonData("Rank", 1)-1)*1, 
+	120, smallEnemyHitbox*2
+	);
+	
+}
+
+
+task _SmallFairyRing(
+	int renderPriority, int graphicBullet, 
+	float enmX, enmY,
+	int denseRing, float delayRing, float speedRing,
+	float spdMove, angMove, scaleBullet
+	){
+
+	// Spawns enemy.
+	
+	int enm = _CreateEnemy(
+	enmX, enmY, enmX, enmY, 5,
+	smallEnemyScale, smallEnemyScale,
+	smallEnemyHP, smallEnemyHitbox, 0,
+	texEnm,
+	768, 0, 1024, 256);
+	
+	Obj_SetRenderPriorityI(enm, renderPriority);
+	
+	ObjMove_SetSpeed(enm, spdMove);
+	ObjMove_SetAngle(enm, angMove);
+	
+	ObjEnemy_SetDamageRate(enm, 0, 0);
+	
+	wait(5);
+	
+	ObjEnemy_SetAutoDelete(enm, true);
+	
+	async{
+	
+		wait(5);
+		
+		while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
+			
+			if(ObjMove_GetX(enm) < STG_WIDTH && ObjMove_GetX(enm) > 0){
+			
+				ascent(i in -1..denseRing){
+				
+					int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), speedRing, GetAngleToPlayer(enm)+i*360/denseRing, graphicBullet, 10);
+					
+					_BulletRescale(bullet, scaleBullet, true, 1);
+					_Delay(bullet, 10);
+					
+					if(ObjEnemy_GetInfo(enm, INFO_LIFE) <= 0){Obj_Delete(bullet);}
+					else{
+						Shoot1;
+					}
+					
+				}
+				
+				wait(delayRing);
+			
+			}
+			
+			else{yield;}
+			
+		}
+	
+	}
+	
+	_EnemyItemDrop(
+	enm, true,
+	5, 3,
+	10+(GetCommonData("Rank", 1)-1)*2, 6+(GetCommonData("Rank", 1)-1)*1,  
+	120, smallEnemyHitbox*2
+	);
+	
+}
+
+task _CreateFrog(
+	int renderPriority, int[] rect, int graphicBullet, 
+	float angspaceFan, float speedFan1, float speedFan2, int widthFan, int stackFan, int delayFan,
+	float frogX, frogY, speedMoveFrog, scaleBullet
+	){
+
+	int enm = _CreateEnemy(
+	frogX, frogY, frogX, frogY, 5,
+	popcornScale, popcornScale,
+	popcornHP, popcornHitbox, 0,
+	texEnm,
+	rect[0], rect[1], rect[2], rect[3]);
+	
+	Obj_SetRenderPriorityI(enm, renderPriority);
+	
+	ObjMove_SetSpeed(enm, speedMoveFrog);
+	ObjMove_SetAngle(enm, 90);
+	
+	ObjEnemy_SetDamageRate(enm, 0, 0);
+	
+	wait(15);
+	
+	ObjEnemy_SetAutoDelete(enm, true);
+	
+	async{
+	
+		wait(5);
+		
+		while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
+			
+			if(ObjMove_GetY(enm) < 10*STG_HEIGHT/12-100 && ObjMove_GetY(enm) > STG_HEIGHT/9){
+			
+				int bullet = CreateFan(enm, widthFan, graphicBullet, stackFan, 
+				0, angspaceFan, speedFan1, speedFan2, scaleBullet,
+				PATTERN_FAN_AIMED, false);
+				
+				if(ObjEnemy_GetInfo(enm, INFO_LIFE) <= 0){Obj_Delete(bullet);}
+				else{Shoot2;}
+				
+				wait(delayFan);
+			
+			}
+			
+			else{yield;}
+			
+		}
+	
+	}
+	
+	_EnemyItemDrop(
+	enm, false,
+	4, 8,
+	7+round((GetCommonData("Rank", 1)-1)*1.25), 15+(GetCommonData("Rank", 1)-1)*2, 
+	120, popcornHitbox*2
+	);
+	
+}
+
+task _CreateKingFrog(
+	int renderPriority, int[] rect, int graphicBullet, 
+	float angSpiral, float delaySpiral, float speedSpiral,
+	float frogX, frogY, speedMoveFrog, scaleBullet
+	){
+
+	int enm = _CreateEnemy(
+	frogX, frogY, frogX, frogY, 5,
+	largeEnemyScale, largeEnemyScale,
+	largeEnemyHP, largeEnemyHitbox, 0,
+	texEnm,
+	rect[0], rect[1], rect[2], rect[3]);
+	
+	Obj_SetRenderPriorityI(enm, renderPriority);
+	
+	ObjMove_SetSpeed(enm, speedMoveFrog);
+	ObjMove_SetAngle(enm, 90);
+	
+	ObjEnemy_SetDamageRate(enm, 0, 0);
+	
+	async{
+	
+		if(GetCommonData("Ground Loops Cleared", 0) % 2 == 0 && GetCommonData("Ground Loops Cleared", 0) != 0){
+			
+			int sigil = _Create2DImage(texEnm, [0, 1024, 512, 1536]);
+			ObjRender_SetAlpha(sigil, 240);
+			Obj_SetRenderPriorityI(sigil, Obj_GetRenderPriorityI(enm)-1);
+			
+			while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
+				ObjRender_SetPosition(sigil, ObjMove_GetX(enm), ObjMove_GetY(enm), 1);
+				ObjRender_SetAngleZ(sigil, ObjRender_GetAngleZ(sigil)+3);
+				yield;
+			}
+			
+			Obj_Delete(sigil);
+			
+		}
+		
+	}
+	
+	async{
+	
+		float x, y;
+		
+		wait(60);
+		
+		while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
+			x = ObjMove_GetX(enm);
+			y = ObjMove_GetY(enm);
+			yield;
+		}
+		
+		DeleteShotInCircle(TYPE_SHOT, TYPE_ITEM, x, y, 384);
+		ObjSound_Play(bossBoom);
+		if(GetCommonData("Ground Loops Cleared", 0) % 2 == 0 && GetCommonData("Ground Loops Cleared", 0) != 0){CreateExtendItem(EXTEND_SPELL, x, y);}
+		TExplosionA(x, y, 10, 0.5);
+		
+	}
+	
+	wait(60);
+	
+	ObjEnemy_SetAutoDelete(enm, true);
+	
+	async{
+	
+		wait(5);
+		
+		while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
+			
+			if(ObjMove_GetY(enm) < 11*STG_HEIGHT/12 && ObjMove_GetY(enm) > STG_HEIGHT/12){
+			
+				SpawnSpiral(0, 1);
+				wait(delaySpiral * 360/angSpiral);
+			
+			}
+			
+			else{yield;}
+			
+		}
+	
+	}
+	
+	task SpawnSpiral(float angStart, int spinDir){
+	
+		async{
+			ascent(i in -1..360/angSpiral){
+				int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), speedSpiral, angStart+i*spinDir*angSpiral, graphicBullet, 10);
+				int bullet2 = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), speedSpiral, angStart+(180+angStart)-i*spinDir*angSpiral, graphicBullet, 10);
+				if(Obj_IsDeleted(enm)){Obj_Delete(bullet); Obj_Delete(bullet2); break;}
+				else{
+				
+					Shoot2;
+					_BulletRescale(bullet, scaleBullet, true, 1); _BulletRescale(bullet2, scaleBullet, true, 1);
+					_Delay(bullet, 10); _Delay(bullet2, 10);
+					
+				}
+				wait(delaySpiral);
+			}
+		}
+
+		async{
+			ascent(i in -1..360/angSpiral){
+				int bullet = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), speedSpiral, angStart+i*-spinDir*angSpiral, graphicBullet, 10);
+				int bullet2 = CreateShotA1(ObjMove_GetX(enm), ObjMove_GetY(enm), speedSpiral, angStart+(180+angStart)-i*-spinDir*angSpiral, graphicBullet, 10);
+				if(Obj_IsDeleted(enm)){Obj_Delete(bullet); Obj_Delete(bullet2); break;}
+				else{
+				
+					Shoot2;
+					_BulletRescale(bullet, scaleBullet, true, 1); _BulletRescale(bullet2, scaleBullet, true, 1);
+					_Delay(bullet, 10); _Delay(bullet2, 10);
+					
+				}
+				wait(delaySpiral);
+			}
+		}
+		
+	}
+	
+	_EnemyItemDrop(
+	enm, false,
+	8, 14,
+	round(15+(GetCommonData("Rank", 1)-1)*1.25), round(20+(GetCommonData("Rank", 1)-1)*2), 
+	180, largeEnemyHitbox*2.5
+	);
+	
+	//ObjEnemy_SetDamageRate(enm, 100, 150);
+	
+}
+
+
+task _LilypodWithKingFrog(
+	int renderFrog, int graphicBullet, 
+	float lilyX, float lilyY,
+	float angSpiral, float delaySpiral, float speedSpiral, float scaleBullet,
+	float speedMove
+	){
+
+	float offsetX = 80;
+	float offsetY = 70;
+	
+	int lilypad = _CreateEnemy(
+	false,
+	lilyX, lilyY, lilyX, lilyY, 5,
+	1, 1,
+	999, 0, 0,
+	texEnm,
+	1536, 256, 2048, 768);
+	
+	Obj_SetRenderPriorityI(lilypad, renderFrog-4);
+	
+	ObjMove_SetSpeed(lilypad, speedMove);
+	ObjMove_SetAngle(lilypad, 90);
+	
+	ObjEnemy_SetDamageRate(lilypad, 0, 0);
+	
+	wait(15);
+	
+	ObjEnemy_SetAutoDelete(lilypad, true);
+	
+	async{
+		
+		_CreateKingFrog(
+			renderFrog, [1024, 768, 1280, 1024], graphicBullet,
+			angSpiral, delaySpiral, speedSpiral,
+			lilyX, lilyY, speedMove, scaleBullet
+		);
+		
+	}
+	
+}
+
+
+task _LilypodWith4Frogs(
+	int renderFrog, int graphicBullet, 
+	float lilyX, float lilyY,
+	float angspaceFan, float speedFan1, float speedFan2, int widthFan, int stackFan, int delayFan, float scaleBullet,
+	float speedMove
+	){
+	
+	float offsetX = 80;
+	float offsetY = 70;
+	
+	int lilypad = _CreateEnemy(
+	false,
+	lilyX, lilyY, lilyX, lilyY, 5,
+	1, 1,
+	999, 0, 0,
+	texEnm,
+	1536, 256, 2048, 768);
+	
+	Obj_SetRenderPriorityI(lilypad, renderFrog-4);
+	
+	ObjMove_SetSpeed(lilypad, speedMove);
+	ObjMove_SetAngle(lilypad, 90);
+	
+	ObjEnemy_SetDamageRate(lilypad, 0, 0);
+	
+	wait(5);
+	
+	ObjEnemy_SetAutoDelete(lilypad, true);
+	
+	async{
+		
+		_CreateFrog(
+			renderFrog, [[1024, 512, 1280, 768], [1280, 512, 1536, 768]][rand_int(0, 1)], graphicBullet,
+			angspaceFan, speedFan1, speedFan2, widthFan, stackFan, delayFan,
+			lilyX+offsetX, lilyY+offsetY, speedMove, scaleBullet
+		);
+		_CreateFrog(
+			renderFrog, [[1024, 512, 1280, 768], [1280, 512, 1536, 768]][rand_int(0, 1)], graphicBullet,
+			angspaceFan, speedFan1, speedFan2, widthFan, stackFan, delayFan,
+			lilyX-offsetX, lilyY+offsetY, speedMove, scaleBullet
+		);
+
+		_CreateFrog(
+			renderFrog-1, [[1024, 512, 1280, 768], [1280, 512, 1536, 768]][rand_int(0, 1)], graphicBullet,
+			angspaceFan, speedFan1, speedFan2, widthFan, stackFan, delayFan,
+			lilyX+offsetX, lilyY-offsetY, speedMove, scaleBullet
+		);
+		_CreateFrog(
+			renderFrog-1, [[1024, 512, 1280, 768], [1280, 512, 1536, 768]][rand_int(0, 1)], graphicBullet,
+			angspaceFan, speedFan1, speedFan2, widthFan, stackFan, delayFan,
+			lilyX-offsetX, lilyY-offsetY, speedMove, scaleBullet
+		);
+		
+	}
+
+}
+
+
+task _LilypodWith2Frog(
+	int renderFrog, int graphicBullet, 
+	float lilyX, float lilyY,
+	float angspaceFan, float speedFan1, float speedFan2, int widthFan, int stackFan, int delayFan, float scaleBullet,
+	float speedMove
+	){
+	
+	int lilypad = _CreateEnemy(
+	false,
+	lilyX, lilyY, lilyX, lilyY, 5,
+	0.75, 0.75,
+	999, 0, 0,
+	texEnm,
+	1536, 256, 2048, 768);
+	
+	Obj_SetRenderPriorityI(lilypad, renderFrog-4);
+	
+	ObjMove_SetSpeed(lilypad, speedMove);
+	ObjMove_SetAngle(lilypad, 90);
+	
+	ObjEnemy_SetDamageRate(lilypad, 0, 0);
+	
+	wait(5);
+	
+	ObjEnemy_SetAutoDelete(lilypad, true);
+	
+	async{
+		
+		_CreateFrog(
+			renderFrog, [1280, 512, 1536, 768], graphicBullet,
+			angspaceFan, speedFan1, speedFan2, widthFan, stackFan, delayFan,
+			lilyX-60, lilyY, speedMove, scaleBullet
+		);
+		_CreateFrog(
+			renderFrog, [1280, 512, 1536, 768], graphicBullet,
+			angspaceFan, speedFan1, speedFan2, widthFan, stackFan, delayFan,
+			lilyX+60, lilyY, speedMove, scaleBullet
+		);
+		
+	}
+
+}
+
+// Leave this for the boss.
+
+task _CreateRybbShip(
+	int renderShip, int graphicBullet, 
+	float shipX, shipY,
+	float speedRing, speedLine, int delayLine, delayRing, angleRing, denseLine, delayBullet, float scaleBullet,
+	float speedMove
+	){
+	
+	int ship = _CreateEnemy(
+	false,
+	shipX, shipY, shipX, shipY, 5,
+	1, 1,
+	999, 0, 0,
+	texEnm,
+	1280, 1024, 2048, 1536);
+	
+	Obj_SetRenderPriorityI(ship, renderShip-1);
+	
+	ObjMove_SetSpeed(ship, speedMove);
+	ObjMove_SetAngle(ship, 90);
+	
+	ObjEnemy_SetDamageRate(ship, 0, 0);
+	
+	wait(15);
+	
+	ObjEnemy_SetAutoDelete(ship, true);
+	
+	// Create enemy
+	
+	async{
+		
+		int enm = _CreateEnemy(
+		shipX, shipY, shipX, shipY, 5,
+		largeEnemyScale, largeEnemyScale,
+		largeEnemyHP, largeEnemyHitbox, 0,
+		texEnm,
+		0, 256, 256, 512);
+		
+		Obj_SetRenderPriorityI(enm, renderShip);
+		
+		ObjEnemy_SetDamageRate(enm, 0, 0);
+		
+		wait(15);
+		
+		ObjEnemy_SetAutoDelete(enm, true);
+		
+		async{
+		
+			float x, y, curxShip, curyShip;
+			
+			while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0 && !Obj_IsDeleted(ship)){
+				x = ObjMove_GetX(enm);
+				y = ObjMove_GetY(enm);
+				curxShip = ObjMove_GetX(ship);
+				curyShip = ObjMove_GetY(ship);
+				
+				ObjMove_SetPosition(enm, curxShip, curyShip-128);
+					
+				yield;
+			}
+			
+			DeleteShotInCircle(TYPE_SHOT, TYPE_ITEM, x, y, 512);
+			
+		}
+		
+		async{
+		
+			wait(5);
+			
+			while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
+				
+				if(ObjMove_GetY(enm) < 11*STG_HEIGHT/12 && ObjMove_GetY(enm) > STG_HEIGHT/12){
+	
+					ascent(i in -1..360/angleRing){
+						int bullet = CreateShotA1(ObjMove_GetX(enm)+rand(-45, 45), ObjMove_GetY(enm)+rand(-30, 30), speedRing, GetAngleToPlayer(enm)+i*angleRing, graphicBullet, 10);
+						if(Obj_IsDeleted(enm)){Obj_Delete(bullet); break;}
+						
+						else{
+						
+							Shoot1;
+							_BulletRescale(bullet, scaleBullet, true, 1);
+							_Delay(bullet, 10);
+							
+						}
+					}
+					
+					wait(delayRing);
+					
+				}
+				
+				else{yield;}
+				
+			}
+		
+		}
+		
+		_EnemyItemDrop(
+		enm, true,
+		6, 10,
+		round(9+(GetCommonData("Rank", 1)-1)*1.1), round(16+(GetCommonData("Rank", 1)-1)*1.4), 
+		180, largeEnemyHitbox*2.5
+		);
+	
+	}
+
+}
+// VARIABLES
+
+task _LargeFairyAimedFan(
+	int renderPriority, bool checkBomb,
+	float enmX, float enmY, float spdMove, float angMove, int graphicBullet, float angspaceFan,
+	float speedFan1, float speedFan2, int widthFan, int stackFan, int delayFan, float scaleBullet
+	){
+
+	// Spawns enemy.
+	
+	int enm = _CreateEnemy(
+	enmX, enmY, enmX, enmY, 5,
+	largeEnemyScale, largeEnemyScale,
+	largeEnemyAltHP, largeEnemyHitbox, 0,
+	texEnm,
+	0, 256, 256, 512);
+	
+	Obj_SetRenderPriorityI(enm, renderPriority);
+	
+	ObjMove_SetSpeed(enm, spdMove);
+	ObjMove_SetAngle(enm, angMove);
+	
+	ObjEnemy_SetDamageRate(enm, 0, 0);
+	
+	async{
+		
+		if(checkBomb && GetCommonData("Flying Loops Cleared", 0) % 4 == 0 && GetCommonData("Flying Loops Cleared", 0) != 0){
+		
+			int sigil = _Create2DImage(texEnm, [0, 1024, 512, 1536]);
+			ObjRender_SetAlpha(sigil, 240);
+			Obj_SetRenderPriorityI(sigil, Obj_GetRenderPriorityI(enm)-1);
+			
+			while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
+				ObjRender_SetPosition(sigil, ObjMove_GetX(enm), ObjMove_GetY(enm), 1);
+				ObjRender_SetAngleZ(sigil, ObjRender_GetAngleZ(sigil)+3);
+				yield;
+			}
+			
+			Obj_Delete(sigil);
+			
+		}
+	}
+			
+	async{
+		float x = 0, y = 0;
+		wait(max(10, 30-GetCommonData("Rank", 0)*5));
+		while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
+			x = ObjMove_GetX(enm);
+			y = ObjMove_GetY(enm);
+			yield;
+		}
+		
+		DeleteShotInCircle(TYPE_SHOT, TYPE_ITEM, x, y, 256);
+		ObjSound_Play(bossBoom);
+		if(checkBomb){if(GetCommonData("Flying Loops Cleared", 0) % 4 == 0 && GetCommonData("Flying Loops Cleared", 0) != 0){CreateExtendItem(EXTEND_SPELL, x, y);}}
+		TExplosionA(x, y, 10, 0.5);
+		
+	}
+	
+	wait(max(10, 30-GetCommonData("Rank", 0)*5));
+	
+	ObjEnemy_SetAutoDelete(enm, true);
+	
+	async{
+	
+		wait(5);
+		
+		while(ObjEnemy_GetInfo(enm, INFO_LIFE) > 0){
+			
+			if(ObjMove_GetY(enm) < 10*STG_HEIGHT/12-100 && ObjMove_GetY(enm) > STG_HEIGHT/10){
+			
+				int bullet = CreateFan(enm, widthFan, graphicBullet, stackFan, 
+				0, angspaceFan, speedFan1, speedFan2, scaleBullet,
+				PATTERN_FAN_AIMED, false);
+				
+				if(ObjEnemy_GetInfo(enm, INFO_LIFE) <= 0){Obj_Delete(bullet);}
+				else{
+					Shoot1;
+				}
+				
+				wait(delayFan);
+			
+			}
+			
+			else{yield;}
+			
+		}
+	
+	}
+	
+	_EnemyItemDrop(
+	enm, true,
+	15, 6,
+	round(20+(GetCommonData("Rank", 1)-1)*2.25), round(12+(GetCommonData("Rank", 1)-1)*2), 
+	180, largeEnemyHitbox*2
+	);
+	
+	//ObjEnemy_SetDamageRate(enm, 100, 150);
+	
+}
+
+task _WaitForAutoDelete(int shot, int timeWait){
+	ObjShot_SetAutoDelete(shot, false);
+	wait(timeWait);
+	ObjShot_SetAutoDelete(shot, true);
+}

script/game/Boss_Plural.dnh

@@ -0,0 +1,134 @@
+#TouhouDanmakufu[Plural]
+#ScriptVersion[3]
+#Title["Boss Plural"]
+#Text["..."]
+#System["script/KevinSystem/Kevin_System.txt"] 
+//#Player["script/KevinPackage/KevinScript_Players/PankevKouda/KevKou_Main.dnh", "script/KevinPackage/KevinScript_Players/MariHousui/MariHousui_Main.dnh"]
+
+let csd = GetCurrentScriptDirectory();
+
+let obj = ObjEnemyBossScene_Create();
+int objBGM = ObjSound_Create();
+
+#include "script/KevinSystem/Universal_Lib.txt"
+#include "script/game/Stage_Background.dnh"
+
+int LifeStart = GetCommonData("Starting Lives", 3);
+
+bool bossTrueStart = false;
+float BGMRate = GetAreaCommonData("Config", "BGMVol", 100) * 0.01;
+
+@Event{
+	
+	alternative (GetEventType())
+	
+	case(EV_PAUSE_ENTER){
+		if (bossTrueStart) {ObjSound_Stop(objBGM);}
+	}
+
+	case(EV_PAUSE_LEAVE){
+		if (bossTrueStart) {ObjSound_Play(objBGM);}
+	}
+	
+}
+
+@Initialize{
+
+	SetCommonData("Flying Defeated", 0);
+	SetCommonData("Ground Defeated", 0);
+	//SetCommonData("IsBomb", false);
+	SetCommonData("Rank", 1);
+
+	if(!IsCommonDataAreaExists("PIV")){
+	CreateCommonDataArea("PIV");
+	SetAreaCommonData("PIV", "currentvalue", 10000);
+	}
+	else{}
+	
+	SetPlayerLife(GetAreaCommonData("Config", "StartingLife", 3));
+	
+	SetAutoDeleteObject(true);
+	
+	// 0: Yal, 1: Wareya
+	//SetAreaCommonData("Config", "BGMSelect", "Wareya");
+	
+	if(GetAreaCommonData("Config", "BGMSelect", 0) == 1){
+		ObjSound_Load(objBGM, "script/game/resourceLib/BossTheme_Wareya1.ogg");
+		ObjSound_SetLoopTime(objBGM, 1.644, 51.110);
+	}
+	
+	else{
+		ObjSound_Load(objBGM, "script/game/resourceLib/BossTheme_Yal.ogg");
+		ObjSound_SetLoopTime(objBGM, 0.001, 92.81);
+	}
+	
+	ObjSound_SetSoundDivision(objBGM, SOUND_BGM);
+	ObjSound_SetResumeEnable(objBGM, true);
+	ObjSound_SetLoopEnable(objBGM, true);
+	//ObjSound_SetLoopTime(objBGM, 0.00, 89.618);
+	
+	ObjSound_SetVolumeRate(objBGM, 60*BGMRate);
+	
+	PluralTask();	
+
+}
+
+@MainLoop{    
+	yield;
+}
+
+@Finalize
+{
+}
+
+
+/* TO DO:
+
++ Single *syncing* - ensure that the boss stays at the same position
+*/
+// Task to handle the plural's boss scene 
+
+task PluralTask(){
+	// Registering individual singles
+
+	ObjEnemyBossScene_Add(obj, 0, csd ~ "99Sec.dnh");
+	ObjEnemyBossScene_LoadInThread(obj);
+	
+	_ScrollBackground();
+	
+	// Loading and registering the boss scene
+	ObjEnemyBossScene_Regist(obj);
+	
+	bossTrueStart = true;
+	ObjSound_Play(objBGM);
+	
+	async{
+		while(GetPlayerState() != STATE_END){yield;}
+		ObjSound_Stop(objBGM);
+	}
+	
+	while(!Obj_IsDeleted(obj)){
+		yield;
+	}
+	
+	ObjSound_Stop(objBGM);
+	bossTrueStart = false;
+	
+	//_ExplosionEffect(GetCommonData("Boss Position X", STG_WIDTH/2), GetCommonData("Boss Position Y", STG_WIDTH/2), PetalEffect);
+
+	if(!IsReplay() & LifeStart <= 3){
+	
+		int highScore = GetAreaCommonData("Data", "High Score", 0);
+		int curScore = GetCommonData("Run Score", 0);
+		
+		if(curScore > highScore){SetAreaCommonData("Data", "High Score", curScore);}
+		else{}
+	
+	}
+	
+	SaveCommonDataAreaA2("Data", "script/game/data.dat");
+	
+	SetAutoDeleteObject(true);
+	wait(60);
+	CloseScript(GetOwnScriptID());
+}

script/game/Non1.dnh

@@ -0,0 +1,266 @@
+#TouhouDanmakufu[Single]
+#ScriptVersion[3]
+#Title["Remilia Nonspell 1"]
+#Text["yassification"]
+#System["script/KevinSystem/Kevin_System.txt"]
+
+int difficultySelect = 0;
+
+let objScene = GetEnemyBossSceneObjectID();
+let csd = GetCurrentScriptDirectory();
+
+let bossObj;
+
+float bossX = 0; 
+float bossY = 0;
+float playerY = 0;
+float playerX = 0;
+
+let aniframe = 0;
+let aniframe2 = 0;
+
+let spellsnd = ObjSound_Create(); 
+let bossdiesnd = ObjSound_Create();
+
+/*Parameters:
+
+- Density of red bubble spiral
+- Delay between red bubble firing
+- Speed of red bubbles
+
+- Density of each bullet curve
+- Angle difference between each bullet in curve
+- Density of blue spiral (how many curves in one spiral)?
+- Delay of blue firing
+- Speed of blue spiral*/
+
+int[] denseBubble = [8, 9, 10];
+int[] delayBubble = [15, 12, 10];
+float[] speedBubble = [8, 9, 9];
+
+int[] denseCurve = [5, 6, 7];
+float[] offsetCurve = [2, 2.4, 4.25];
+int[] denseSpiral = [6, 7, 8];
+int[] delaySpiral = [10, 8, 10];
+int[] speedSpiral = [6, 8, 8];
+
+
+// Includes ahoy
+
+#include "script/KevinSystem/Universal_Lib.txt" // The library to include all libraries :sans: :nail_care:
+
+@Initialize {
+
+	//SetIntersectionVisualization(true);
+	
+	SetAutoDeleteObject(true);
+	
+	difficultySelect = _InitDifficulty(difficultySelect);
+	
+	//difficultySelect = 2; // debug
+	
+	if(!IsCommonDataAreaExists("PIV")){
+	CreateCommonDataArea("PIV");
+	SetAreaCommonData("PIV", "currentvalue", 10000);
+	}
+	else{}
+	
+	// Create the boss object itself
+	bossObj = ObjEnemy_Create(OBJ_ENEMY_BOSS); 
+	ObjEnemy_Regist(bossObj);
+	
+	ObjMove_SetPosition(bossObj, STG_WIDTH/2, -256);
+	ObjEnemy_SetMaximumDamage(bossObj, 999);
+	
+	_RenderBoss(bossObj);
+	
+	mainTask();
+	_FadeInvincibility(bossObj, 150, 150, 1);
+	endingnew();
+}
+
+@Event {
+
+	alternative(GetEventType())
+
+	case(EV_REQUEST_LIFE) {
+		SetScriptResult(3000);
+	}
+	
+	case(EV_REQUEST_TIMER) {
+		SetScriptResult(25);
+	}
+	
+}
+
+@MainLoop {
+
+	playerY = GetPlayerY();
+	playerX = GetPlayerX();
+	//The player position is ALWAYS UPDATED 
+	
+	bossX = ObjMove_GetX(bossObj);
+	bossY = ObjMove_GetY(bossObj);
+	
+	ObjEnemy_SetIntersectionCircleToShot(bossObj, ObjMove_GetX(bossObj), ObjMove_GetY(bossObj), 180);
+	
+	yield;
+	
+}
+
+@Finalize {
+
+}
+
+/*Nonspell 1:
+
+Reference to Remi non 1 from EoSD.
+Remi fires a light spiral of red bubbles while also firing a spiral of blue bullet curves in reverse.
+
+Parameters:
+
+- Density of red bubble spiral
+- Delay between red bubble firing
+- Speed of red bubbles
+
+- Density of each bullet curve
+- Angle difference between each bullet in curve
+- Density of blue spiral (how many curves in one spiral)?
+- Delay of blue firing
+- Speed of blue spiral
+
+*/
+
+task mainTask {
+	
+	MoveToPosition();
+	FireBubble();
+	FireSpiral();
+	
+}
+
+function <void> MoveToPosition(){
+
+	ObjMove_SetDestAtFrame(bossObj, STG_WIDTH/2, STG_HEIGHT/6+30, 90, LERP_DECELERATE);
+	wait(90);
+
+}
+
+task FireBubble(){
+
+	float ang = GetAngleToPlayer(bossObj);
+	int multiplier = 1;
+	
+	if(difficultySelect < 1){
+		while(!ObjEnemy_GetInfo(bossObj, INFO_LIFE) <= 0){
+			
+			loop(8){
+			ascent(i in 0..denseBubble[difficultySelect]){
+				int shot = CreateShotA1(bossX, bossY, speedBubble[difficultySelect], ang + 360/(denseBubble[difficultySelect])*i, KEV_BUBBLE_RED, 0);
+				if(ObjEnemy_GetInfo(bossObj, INFO_LIFE) == 0){Obj_Delete(shot);}
+				else{
+					_Delay(shot, 10);
+					_BulletRescale(shot, 0.65, true, 1);
+					Shoot2;
+				}
+			}
+			
+			wait(delayBubble[difficultySelect]);
+			
+			ang += (360/(denseBubble[difficultySelect]))/3;
+			}
+			
+			ang = GetAngleToPlayer(bossObj);
+			
+		}
+	}
+	
+	else{
+		while(!ObjEnemy_GetInfo(bossObj, INFO_LIFE) <= 0){
+		
+			loop(8){
+				ascent(i in 0..denseBubble[difficultySelect]){
+					int shot = CreateShotA1(bossX, bossY, speedBubble[difficultySelect], ang + 360/(denseBubble[difficultySelect])*i, KEV_BUBBLE_RED, 0);
+					if(ObjEnemy_GetInfo(bossObj, INFO_LIFE) == 0){Obj_Delete(shot);}
+					else{
+						_Delay(shot, 10);
+						_BulletRescale(shot, 0.65, true, 1);
+						Shoot2;
+					}
+				}
+				
+				wait(delayBubble[difficultySelect]);
+				
+				ang += (360/(denseBubble[difficultySelect]))/3*multiplier;
+			}
+				
+			ang = GetAngleToPlayer(bossObj);
+			multiplier *= -1;
+		
+		}
+	}
+	
+}
+
+task FireSpiral(){
+
+	float startAng = 0;
+	float startAngWhole = 0;
+	int multiplier = 1;
+	
+	while(!ObjEnemy_GetInfo(bossObj, INFO_LIFE) <= 0){
+		
+		startAngWhole = GetAngleToPlayer(bossObj);
+		startAng = startAngWhole;
+		
+		loop(5){
+		
+			ascent(i in 0..denseCurve[difficultySelect]){
+			
+				startAng -= offsetCurve[difficultySelect]*multiplier;
+				
+				ascent(j in -1..denseSpiral[difficultySelect]){
+					
+					float ang = startAng + (360/denseSpiral[difficultySelect])*j;
+					int bullet = CreateShotA1(bossX, bossY, speedSpiral[difficultySelect], ang, KEV_BALL_AQUA, 5);
+					if(ObjEnemy_GetInfo(bossObj, INFO_LIFE) <= 0){Obj_Delete(bullet);}
+					else{
+						_Delay(bullet, 5);
+						_BulletRescale(bullet, 0.6, true, 1);
+						Obj_SetRenderPriorityI(bullet, 51);
+						ObjRender_SetBlendType(bullet, BLEND_ALPHA);	
+					}
+					
+				}
+				
+				//Shoot2;
+				wait(2);
+				
+			}
+			
+			startAng -= (360/(denseSpiral[difficultySelect]))/2;
+			
+			wait(delaySpiral[difficultySelect]);
+			if(difficultySelect >= 1){multiplier *= -1;} else {} // Special behaviour for Hyper/Unparalleled
+		
+		}
+		
+	}
+	
+}	
+
+task endingnew(){
+	
+	while(ObjEnemy_GetInfo(bossObj, INFO_LIFE)>0){
+		yield;
+	}
+	
+	_GoToBrazil(objScene, bossObj, 12, 24);
+	wait(120);
+	ObjSound_SetVolumeRate(fire2, 20);
+	
+	CloseScript(GetOwnScriptID);
+	
+}
+
+

script/game/Stage_Background.dnh

@@ -0,0 +1,110 @@
+let bossBG = "script/game/resourceLib/BGFight.png"; 
+let soundWarn = ObjSound_Create();
+let alphaMax = 255*((GetAreaCommonData("Config", "BGOpacity", 100))/100);
+let exVol = GetAreaCommonData("Config", "SEVol", 100) * 0.01;
+
+//ObjSound_Load(sound, "script/game/resourceLib/dialogueblip.wav");
+ObjSound_Load(soundWarn, "script/game/resourceLib/warnSound.wav");
+//ObjSound_SetVolumeRate(sound, 100 * blipVol);
+ObjSound_SetVolumeRate(soundWarn, 100 * blipVol);
+//ObjSound_SetSoundDivision(sound, SOUND_SE);
+ObjSound_SetSoundDivision(soundWarn, SOUND_SE);
+
+//LoadSound("script/game/StageLib/dialogueblip.wav");
+
+LoadTextureEx(bossBG, true, true);
+
+function <void> _ScrollBackground(){
+	
+	int BossImg = _Create2DImage(bossBG, [0, 0, 910, 1200]);
+	ObjRender_SetPosition(BossImg, STG_WIDTH/2, STG_HEIGHT/2, 0);
+	Obj_SetRenderPriorityI(BossImg, 24);
+	
+	float scrollSpeed = 0;
+	float maxscrollSpeed = 14;
+	int curScroll = 0;
+	
+	async{
+		loop{
+			maxscrollSpeed = 9+GetCommonData("Rank", 1)*1.25;
+			wait(60);
+		}
+	}
+	
+	async{
+
+		loop{
+		
+			//ObjSprite2D_SetDestRect(BossImg, 0, 0, STG_WIDTH/2, STG_HEIGHT/2);
+			ObjSprite2D_SetSourceRect(BossImg, 0, curScroll, 910, curScroll+GetStgFrameHeight());
+			curScroll -= scrollSpeed;
+			
+			scrollSpeed = min(maxscrollSpeed, scrollSpeed+0.05);
+			yield;
+		
+		}
+		
+	}
+	
+	ascent(i in 0..90){
+		ObjRender_SetAlpha(BossImg, Interpolate_Decelerate(0, alphaMax, i/90));
+		yield;
+	}
+	
+	Dialogue();
+	//ObjRender_SetAlpha(BossImg, 255*((GetAreaCommonData("Config", "BGOpacity", 100))/100));
+	
+}
+
+function <void> Dialogue(){
+
+	//ObjSound_Play(soundWarn);
+
+	wait(30);
+	
+	int objText3 = CreateTextObject(
+	
+	STG_WIDTH/2, STG_HEIGHT/3-60, 80,
+	" ", "Origami Mommy",
+	0x72CBFF, 0x72CBFF,
+	0x08007C, 10,
+	71
+	
+	);
+	
+	int objText = CreateTextObject(
+	
+	STG_WIDTH/2, STG_HEIGHT/2-60, 36,
+	" ", "Origami Mommy",
+	0x72CBFF, 0x72CBFF,
+	0x08007C, 6,
+	71
+	
+	);
+	
+	int objText2 = CreateTextObject(
+	
+	STG_WIDTH/2, STG_HEIGHT/2, 36,
+	" ", "Origami Mommy",
+	0x72CBFF, 0x72CBFF,
+	0x08007C, 6,
+	71
+	
+	);
+	
+	ObjText_SetHorizontalAlignment(objText, ALIGNMENT_CENTER);
+	ObjText_SetHorizontalAlignment(objText2, ALIGNMENT_CENTER);
+	ObjText_SetHorizontalAlignment(objText3, ALIGNMENT_CENTER);
+	
+	TTextScroll(objText3, "GET READY!");
+	TTextScroll(objText, "IN 99 SECONDS");
+	//wait(60);
+	TTextScroll(objText2, "BECOME THE STRONGEST!");
+	
+	wait(60);
+	
+	Obj_Delete(objText);
+	Obj_Delete(objText2);
+	Obj_Delete(objText3);
+	
+}