;Mgamerz Enhanced Enemies Mod v0.001
;12/17/2016
;Apply to MMBN3 ENGLISH WHITE version only! Apply with ARMIPS:
;armips filename.asm

input	equ	whitevanilla.gba	; Put the name of your ROM here

fspace equ 0x800000; Put the ROM free space offset here

.gba
.open input,output.gba,8000000h

rngaddress EQU 0x080016a2|1b
timestopchipcall EQU 08008E54h
GetPlayer EQU 0x080013E0
RecoveryChipRoutine EQU 0x80ADB04
SpawnObject EQU 0x08003084
;FieldConfiguration EQU 0x
SetPanelTeam EQU 0x0800B7C4
PlaySound EQU 0x080005B8
CalculateAIConstantsAddress EQU 0x080AEDBC
GetPanelType EQU 0x0800B4F2

;Flashman Chips
flashmanchipcount EQU 1h
flashmanChipHookAddress EQU 0x080B6726

gutsmanChipHookAddress EQU 0x080B8592
gutsmanZPunchHookAddress EQU 0x080B84C6
gutsmanChipCount EQU 4h
gutsmanZPunchChipCount EQU 3h
gutsmanMovesBeforeZPunch EQU 6h

teamfamily EQU 3Fh
areafamily EQU 0h
stagefamily EQU 4h
trumpyfamily EQU 26h
sensorfamily EQU 3Eh
grabbackfamily EQU 15h
mpchipfamily EQU 18h
div EQU swi 6


.org 0x08235154 ;Free Space
.area 0xDAC
.align 2

rngRoutine:
	ldr r0, =rngaddress
	bx r0
	pop r15

;setPanelToTeam:
;	ldr r0 =fieldConfiguration

;callTimestopChipWithoutTimestop:
	;requires routine and parameters.


	;healSelf:
	;r0 = how much to heal
	;r5 = who to heal
	;bl RecoveryChipRoutine

;===========================FLASH MAN==========================
armRaiseMove:
	;Hijack at 080D7A66
	push r1-r3,r5,r6
	push r14
	;b performBulbSpawn
	push r0
	ldrh r0, [r5,24h] ;GetHP
	ldr r4, =12Ch
	cmp r0,r4
	pop r0
	bgt notInRecoveryThreshold

	inRecoveryThreshold:
		ldr r0, =0x7D ;how much HP to heal at level 0 (125)
		ldr r4, [r5,4h] ;get level
		add r4, r4, 1h ; prevents *0
		mul r0, r4 ;multiply how much HP to heal
		bl RecoveryChipRoutine
		mov r1, 0h ;0 = Navi Pixelated Summon
		strb r1, [r5, 0xC]
		mov r1, 1h	;Give Flashman another chip to use as he may run out.
		strb r1, [r5,0x1A] ;0xA offset is how many chips an AI have to use, but r5 is incremented by 4 here for some reason.
		pop r1
		pop r1-r3,r5,r6; including get rid of return address, we will set our own to resume control

		ldr r0, =080D7A84h|1b
		bx r0 ;ignore post spawn

	notInRecoveryThreshold:
		
		push r1-r3
		bl rngRoutine ;GET RNG result AND PUT INTO r0
		mov r1, 02h ;remainder 0 = steal, anything else = bulbs
		swi 6; Divide, remainder is in r1
		mov r0, 0h
		cmp r0, r1
		pop r1
		pop r2
		pop r3
		bne performBulbSpawn
		stealPanels:
			;position is on the stack it seems...?
			;Make the areagrab noise since it won't automatically
			mov r0, 0x78
			bl PlaySound
			mov r0, 9h
			b armRaiseFinish
			pop r1-r3,r5,r6
			ldr r0, =080D7A84h|1b
			bx r0 ;ignore post spawn

		performBulbSpawn:
			mov r0, 11h

		armRaiseFinish:
			bl SpawnObject
			pop r15 ;finish

