[Function saveCall(characterId, nerfValue)]
#some yandev tier coding here
if $characterId = 1
{
	SaveFile{savedata: $nerfValue; path:  "kfm.gob"}
	SaveFile{savedata: $nerfValue; path:  "../../data/backup/kfm.gob"}
}
else
{
	#do nothing
}

[Function loadCall(characterId) nerfValue]
let nerfValue = 0;
#some yandev tier coding here
if $characterId = 1
{
	LoadFile{savedata: $nerfValue; path:	"kfm.gob"}
}
else
{
	#do nothing
}

[Function CheckForNerf(nerfValueMapInitial, temp) nerfValue]
let nerfValue = 0;

#if the Characters attack is below %20 of it's original at all
if $nerfValueMapInitial < 0.20
{
	#in case if it's below
	let nerfValue = 0.20;
}
else
{
	if $temp <= Round($temp * 0.2,0)
	{
		#consider it a close match
	}
		#Character is above 20% of Said life, but lesser than 40%
	if $temp >= Round($temp * 0.2,0) && $temp <= Round($temp * 0.4,0)
	{
		let nerfValue = 0.95;
	}
	#Character is above 40% of Said life, but lesser than 60%
	else if $temp >= Round($temp * 0.4,0) && $temp <= Round($temp * 0.6,0)
	{
		let nerfValue = 0.90;
	}
	#Character is above 60% of Said life, but lesser than 80%
	else if $temp >= Round($temp * 0.6,0) && $temp <= Round($temp * 0.8,0)
	{
		let nerfValue = 0.85;
	}
	#Character is above 80% of Said life
	else if $temp >= Round($temp * 0.8,0)
	{
		let nerfValue = 0.80;
	}
}


#Rank code adopted from Shiyo Kakuge's add004
#===============================================================================
#Global states (not halted by Pause/SuperPause, no helper limitations)
#===============================================================================
[Statedef -4]
#[map]
# characterIdInitial = 1
if RoundState = 0 && RoundNo = 1
{
	let characterId = map(characterIdInitial);
	let nerfValue = 1;	#call loadCall($characterId)
	PrintToConsole{text: "$nerfValue is %d"; params: $nerfValue}
	MapSet{map: "nerfValueMap"; value: $nerfValue}
}
if RoundState = 0
{
	
	let nerfValue = call loadCall($characterId);
	MapSet{map: "nerfValueMap"; value: $nerfValue}
}