snakeTrace:
	push r14
	bl GetPlayer ;load X,Y into r0 r1
	;r0 - Player Current X
	;r1 - Player Current Y
	push r1
	push r3 ;temporary variable
	ldr r1, [sp,0xC] ;next X pos of bulb
	add r1, r1, 1h
	cmp r0, r1 ;compare next X+1 (same) vs Megaman's X
	ldrb r2,[r5,13h] ; highjacks at 080D7688 ;Current Y position
	bne snakeTraceNotLinedUp ;exit if numbers aren't the same
	snakeTraceLinedUp:
		pop r3
		pop r0 ;Player Y
		cmp r2, r0 ;compare Y coordinates. also used by the routine we return to
		bne snakeTraceDifferentYs
		b snakeTraceLinedUpExit ;same Ys.

		snakeTraceDifferentYs:
			str r1, [sp,0x4] ;store same X if our current Y is not the same as the player Y (hit and leave field)

		snakeTraceLinedUpExit:
			pop r15

	snakeTraceNotLinedUp:
		pop r3
		mov r1, 1h
		cmp r1, 1h ;force same y
		pop r1
		;mov r2, 1h
		;cmp r2, 2h ;Same Y
		pop r15
	

loadFlashmanRandomChip:
	push r14
	bl rngRoutine ;GET RNG result AND PUT INTO r0
	mov r1, flashmanchipcount ;number of chips in selection list
	swi 6; Divide
	ldr r0,=@@flashmanChipLookupTable ;Load address of chip lookup table (defined below)
	mov r2,0x03 ; Load r2 with 3
	mul r1,r2 ;Multiply the remainder result by the size of the structs (3 bytes) - this will provide an offset into the chip lookup table
	add r0,r0,r1 ;calculate the address using the offset, store in r0
	ldrb r3, [r0,0x02] ;load byte from *r0 (offset 2 forward) into r3 (dmg)
	ldrb r1, [r0,0x01] ;load byte from *r0 (offset 1 forward) into r1 (sublevel) 
	ldrb r0, [r0,0x00] ;load byte from *r0 (direct addr) into r0 (family)
	ldrb r2,[r5,16h] ; ...this is actually the object's alliance enemy/allied
	pop r15

.pool
@@flashmanChipLookupTable:
;.byte teamfamily, 1h, 0h
.byte areafamily, 0h, 10h
;.byte stagefamily, 4h, 0h
;.byte trumpyfamily, 2h, 0h

;Flashman zap throwdown
.align 4
flashmanThrowdownAction:
	push r1,r2,r5,r6
	push r14
	bl rngRoutine ;GET RNG result AND PUT INTO r0
	mov r1, 0x3 ;number of available actions
	swi 6; Divide
	ldr r0,=flashmanThrowdownLookupTable ;Load address of actions
	add r0,r0,r1 ;calculate the address using the offset, store in r0
	ldrb r1, [r0, 1h] ;sound check
	ldrb r0, [r0] ;action
	tst r1, r1
	bne playThrowdownSFX
	b finishFlashmanThrowdown
	playThrowdownSFX:
		push r0
		mov r0, r1
		bl PlaySound
		pop r0

	finishFlashmanThrowdown:
		pop r15

.pool
flashmanThrowdownLookupTable:
.byte 0x35, 0x00 ;Mine
.byte 0x3A, 0x9D ;YoYo
.byte 0x10, 0x00 ;ZapAttack

;-----------------------------GUTS MAN----------------------

;This block is unused right now due to spam issues
;loadGutsmanRandomChip:
;push r14
;bl rngRoutine
;mov r1, gutsmanchipcount
;swi 6; Divide
;ldr r0,=@@gutsmanChipLookupTable ;Load address of chip lookup table (defined below)
;mov r2,0x03 ; Load r2 with 3
;mul r1,r2 ;Multiple the remainder result by the size of the structs (3 bytes) - this will provide ;an offset into the chip lookup table
;add r0,r0,r1 ;calculate the address using the offset, store in r0
;ldrb r3, [r0,0x02] ;load byte from *r0 (offset 2 forward) into r3 (dmg)
;ldrb r1, [r0,0x01] ;load byte from *r0 (offset 1 forward) into r1 (sublevel) 
;ldrb r0, [r0,0x00] ;load byte from *r0 (direct addr) into r0 (family)
;ldrb r2,[r5,16h] ; ...this is actually the object's alliance enemy/allied
;pop r15