if !Const(Default.Enable.Rank) || TeamSide = 0 {
	#do nothing, global code disabled locally or executed by stage
} else if IsHelper {
	# parry detection
	ignorehitpause if HelperName = "Parry Detection" && MoveHit = 1 {
		MapSet{map: "_iksys_rankParryStateNo"; value: root,StateNo; redirectid: root,ID}
	}
} else if RoundState = 0 {
	MapSet{map: "_iksys_rankParryStateNo"; value: 0}
	MapSet{map: "_iksys_rankLifeFlag"; value: 0}
	MapSet{map: "_iksys_rankHitOverriddenStateNo"; value: 0}
	MapSet{map: "_iksys_rankFirstAttackFlag"; value: 0}
	MapSet{map: "_iksys_rankComboCount"; value: 0}
	MapSet{map: "_iksys_rankWinFlag"; value: 0}
} else ignorehitpause if RoundState > 0 {
	# life (v_Tech_Life)
	if Win && Alive && Map(_iksys_rankLifeFlag) = 0 {
		RankAdd{value: float(Life) / LifeMax / (NumPartner + 1) * 30; type: "life"; max: 30}
		MapSet{map: "_iksys_rankLifeFlag"; value: 1}
	}
	# enemy in GetHit or Dizzy states (v_Tech_Attack)
	if StateNo = Const(StateStandGetHit_shaking) || StateNo = Const(StateCrouchGetHit_shaking) || StateNo = Const(StateAirGetHit_shaking) || StateNo = Const(StateTrippedGetHit_shaking) || GetHitVar(isbound) || Dizzy {
		RankAdd{value: 0.05 / (enemy,NumPartner + 1); type: "attack"; max: 36; redirectid: enemy,ID}
	}
	# blocking states or parry (v_Tech_Guard)
	if HitOverridden {
		MapSet{map: "_iksys_rankHitOverriddenStateNo"; value: StateNo}
	} else if Map(_iksys_rankHitOverriddenStateNo) > 0 && Map(_iksys_rankHitOverriddenStateNo) != StateNo {
		MapSet{map: "_iksys_rankHitOverriddenStateNo"; value: 0}
	}
	if StateNo = [Const(StateGuard_start), Const(StateAirGuardHit_knockedAway)] || Map(_iksys_rankHitOverriddenStateNo) > 0 || Map(_iksys_rankParryStateNo) > 0 {
		RankAdd{value: 0.05 / (enemy,NumPartner + 1); type: "guard"; max: 31}
	}
	# parry (v_Tech_Parry)
	if Map(_iksys_rankHitOverriddenStateNo) > 0 || Map(_iksys_rankParryStateNo) > 0 {
		RankAdd{value: 0.001 / (enemy,NumPartner + 1); type: "tech"; max: 38}
	}
	if Map(_iksys_rankParryStateNo) > 0 && Map(_iksys_rankParryStateNo) != StateNo {
		MapSet{map: "_iksys_rankParryStateNo"; value: 0}
	}
	# no guard (v_Tech_NoGuard)
	if InGuardDist && StateNo = [Const(StateWalk), Const(StateGuard_start) - 1] {
	  RankAdd{value: 0.00001 / (enemy,NumPartner + 1); type: "tech"; max: 38}
	}
	# first attack (is_First_Attack)
	if FirstAttack && Map(_iksys_rankFirstAttackFlag) = 0 {
		RankAdd{value: 5; type: "tech"; max: 38; icon: "fa"}
		MapSet{map: "_iksys_rankFirstAttackFlag"; value: 1}
	}
	# code executed only by P1 and P2
	if PlayerNo = TeamSide {
		# max combo (v_Tech_MaxCombo)
		if min(25, ComboCount) > Map(_iksys_rankComboCount) {
			RankAdd{value: ComboCount - Map(_iksys_rankComboCount); type: "tech"; max: 38}
			MapSet{map: "_iksys_rankComboCount"; value: ComboCount}
		}
		# win type (bonus_tech)
		if Win && Map(_iksys_rankWinFlag) = 0 {
			if WinPerfect { #is_Perfect
				RankAdd{value: 15; type: "tech"; max: 38; icon: "p"}
			}
			if WinHyper { #is_Hyper_Finish
				RankAdd{value: 20; type: "tech"; max: 38; icon: "hf"}
			} else if WinSpecial { #is_Special_Finish
				RankAdd{value: 10; type: "tech"; max: 38; icon: "sf"}
			}
			MapSet{map: "_iksys_rankWinFlag"; value: 1}
			MapSet{map: "temp"; value: life}
			let temp = map(temp);
			PrintToConsole{text: "Win $temp is %f"; params: $temp}
			let nerfValue = call CheckForNerf($nerfValue, $temp);
			MapSet{map: "nerfValueMap"; value: $nerfValue}
			call saveCall($characterId, $nerfValue);
			
		}
		if lose && Map(_iksys_rankWinFlag) = 0
		{
			MapSet{map: "_iksys_rankWinFlag"; value: 1}
			MapSet{map: "temp"; value: enemy,life}
			let temp = map(temp);
			#PrintToConsole{text: "Lose $temp is %f"; params: $temp}
			let nerfValue = call CheckForNerf($nerfValue, $temp);
			let buffValue = 1 - $nerfValue;
			MapSet{map: "buffValueMap"; value: $buffValue}
			PrintToConsole{text: "$buffValue is %f"; params: map(buffValueMap)}
			#call saveCall($characterId, $nerfValue);
		}
	}
}