;.pool
;@@gutsmanChipLookupTable:
;.byte teamfamily, 0h, 0h
;.byte areafamily, 1h, 10h
;.byte stagefamily, 4h, 0h
;.byte trumpyfamily, 1h, 0h
;.align 4
loadZPunchRandomChip:
	.align 2
	push r14
	bl rngRoutine
	mov r1, gutsmanZPunchChipCount
	swi 6; Divide
	ldr r0,=@@gutsmanZPunchLookupTable ;Load address of chip lookup table (defined below)
	mov r2,0x03 ; Load r2 with 3
	mul r1,r2 ;Multiple the remainder result by the size of the structs (3 bytes) - this will provide an offset into the chip lookup table
	add r0,r0,r1 ;calculate the address using the offset, store in r0
	ldrb r3, [r0,0x02] ;load byte from *r0 (offset 2 forward) into r3 (dmg)
	ldrb r1, [r0,0x01] ;load byte from *r0 (offset 1 forward) into r1 (sublevel) 
	ldrb r0, [r0,0x00] ;load byte from *r0 (direct addr) into r0 (family;)
	ldrb r2,[r5,16h] ; ...this is actually the object's alliance enemy/allied
	pop r15

.pool
@@gutsmanZPunchLookupTable:
;.byte teamfamily, 0h, 0h
;.byte areafamily, 1h, 10h
;.byte stagefamily, 4h, 0h
.byte trumpyfamily, 2h, 0h
.byte sensorfamily, 2h, 100h
.byte mpchipfamily, 2h, 0h

;=================GRAB REVENGE===========
.align 2
grabRevengeResetBoard:
	push r14
	//Read what team called this chip 00 = Player 04 = Enemy. This conveniently also means the return value can be used as an offset to the list of timer pointers
	ldrb r0, [r5,6h]
	//lsr r2, r2, 2h //Divide by 4 - 1 is enemy 0 is us
	//mul r1, r2, 4h ;0x4 = no offset, 1x4 = 2nd offset (enemy team offset in the pool)
	ldr r1, =GrabRevengeMemoryTimerPointer
	//ldr r1, [r1] //Load pointer to first item in pool
	add r0, r1, r0 //get offset in the pool below
	ldr r0, [r0] //load the value into 40 from there
	mov r1, 5h ;timer value to set, will be incremented by 15 frames every time to create a nice 
	push r2,r3
	mov r2, 0h
	mov r3, 2h ;0-2 columns
	
	returnColumnsInCascade:
		strh r1, [r0] ;Set the current timer of panels to 5 frames. After those 5 frames the panels will return
		add r0, r0, 4h ;Go to next position for next row.
		push r0
		mov r0, 20h
		add r1, r1, r0
		pop r0
		//add r1, r1, 7h;Add 14 frames for cascade
		//add r1, r1, 7h;Add 14 frames for cascade
		add r2, r2, 1h ;Update counter
		cmp r2,r3
		ble returnColumnsInCascade


	pop r2,r3
	mov r0, 5h ;original code
	mov r1, 4h ;original code
	pop r15

.pool
GrabRevengeMemoryTimerPointer:
.dw 0200F7A4h ;Panels that the enemy stole from you will reset
.dw 0200F7B0h ;Panels that the player stole from the other team will reset

//=========================FLAME MAN======================================
flamemanNextCandleStateRandom: //return next state on r0.
	push r14
	push r2
	push r3
	strb r0, [r5,6h]
	bl rngRoutine
	mov r1, 4h //Number of candle states
	div //r1 = remainder
	mov r0, r1
	pop r3
	pop r2
	pop r15

flamemanYellowGuyChangeToHorizontalOnSameRowAsPlayer:
	push r14
	push r0-r2
	bl GetPlayer ;r0 = X, r1 = Y
	mov r3, r1 //Put player Y in r3
	pop r0-r2
	ldr r1,[r5,44h]
	tst r1,r1
	pop r15

flamemanYellowGuyChangeToVerticalOnSameColumnAsPlayer:
	push r14
	push r0-r2
	bl GetPlayer ;r0 = X, r1 = Y
	mov r3, r0 //Put player X in r3
	pop r0-r2
	ldr r1,[r5,40h]
	tst r1,r1
	pop r15

flamemanLevelUpCandleExtinguished:
	push r14
	push r1,r2
	ldrb r0, [r5,0Ch] //Read state that is being extinguished
	//Check if it is 0x4 (Level Up)
	cmp r0, 8h //8 as its left shifted by 1.
	bne @@flamemanCandleExtinguishedFinish

	//We are extinguishing a level up flame
	ldr r0,[r5,4Ch] //Get Pointer To Parent
	ldrb r2, [r0,4h] //Get current level
	sub r2, 1h
	strb r2,[r0,4h] //Store level -1
	bl flamemanUpdateAIConstantsAddress

	@@flamemanCandleExtinguishedFinish:
		pop r1,r2
		mov r0, 0h //Original Code
		strb r0,[r5,0Ch] //Original Code
		pop r15

flamemanLevelUpCandleActivating:
	push r1,r2,r14
	ldrh r0, [r5,20h] //Read activation timer
	cmp r0, 0h
	bne @@flamemanEndCandleActivation
	add r0, 1h
	strh r0, [r5,20h] //Set candle timer to 1 (it doesn't count down while active) to indicate this effect has already been applied
	ldrh r0, [r5,24h] //Get HP
	lsl r0, r0, 0x2 //Quadruple HP
	strh r0, [r5,24h]
	//strh r0, [r5,26h]
	ldr r0,[r5,4Ch] //Get Pointer To Parent
	ldrb r2, [r0,4h] //Get current level
	add r2, 1h
	strb r2,[r0,4h] //Store level +1
	bl flamemanUpdateAIConstantsAddress	//R0 = FlamemanPointer, R2 = Level
	@@flamemanEndCandleActivation:
	pop r1,r2,r15

.align 4
flamemanCustomCandleActivationArray:
	.word 0x080E2CC9 //Green Empty Function
	.word 0x080E2CCD //Red Empty Function
	.word 0x080E2CD1 //Yellow Empty Function
	//NEW ONE HERE //NEW Level Up Startup Function
	.word flamemanLevelUpCandleActivating|1b

flamemanUpdateAIConstantsAddress:
	push r14
	push r5 //This operation requires r5 to point to flameman memory
	mov r5, r0 //Update R5 with the one referenced by the candle parent
	ldr r0, =flamemanNewAIData ;Flameman AI Base
	mov r1, 0Ah ;Flameman's data is 0xA bytes wide per level
	bl CalculateAIConstantsAddress
	pop r5
	pop r15

	.pool
	//Flameman New AI Data
	flamemanNewAIData:
	//      0    1    2    3    4    5    6    7    8    9 
	.byte 0x3C,0x3C,0x3C,0x1E,0x2D,0x08,0xA4,0x0A,0x10,0x78 //Normal
	.byte 0x64,0x50,0x50,0x19,0x28,0x0C,0x90,0x09,0x18,0x64 //Alpha
	.byte 0x96,0x96,0x96,0x14,0x23,0x15,0x70,0x08,0x20,0x50 //Beta
	.byte 0xC8,0xC8,0xC8,0x0F,0x1E,0x20,0x58,0x06,0x20,0x3C //Omega
	.byte 0xE1,0xE1,0xE1,0x0A,0x0F,0x25,0x44,0x03,0x28,0x28 //Omega + 1
	.byte 0xFA,0xFA,0xFA,0x05,0x0A,0x28,0x40,0x01,0x30,0x16 //Omega + 2

	//Candle info
	//[02038A74]=CURRENT SELF POINTER
	//[02038AC0]=PARENT POINTER
	//r5+4C = Parent Pointer

flamemanAdditionalAttacksWithLevelUpCandleCheck:
	push r0-r2,r14
	mov r0, #0x0 //init bitmask

	//Check Candle 1
	ldr r1, [r5,#0x60]
	tst r1,r1 //Candle 1 is not null check
	beq @@CheckCandle2
	ldrb r2, [r1,#0xC]
	orr r0, r2 //add effect to bitmask

	//Check Candle 2
	@@CheckCandle2:
	ldr r1, [r5,#0x64]
	tst r1,r1 //Candle 2 is not null check
	beq @@candleEffectCheck
	ldrb r2, [r1,#0xC]
	orr r0, r2

	@@candleEffectCheck:
	//8 = Leveled Up
	mov r1, 8h
	and r0, r1
	tst r0, r0
	beq @@flamemanLaunchStandardFlameAttack

	//Different Flame Attack
	@@flamemanLaunchDifferentFlameAttack:
		bl rngRoutine ;GET RNG result AND PUT INTO r0
		mov r1, 0x4
		swi 6
		tst r1,r1
		bne @@flamemanLaunchModifiedFlameAttack
		@@flamemanSpawnFireRatn:
			//Check if square we are going to spawn in is occupied by something. If it is, we shouldn't spawn a ratton
			pop r0-r2
			push r0-r2 //we might still need these...
			mov r0, r1
			mov r1, r2 //move positions to correct registers
			bl GetPanelType
			mov r1, 0xE
			lsl r1, r1, 0x18 //Occupied mask
			//mov r1, 0x10 //broken panel mask
			//orr r0, r1 //also check if panel is broken
			tst r0, r1
			bne @@flamemanLaunchModifiedFlameAttack //it is occupied

			//Spawn Ratton
			pop r0-r2 //Discard
			mov r0, 0xC8 //HP of Object
			mov r3, 1h //Enemy Team
			mov r4, 0h //Memory Space that will be assigned to this object on spawn (by spawnobject)
			mov r6, 0xE6 //230 Damage
			bl 0x080DA218 ;SpawnRatton
			pop r15

		@@flamemanLaunchModifiedFlameAttack:
			//Recover a small amount of HP
			push r4
			ldr r0, =0xA ;how much HP to heal at level 0 (125)
			ldrb r4, [r5,4h] ;get level
			add r4, r4, 1h ; prevents *0
			mul r0, r4 ;multiply how much HP to heal
			bl RecoveryChipRoutine
			pop r4
			mov r0, 30h
			lsl r1, r1, 18h
			orr r4, r1
		@@flamemanLaunchStandardFlameAttack:
			pop r0-r2
			bl 0x080E317E ;FlamemanSpawnInitialFlameTower
			pop r15

.align 4
.pool 
@@FlamemanCustomFlameAttackPattern:
.word 0x06280C00 //Straight Flame
.word 0x02241401 //WideFlame
.word 0x32241401 //WideFlame, goes 3 rows deep (at least)
.word 0x02241400

.endarea
;==================HOOKS================
.org 0x080E2F84 //ldr r1,[r5,44h]
flamemanYellowGuyYHook:
	bl flamemanYellowGuyChangeToHorizontalOnSameRowAsPlayer

.org 0x080E2F2A //ldr r1,[r5,40h]
flamemanYellowGuyXHook:
	bl flamemanYellowGuyChangeToVerticalOnSameColumnAsPlayer

.org 0x080E2D46 //strb r0,[r5,6h]
flamemanRandomCandleStateHook:
	push r14
	nop
	bl flamemanNextCandleStateRandom
	pop r15

.org 0x080E2C10 //mov r0, 0h
flamemanCandleExtinguishLevelUpHook:
	bl flamemanLevelUpCandleExtinguished

.org 0x080C57C0 //bl FlameManSpawnInitialTower
	bl flamemanAdditionalAttacksWithLevelUpCandleCheck

.org 0x080F9E9E 
grabRevengeResetBoardHook:
	bl grabRevengeResetBoard

.org flashmanChipHookAddress
flashmanChipHook:
	bl loadFlashmanRandomChip
	nop

.org 0x080D7A66 ;Flashman Bulb Spawn (Arm Raise Move to heal)
flashmanArmRaiseMoveHook:
	bl armRaiseMove
	nop
	nop

.org 0x080D7664 ;In the Follow Trace Y calculation area (will only affect follow and not zigzag tracer)
snakeTraceHook:
	bl snakeTrace
	nop
	nop

.org 0x080D7850 ;Flashman zap throwdown
flashmanThrowdownHook:
	bl flashmanThrowdownAction

;.org gutsmanChipHookAddress
;gutsmanAreaGrabChipHook:
;bl loadGutsmanRandomChip
;nop

.org gutsmanZPunchHookAddress
	bl loadZPunchRandomChip ;Hook z-punch chip and use my routine instead
	;nop

;=================PATCHES===============

;--------------HP SPEED PATCH---------------------
;Makes HP display change faster than default (which is 2)
.org 0x08010E22
	mov r0, 4h

;------------FLAME MAN PATCHES----------
.org 0x080C53EC
	mov r1, 5h ;Candle 1 at X=5 rather than X=6

.org 0x080C5406
	mov r1, 5h ;Candle 2 at X=5 rather than X=6

.org 0x080E2F98
	cmp r0, r3 ;YellowGuyY will now go left on same row rather than 3

.org 0x080E2F40
	cmp r0, r3 ;YellowGuyX will now go down on same row rather than 3

.org 0x080E2CB8
	.word flamemanCustomCandleActivationArray ;Rewrite the activation array pointer to my own so the level up function can activate (and avoid crash)

.org 0x080C5440
	.word flamemanNewAIData ;Repoint AI data to my own so we have omega +2 levels

.org 0x080C5916
	.byte 7h ;Allow flameman to attack from back row 

.org 0x080C5424
	//Patch out Flameman's Off-Limits 6,2 position.
	nop
	nop
	nop
	nop

.org 0x080C566A 
	//Patch out FlameMan's additional off-limits 6,2 check
	nop
	nop

.org 0x080E30B8
	//Patch out flames despawning on holes
	nop
	nop

.org 0x080C559A
	cmp r0, #0x6 //Flameman 6 moves in upper half HP instead of 8

.org 0x080C55B8
	cmp r0, #0x3 //Flameman 3 moves in lower half of HP instead of 5

;--------------Flashman Patches---------

;--------------GUTSMAN PATCHES----------
;.org 0x080B7DF0 ;gutsmans sets move counter here to 0xFF so Z-Punch attack no longer comes up
;mov r0, #0x0 ;reset to 0 instead so he can use it again. this is the amount of moves he has done.

;.org 0x080b7de8 ;gutsmans checks if his move count is same as this in order to activate Z-Punch
;cmp r0, gutsmanMovesBeforeZPunch

;.org 0x080b7dcc ;gutsman checks this value and if his hp is less he can use zpunch. by default it is division by 2 by shifting to the right by 1.
;add r1, r1, 1 ;add 1 HP so its one over the max. Can use zpunch anytime now

.org 0x080b8590 ;gutsmans areagrab response chip
mov r0, grabbackfamily
mov r1, 0x1 ;grabrevenge sublevel
ldrb r2,[r5,#0x16]
mov r3,#0x32 ;50 damage per hit

;-.org 0x080ae6a4 ;gutsman beta AI - delay after shockwave
;-.byte 0x64 ;contact damage

.org 0x08019b68 ;flashman beta HP
.byte 0xe8
.byte 0x03 ;1000 HP 0x03e8

.close
 ; eof