//--------------------------------------------------------------//
// Homunculus Status Calculator                                 //
// File:hom.js                                                  //
// Proc:ホムンクルスステータス計算                              //
//                                            Copyright (c) mk  //
//                                        Last Update:07/07/05  //
//--------------------------------------------------------------//

////////////////////////////////
//          初期処理          //
////////////////////////////////
function init(){
	// セーブリストを作成
	make_savelist()
	// 種族リストを作成
	make_typelist()
	// 初期化
	ListInit();
	// Cookieの読み込み
	CLoad();
	// チェックボックス等表示
	Option_Disp();
	// 初期値配置
	ListSet();
	// 進化スキル表示
	EvoSkill_Disp();
	// 進化スキル表示(成長後)
	EvoSkill_Disp2();
	// 全計算
	Hope_Calc();
}

////////////////////////////////
//          種族変更          //
////////////////////////////////
function type_change(){
	// 種族情報取得
	ListGet_Type();
	// 種族別初期値取得
	Type_Init();
	// チェックボックス等表示
	Option_Disp();
	// 進化スキル表示
	EvoSkill_Disp();
	// 進化スキル表示(成長後)
	EvoSkill_Disp2();
	// パラメータ計算
	Parameter_Calc();
	// 初期値配置
	ListSet();
	// ステータス表示
	Status_Disp();
	// 上昇平均値計算
	Status_Up();
	// 上昇平均値表示
	Status_Up_Disp();
	// 進化スキル表示
	EvoSkill_Disp();
	// 進化スキル表示(成長後)
	EvoSkill_Disp2();
}

////////////////////////////////
//        進化状態変更        //
////////////////////////////////
function evo_change(){
	// 種族情報取得
	ListGet_Type();
	// 進化ボーナス入力欄表示
	EvoBonus_Disp();
	// 進化スキル表示
	EvoSkill_Disp();
}

////////////////////////////////
//        表示言語変更        //
////////////////////////////////
function langage_change(){
	// チェックボックス取得
	Langage = getCheckBox("langage");
	// セーブリストを作成
//	make_savelist()
	// 種族リストを再作成
	make_typelist();

	if (Langage == 0) {
		setValue("submit_1", "ステータス計算");
		setValue("submit_2", "予想ステータス計算");
		dit("l_name", "名前");
		dit("l_level", "レベル");
		dit("l_exp", "経験値");
		dit("skill_name", skill_name[type]);
		dit("skill_name2", skill_name[type]);
		dit("name_2", type_name[type]);
		if (type == 0 || type == 3) {
			setHtml("d_heal", '<FONT STYLE="font-size:10px;line-height:12px"><A HREF="JavaScript:Heal_Disp(0)"><B>'+skill_name3[type]+'</B></A></FONT>');
			setHtml("d_heal_2", '<FONT STYLE="font-size:10px;line-height:12px"><A HREF="JavaScript:Heal_Disp(1)"><B>'+skill_name3[type]+'</B></A></FONT>');
		}
	} else {
		setValue("submit_1", "Calculate Status");
		setValue("submit_2", "Calculate Expectation Status");
		dit("l_name", "Name");
		dit("l_level", "Level");
		dit("l_exp", "Exp.");
		dit("skill_name", skill_name_e[type]);
		dit("skill_name2", skill_name_e[type]);
		dit("name_2", type_name_e[type]);
		dit("atk_p", "~");
		if (type == 0 || type == 3) {
			setHtml("d_heal", '<FONT STYLE="font-size:10px;line-height:12px"><A HREF="JavaScript:Heal_Disp(0)"><B>'+skill_name3_e[type]+'</B></A></FONT>');
			setHtml("d_heal_2", '<FONT STYLE="font-size:10px;line-height:12px"><A HREF="JavaScript:Heal_Disp(1)"><B>'+skill_name3_e[type]+'</B></A></FONT>');
		}
	}
	dit("pp_name", pp_name[Langage]);
	dit("pp_name2", pp_name[Langage]);
}

////////////////////////////////
//    進化状態変更(成長後)    //
////////////////////////////////
function evo_change2(){
	// 種族情報取得
	ListGet_Type();
	// 進化スキル表示(成長後)
	EvoSkill_Disp2();
}

////////////////////////////////
//      進化ボーナス入力      //
////////////////////////////////
function Evo_Bonus(){
	// 進化ボーナス取得
	ListGet_EvoBonus();
	// 全計算
	Hope_Calc();
	// 進化ボーナス入力欄非表示
	offOptionLayer();
}

////////////////////////////////
//       ステータス計算       //
////////////////////////////////
function main(){
	// 種族情報取得
	ListGet_Type();
	// パラメータ取得
	ListGet_Status();
	// 予想ステータス情報取得
	ListGet_Hope();
	// ステータス計算
	Status_Calc();
	// ステータス表示
	Status_Disp();
	// 上昇平均値計算
	Status_Up();
	// 上昇平均値表示
	Status_Up_Disp();
}

////////////////////////////////
//     予想ステータス計算     //
////////////////////////////////
function Hope_Calc(){
	// 種族情報取得
	ListGet_Type();
	// パラメータ取得
	ListGet_Status();
	// 予想ステータス情報取得
	ListGet_Hope();
	// ステータス計算
	Status_Calc();
	// ステータス表示
	Status_Disp();
	// 上昇平均値計算
	Status_Up();
	// 上昇平均値表示
	Status_Up_Disp();
	// 予想ステータス計算
	Hope_Status_Calc();
	// 予想ステータス情報表示
	Hope_Status_Disp();
}

////////////////////////////////
//        データセーブ        //
////////////////////////////////
function DataSave(){
	// 種族情報取得
	ListGet_Type();
	// パラメータ取得
	ListGet_Status();
	// 予想ステータス情報取得
	ListGet_Hope();
	// Cookieの保存
	CSave();
	// セーブリストを再作成
	make_savelist()

	var slot = saveNo + 1;
	if (Langage == 0) {
		Make_Window_Cation("Slot"+slot+" にデータをセーブしました。");
	} else {
		Make_Window_Cation("DataSave : Slot"+slot);
	}

}
////////////////////////////////
//        データロード        //
////////////////////////////////
function DataLoad(){
	// Cookieの読み込み
	CLoad();
	// チェックボックス等表示
	Option_Disp();
	// 初期値配置
	ListSet();
	// 進化スキル表示
	EvoSkill_Disp();
	// 進化スキル表示(成長後)
	EvoSkill_Disp2();
	// 全計算
	Hope_Calc();
	var slot = saveNo + 1;
	if (loadFlg == true){
		if (Langage == 0) {
			Make_Window_Cation("Slot"+slot+" からデータをロードしました。");
		} else {
			Make_Window_Cation("DataLoad : Slot"+slot);
		}
	} else {
		if (Langage == 0) {
			Make_Window_Cation("セーブデータが存在しません。");
		} else {
			Make_Window_Cation("SaveData Not Found");
		}
	}
}
////////////////////////////////
//        データクリア        //
////////////////////////////////
function DataClear(){
	// 種族別初期値取得
	Type_Init();
	// パラメータ計算
	Parameter_Calc();
	// 初期値配置
	ListSet();
	// 進化スキル表示
	EvoSkill_Disp();
	// 進化スキル表示(成長後)
	EvoSkill_Disp2();
	// ステータス表示
	Status_Disp();
	// 上昇平均値計算
	Status_Up();
	// 上昇平均値表示
	Status_Up_Disp();
	// 予想ステータス計算
	Hope_Status_Calc();
	// 予想ステータス情報表示
	Hope_Status_Disp();
}

/////////////////////////// 情報取得 ///////////////////////////
//////////// 種族情報取得 ////////////
function ListGet_Type(){
	// 種族
	type = getIndex("type", 0);
	// 言語
	Langage = getCheckBox("langage");
	// 進化フラグ取得
	evo_flg_1 = getCheckBox("evo_1");
	evo_flg_2 = getCheckBox("evo_2");

}

///////// ステータス情報取得 /////////
function ListGet_Status(){
	// レベル
	level = getIndex("level", 1);
	// atk
	atk_max = getIndex("atk", 1);
	// matk
	matk = getIndex("matk", 1);
	// hit
	hit = getIndex("hit", 1);
	// critical
	cri = getIndex("cri", 1);
	// def
	def = getIndex("def", 1);
	// mdef
	mdef = getIndex("mdef", 1);
	// flee
	flee = getIndex("flee", 1);

	// スキル情報
	ListGet_Skill();

	var form = document.form;
	// hp
	hp = Number(getValue("hp"));
	// sp
	sp = Number(getValue("sp"));

}

/////////// スキル情報取得 ///////////
function ListGet_Skill(){
	// skill
	skill = getIndex("skill", 0);
	// skill_option
	if (type == 3) {
		skill_option1 = getCheckBox("CI_FLG1");
	}
	// evo_skill_1
	if (type == 0 || type == 1) {
		if (evo_flg_1 == 1) {
			evo_skill_1 = getIndex("evo_skill_1", 0);
		} else {
			evo_skill_1 = 0;
		}
	} else {
		evo_skill_1 = 0;
	}
}

////////// 進化ボーナス取得 //////////
function ListGet_EvoBonus(){
	// hp_bonus
	hp_bonus = getIndex("hp_bonus", 0);
	// sp_bonus
	sp_bonus = getIndex("sp_bonus", 0);
	// str_bonus
	str_bonus = getIndex("str_bonus", 0);
	// agi_bonus
	agi_bonus = getIndex("agi_bonus", 0);
	// vit_bonus
	vit_bonus = getIndex("vit_bonus", 0);
	// int_bonus
	int_bonus = getIndex("int_bonus", 0);
	// dex_bonus
	dex_bonus = getIndex("dex_bonus", 0);
	// luk_bonus
	luk_bonus = getIndex("luk_bonus", 0);
}

///////// 予想ステータス情報 /////////
function ListGet_Hope(){
	// レベル
	hope_level = getIndex("hope_level", 1);
	// skill
	hope_skill = getIndex("hope_skill", 0);
	// skill_option(バニルミルトのみ)
	if (type == 3) {
		skill_option2 = getCheckBox("CI_FLG2");
	}
	// evo_skill_2
	if (type == 0 || type == 1) {
		if (evo_flg_2 == 1) {
			evo_skill_2 = getIndex("evo_skill_2", 0);
		} else {
			evo_skill_2 = 0;
		}
	} else {
		evo_skill_2 = 0;
	}

	// 現在レベル未満の場合は現在レベルに変更
	if (level > hope_level) {
		hope_level = level;
		setIndex("hope_level", hope_level, 1);
	}
	if (skill > hope_skill) {
		if (type != 2) {
			hope_skill = skill;
			setIndex("hope_skill", hope_skill, 0);
		}
	}
	if (evo_flg_1 == 1 && evo_flg_2 == 0) {
		// 成長後も進化適用
		evo_flg_2 = evo_flg_1;
		setCheckBox("evo_2", evo_flg_2);
		// 進化スキル表示(成長後)
		EvoSkill_Disp2();
	}

}

//////// 種族別初期値設定 /////////
function Type_Init(){
	// level
	level = 1;
	// str
	str_ = type_status[type][0];
	// agi
	agi_ = type_status[type][1];
	// vit
	vit_ = type_status[type][2];
	// int
	int_ = type_status[type][3];
	// dex
	dex_ = type_status[type][4];
	// luk
	luk_ = type_status[type][5];
	// hp
	hp = type_status[type][6];
	// sp
	sp = type_status[type][7];
	// skill
	skill = 0;
	// skill_option
	skill_option1 = 0;

	// スキルリセット
	str_plus = 0;
	int_plus = 0;
	vit_plus = 0;

	hope_skill = 0;
	skill_option2 = 0;
	str_plus_2 = 0;
	int_plus_2 = 0;
	vit_plus_2 = 0;

	// 進化リセット
	evo_flg_1 = 0;
	evo_flg_2 = 0;
	evo_skill_1 = 0;
	evo_skill_2 = 0;

	// 進化ボーナス
	hp_bonus = 0;
	sp_bonus = 0;
	str_bonus = 0;
	agi_bonus = 0;
	vit_bonus = 0;
	int_bonus = 0;
	dex_bonus = 0;
	luk_bonus = 0;

	// ポーションピッチャー
	lp_lv = 10;
	pp_lv = 5;

}


//////////////////////////// 初期化 ////////////////////////////
function ListInit(){

	// 種族
	type = 0;
	// レベル
	level = 1;
	// 予想レベル
	hope_level = 99;

	// 種族別初期値取得
	Type_Init();

	// パラメータ計算
	Parameter_Calc();

}

/////////// 初期値配置 ////////////
function ListSet(){
	// 種族
	setIndex("type", type, 0);
	// 言語
	if (Langage != disp_lang) {
		// 種族リストを再作成
		make_typelist()
	}
	setCheckBox("langage", Langage);
	// 進化フラグ
	setCheckBox("evo_1", evo_flg_1);
	// レベル
	setIndex("level", level, 1);

	// atk
	if(eval(atk_max) >= eval(atk_min) || (evo_flg_1 == 1 && evo_skill_1 != 0)) {
		setIndex("atk", atk_max, 1);
	} else {
		setIndex("atk", atk_min, 1);
	}
	// matk
	setIndex("matk", matk, 1);
	// hit
	setIndex("hit", hit, 1);
	// critical
	setIndex("cri", cri, 1);
	// def
	setIndex("def", def, 1);
	// mdef
	setIndex("mdef", mdef, 1);
	// flee
	setIndex("flee", flee, 1);

	var form = document.form;
	// hp
	setValue("hp", hp);
	// sp
	setValue("sp", sp);

	// skill
	setIndex("skill", skill, 0);

	// skillname
	// skillname2
	// name_2
	if (Langage == 0) {
		dit("skill_name", skill_name[type]);
		dit("skill_name2", skill_name[type]);
		dit("name_2", type_name[type]);
	} else {
		dit("skill_name", skill_name_e[type]);
		dit("skill_name2", skill_name_e[type]);
		dit("name_2", type_name_e[type]);
	}
	// Potion Pitcher
	dit("pp_name", pp_name[Langage]);
	dit("pp_name2", pp_name[Langage]);

	// hope_level
	setIndex("hope_level", hope_level, 1);
	// 進化フラグ２
	setCheckBox("evo_2", evo_flg_2);

	// skill2
	setIndex("hope_skill", hope_skill, 0);

}

////////////////////////////  表示  ////////////////////////////

/////// チェックボックス等表示 ///////
function Option_Disp(){

	// チェックボックス
	if (type == 3) {
		setHtml("option1", '<INPUT TYPE="checkbox" ID="CI_FLG1">');
		setHtml("option2", '<INPUT TYPE="checkbox" ID="CI_FLG2">');
		setCheckBox("CI_FLG1", skill_option1);
		setCheckBox("CI_FLG2", skill_option2);
	} else {
		setHtml("option1", "");
		setHtml("option2", "");
	}

	// 回復スキル
	if (type == 0 || type == 3) {
		if (Langage == 0) {
			setHtml("d_heal", '<FONT STYLE="font-size:12px;line-height:12px"><A HREF="JavaScript:Heal_Disp(0)"><B>'+skill_name3[type]+'</B></A></FONT>');
			setHtml("d_heal_2", '<FONT STYLE="font-size:12px;line-height:12px"><A HREF="JavaScript:Heal_Disp(1)"><B>'+skill_name3[type]+'</B></A></FONT>');
		} else {
			setHtml("d_heal", '<FONT STYLE="font-size:12px;line-height:12px"><A HREF="JavaScript:Heal_Disp(0)"><B>'+skill_name3_e[type]+'</B></A></FONT>');
			setHtml("d_heal_2", '<FONT STYLE="font-size:12px;line-height:12px"><A HREF="JavaScript:Heal_Disp(1)"><B>'+skill_name3_e[type]+'</B></A></FONT>');
		}
	} else {
		setHtml("d_heal", "");
		setHtml("d_heal_2", "");
	}

}

/////// 進化ボーナス入力欄表示 ///////
function EvoBonus_Disp(){
	if (evo_flg_1 == 1) {
		// ウィンドウ表示
		Make_Window_Evo();
		for(i=0;i<=50;i++) {
			document.getElementById("hp_bonus").options[i] = new Option(i, i);
			document.getElementById("sp_bonus").options[i] = new Option(i, i);
			if (i <= 15) {
				document.getElementById("str_bonus").options[i] = new Option(i, i);
				document.getElementById("agi_bonus").options[i] = new Option(i, i);
				document.getElementById("vit_bonus").options[i] = new Option(i, i);
				document.getElementById("int_bonus").options[i] = new Option(i, i);
				document.getElementById("dex_bonus").options[i] = new Option(i, i);
				document.getElementById("luk_bonus").options[i] = new Option(i, i);
			}
		}
		// 進化ボーナス値表示
		setEvoBonus(hp_bonus, sp_bonus, str_bonus, agi_bonus, vit_bonus, int_bonus, dex_bonus, luk_bonus);
		// 進化ボーナスコード表示
		var c_evocode = Make_EvoCode(hp_bonus, sp_bonus, str_bonus, agi_bonus, vit_bonus, int_bonus, dex_bonus, luk_bonus);
		setValue("evocode", c_evocode);
	} else {
		offOptionLayer();
	}
}

///////// 進化ボーナス値表示 /////////
function setEvoBonus(c_hp_bonus, c_sp_bonus, c_str_bonus, c_agi_bonus, c_vit_bonus, c_int_bonus, c_dex_bonus, c_luk_bonus){
	setIndex("hp_bonus", c_hp_bonus, 0);
	setIndex("sp_bonus", c_sp_bonus, 0);
	setIndex("str_bonus", c_str_bonus, 0);
	setIndex("agi_bonus", c_agi_bonus, 0);
	setIndex("vit_bonus", c_vit_bonus, 0);
	setIndex("int_bonus", c_int_bonus, 0);
	setIndex("dex_bonus", c_dex_bonus, 0);
	setIndex("luk_bonus", c_luk_bonus, 0);
}

/// ポーションピッチャー回復量表示 ///
function PotionPitcher_Disp(evoflg){
	// ウィンドウ表示
	Make_Window_PP(evoflg);
	for(i=1;i<=5;i++) {
		document.getElementById("pp_lv").options[i - 1] = new Option(i, i);
	}
	for(i=5;i<=10;i++) {
		document.getElementById("lp_lv").options[i - 5] = new Option(i, i);
	}
	setIndex("pp_lv", pp_lv, 1);
	setIndex("lp_lv", lp_lv, 5);

	// ポーションピッチャー回復量計算
	Calc_Potion(evoflg);
}

/// カオティックベネディクション/治癒の手助け 回復量表示 ///
function Heal_Disp(evoflg){
	// ウィンドウ表示
	Make_Window_Heal(evoflg);
	if (Langage == 0) {
		dit("heal_title", skill_name3[type]);
	} else {
		dit("heal_title", skill_name3_e[type]);
	}

	var heal;
	for(i=0;i<=4;i++) {
		if (evoflg == 0) {
			if (type == 0 && evo_skill_1 != 0) {
				H_Disp("heal_"+i, 0, i);
			} else {
				heal = Calc_Heal(i + 1, level, int_);
				// リーフ(脳手術)
				if (type == 0) {
					heal = Math.floor(heal * (100 + skill_type[type][2][skill]) / 100);
				}
				H_Disp("heal_"+i, heal, i);
			}
		} else {
			if (type == 0 && evo_skill_2 != 0) {
				H_Disp("heal_"+i, 0, i);
			} else {
				heal = Calc_Heal(i + 1, hope_level, int_2);
				// リーフ(脳手術)
				if (type == 0) {
					heal = Math.floor(heal * (100 + skill_type[type][2][skill]) / 100);
				}
				H_Disp("heal_"+i, heal, i);
			}
		}
	}
}

/////////// 進化スキル表示 ///////////
function EvoSkill_Disp(){

	if (evo_flg_1 == 1) {
		if (type == 0 || type == 1) {
			if (Langage == 0) {
				dit("skill_name_2", skill_name2[type]);
			} else {
				dit("skill_name_2", skill_name2_e[type]);
			}
			dit("evo_1_1", "SkillLv");
			dit("evo_1_2", ":");
			setHtml("evo_1_3", '<SELECT ID="evo_skill_1"></SELECT>');
			for(i=0;i<=3;i++) {
				document.getElementById("evo_skill_1").options[i] = new Option(i, i);
			}
			setIndex("evo_skill_1", evo_skill_1, 0);
		} else {
			dit("skill_name_2", "");
			dit("evo_1_1", "");
			dit("evo_1_2", "");
			setHtml("evo_1_3", "");
		}
	} else {
		dit("skill_name_2", "");
		dit("evo_1_1", "");
		dit("evo_1_2", "");
		setHtml("evo_1_3", "");
	}
}

/////// 進化スキル表示(成長後) ///////
function EvoSkill_Disp2(){

	if (type == 0 || type == 1) {
		if (evo_flg_2 == 1) {
			if (Langage == 0) {
				dit("skill_name2_2", skill_name2[type]);
			} else {
				dit("skill_name2_2", skill_name2_e[type]);
			}
			dit("evo_2_1", "SkillLv");
			dit("evo_2_2", ":");
			setHtml("evo_2_3", '<SELECT ID="evo_skill_2"></SELECT>');
			for(i=0;i<=3;i++) {
				document.getElementById("evo_skill_2").options[i] = new Option(i, i);
			}
			setIndex("evo_skill_2", evo_skill_2, 0);
		} else {
			dit("skill_name2_2", "");
			dit("evo_2_1", "");
			dit("evo_2_2", "");
			setHtml("evo_2_3", "");
		}
	} else {
		dit("skill_name2_2", "");
		dit("evo_2_1", "");
		dit("evo_2_2", "");
		setHtml("evo_2_3", "");
	}
}


/////////// ステータス表示 ///////////
function Status_Disp(){
	// str
	dit("str",  str_);
	if (str_plus != 0) {
		dit("plus1", "+");
		dit("str_plus", str_plus);
	} else {
		dit("plus1", "");
		dit("str_plus", "");
	}
	// agi
	dit("agi",  agi_);
	// vit
	dit("vit",  vit_);
	if (vit_plus != 0) {
		dit("plus5", "+");
		dit("vit_plus", vit_plus);
	} else {
		dit("plus5", "");
		dit("vit_plus", "");
	}
	// int
	dit("int",  int_);
	if (int_plus != 0) {
		dit("plus2", "+");
		dit("int_plus", int_plus);
	} else {
		dit("plus2", "");
		dit("int_plus", "");
	}
	// dex
	dit("dex",  dex_);
	// luk
	dit("luk",  luk_);
	if (luk_ < 150) {
		dit("luk_p", "~");
		dit("luk2", luk_+2);
	} else {
		dit("luk_p", "");
		dit("luk2", "");
	}

	// aspd
	dit("aspd", Aspd_Format(aspd));
	// true_aspd
//	dit("true_aspd", Aspd_Format(true_aspd));

	// hpr
	dit("hpr",  hpr);
	// spr
	dit("spr",  spr);

	// atk
	if(atk_disp_max >= atk_disp_min) {
		dit("atk_max", atk_disp_max);
		dit("atk_min", atk_disp_min);
	} else {
		dit("atk_max", atk_disp_min);
		dit("atk_min", atk_disp_max);
	}

	// def
	if(def_disp == 0) {
		dit("d_def", "");
	} else {
		dit("d_def", def_disp);
	}
	// mdef
	if(mdef_disp == 0) {
		dit("d_mdef", "");
	} else {
		dit("d_mdef", mdef_disp);
	}
}

///////// 予想ステータス表示 /////////
function Hope_Status_Disp(){
	// level
	dit("level_2", hope_level);
	// str
	dit("str_2",  str_2);
	if (str_plus_2 != 0) {
		dit("plus3", "+");
		dit("str_plus_2", str_plus_2);
	} else {
		dit("plus3", "");
		dit("str_plus_2", "");
	}
	// agi
	dit("agi_2",  agi_2);
	// vit
	dit("vit_2",  vit_2);
	if (vit_plus_2 != 0) {
		dit("plus6", "+");
		dit("vit_plus_2", vit_plus_2);
	} else {
		dit("plus6", "");
		dit("vit_plus_2", "");
	}
	// int
	dit("int_2",  int_2);
	if (int_plus_2 != 0) {
		dit("plus4", "+");
		dit("int_plus_2", int_plus_2);
	} else {
		dit("plus4", "");
		dit("int_plus_2", "");
	}
	// dex
	dit("dex_2",  dex_2);
	// luk
	dit("luk_2",  luk_2);
	if (luk_2 < 150) {
		dit("luk_p_2", "~");
		dit("luk2_2", luk_2+2);
	} else {
		dit("luk_p_2", "");
		dit("luk2_2", "");
	}


	// atk
	if(atk_2_disp_max >= atk_2_disp_min) {
		dit("atk_max_2", atk_2_disp_max);
		dit("atk_min_2", atk_2_disp_min);
	} else {
		dit("atk_max_2", atk_2_disp_min);
		dit("atk_min_2", atk_2_disp_max);
	}
	// matk
	dit("matk_2", matk_2);
	// hit
	dit("hit_2", hit_2);
	// critical
	dit("cri_2", cri_2);
	// def
	dit("def_2", def_2);
	// mdef
	dit("mdef_2", mdef_2);
	// flee
	dit("flee_2", flee_2);
	// aspd
	dit("aspd_2", Aspd_Format(aspd_2));
	// aspd
//	dit("true_aspd_2", Aspd_Format(true_aspd_2));
	// hp
	dit("hp_2",  hp_2);
	// sp
	dit("sp_2",  sp_2);
	// hpr
	dit("hpr_2",  hpr_2);
	// spr
	dit("spr_2",  spr_2);
	// exp
	dit("exp",  hope_exp);
}

////// ステータス上昇平均値表示 //////
function Status_Up_Disp(){

	var d_str_up = Status_Up_Format(Math.round(str_up * 1000) / 1000 , 1);
	var d_agi_up = Status_Up_Format(Math.round(agi_up * 1000) / 1000 , 1);
	var d_vit_up = Status_Up_Format(Math.round(vit_up * 1000) / 1000 , 1);
	var d_int_up = Status_Up_Format(Math.round(int_up * 1000) / 1000 , 1);
	var d_dex_up = Status_Up_Format(Math.round(dex_up * 1000) / 1000 , 1);
	var d_luk_up = Status_Up_Format(Math.round(luk_up * 1000) / 1000 , 1);

	if (hp_up < 100) {
		var d_hp_up = Status_Up_Format(Math.round(hp_up * 1000) / 1000 , 2);
		var d_sp_up = Status_Up_Format(Math.round(sp_up * 1000) / 1000 , 2);
	} else {
		var d_hp_up = Status_Up_Format(Math.round(hp_up * 1000) / 1000 , 3);
		var d_sp_up = Status_Up_Format(Math.round(sp_up * 1000) / 1000 , 3);
	}

	if (level == 1){
		// str_up
		dit("str_up", "");
		// agi_up
		dit("agi_up", "");
		// vit_up
		dit("vit_up", "");
		// int_up
		dit("int_up", "");
		// dex_up
		dit("dex_up", "");
		// luk_up
		dit("luk_up", "");

		// hp_up
		dit("hp_up", "");
		// sp_up
		dit("sp_up", "");
	} else {
		// str_up
		dit("str_up", "[ "+d_str_up+" ]");
		// agi_up
		dit("agi_up", "[ "+d_agi_up+" ]");
		// vit_up
		dit("vit_up", "[ "+d_vit_up+" ]");
		// int_up
		dit("int_up", "[ "+d_int_up+" ]");
		// dex_up
		dit("dex_up", "[ "+d_dex_up+" ]");
		// luk_up
		dit("luk_up", "[ "+d_luk_up+" ]");

		// hp_up
		dit("hp_up", "[ "+d_hp_up+" ]");
		// sp_up
		dit("sp_up", "[ "+d_sp_up+" ]");
	}

	if (evo_flg_1 == 1) {
		// evo_hp
		dit("evo_hp", EvoBonus_Format(hp_bonus));
		// evo_sp
		dit("evo_sp", EvoBonus_Format(sp_bonus));
		// evo_str
		dit("evo_str", EvoBonus_Format(str_bonus));
		// evo_agi
		dit("evo_agi", EvoBonus_Format(agi_bonus));
		// evo_vit
		dit("evo_vit", EvoBonus_Format(vit_bonus));
		// evo_int
		dit("evo_int", EvoBonus_Format(int_bonus));
		// evo_dex
		dit("evo_dex", EvoBonus_Format(dex_bonus));
		// evo_luk
		dit("evo_luk", EvoBonus_Format(luk_bonus));
	} else {
		// evo_hp
		dit("evo_hp", "");
		// evo_sp
		dit("evo_sp", "");
		// evo_str
		dit("evo_str", "");
		// evo_agi
		dit("evo_agi", "");
		// evo_vit
		dit("evo_vit", "");
		// evo_int
		dit("evo_int", "");
		// evo_dex
		dit("evo_dex", "");
		// evo_luk
		dit("evo_luk", "");
	}

}

////////////////////////////  計算  ////////////////////////////

////// ステータス上昇平均値計算 //////
function Status_Up(){
	var c_lv = level - 1;
	if (c_lv == 0) {
		c_lv = 1;
	}

	var c_str_bonus = 0
	var c_agi_bonus = 0
	var c_vit_bonus = 0
	var c_int_bonus = 0
	var c_dex_bonus = 0
	var c_luk_bonus = 0
	var c_hp_bonus = 0
	var c_sp_bonus = 0

	if (evo_flg_1 == 1) {
		c_str_bonus = eval(str_bonus);
		c_agi_bonus = eval(agi_bonus);
		c_vit_bonus = eval(vit_bonus);
		c_int_bonus = eval(int_bonus);
		c_dex_bonus = eval(dex_bonus);
		c_luk_bonus = eval(luk_bonus);
		c_hp_bonus = eval(hp_bonus);
		c_sp_bonus = eval(sp_bonus);
	}

	// str_up
	str_up = (str_ - type_status[type][0] - c_str_bonus) / c_lv;
	// agi_up
	agi_up = (agi_ - type_status[type][1] - c_agi_bonus) / c_lv;
	// vit_up
	vit_up = (vit_ - type_status[type][2] - c_vit_bonus) / c_lv;
	// int_up
	int_up = (int_ - type_status[type][3] - c_int_bonus) / c_lv;
	// dex_up
	dex_up = (dex_ - type_status[type][4] - c_dex_bonus) / c_lv;
	// luk_up
	luk_up = (luk_ - type_status[type][5] - c_luk_bonus) / c_lv;

	// hp_up
	var c_hp;
	// アミストルの場合
	if (type == 1) {
		c_hp = Math.floor(hp / (100 + skill_type[type][0][skill]) * 100);
	} else {
		c_hp = hp;
	}
	hp_up = (c_hp - type_status[type][6] - c_hp_bonus) / c_lv;
	// sp_up
	var c_sp;
	// リーフの場合
	if (type == 0) {
		c_sp = Math.floor(sp / (100 + skill_type[type][0][skill]) * 100);
	} else {
		c_sp = sp;
	}
	sp_up = (c_sp - type_status[type][7] - c_sp_bonus) / c_lv;

}

/////////// パラメータ計算 ///////////
function Parameter_Calc(){

	var c_str = str_ + str_plus;
	var c_int = int_ + int_plus;
	// atk
	atk_max = Calc_Atk_Max(level, type, evo_flg_1, c_str, c_int, skill, evo_skill_1, skill_option1);
	atk_min = Calc_Atk_Min(level, type, evo_flg_1, c_str, c_int, dex_, evo_skill_1);
	// matk
	matk = Calc_Matk(c_int);
	// hit
	hit = Calc_Hit(level, dex_);
	// critical
	cri = Calc_Cri(luk_);
	// def
	def = Calc_Def(level, vit_, type, skill);
	// mdef
	mdef = Calc_Mdef(level, c_int);
	// flee
	flee = Calc_Flee(level, agi_);
	// aspd
	aspd = Calc_Aspd(agi_, dex_, type, skill);
	// true_aspd
	true_aspd = Calc_True_Aspd(agi_, dex_, type, skill);
	// hpr
	hpr = Calc_Hpr(vit_, hp, type, evo_flg_1, skill, evo_skill_1);
	// spr
	spr = Calc_Spr(int_, sp, type, evo_flg_1, skill, evo_skill_1);

	// フリットムーブ・ブラッドラスト補正
	atk_disp_max = Calc_FleetMove(atk_max, type, evo_flg_1, skill, evo_skill_1);;
	atk_disp_min = Calc_FleetMove(atk_min, type, evo_flg_1, skill, evo_skill_1);;
}

/////////// ステータス計算 ///////////
function Status_Calc(){
	// str
	str_ = Calc_Str(level, atk_max, hit, type, skill, skill_option1);
	// バニルミルト(CI)
	if(type == 3 && skill_option1 == 1) {
		str_plus = skill_type[type][0][skill];
		str_ = str_ - str_plus;
	} else {
		str_plus = 0;
	}
	// agi
	agi_ = Calc_Agi(level, flee);
	// vit
	vit_ = Calc_Vit(level, def, type, skill);
	vit_plus = 0;
	// リーフ(メンタルチェンジ)
	if(type == 0 && evo_flg_1 == 1) {
		vit_plus = skill_type2[type][0][evo_skill_1];
	}
	// int
	int_ = Calc_Int(matk);
	int_plus = 0;
	// バニルミルト(CI)
	if(type == 3) {
		int_plus = skill_type[type][1][skill];
		int_ = int_ - int_plus;
	}
	// リーフ(メンタルチェンジ)
	if(type == 0 && evo_flg_1 == 1) {
		int_plus = skill_type2[type][1][evo_skill_1];
	}
	// dex
	dex_ = Calc_Dex(level, hit);
	// luk
	luk_ = Calc_Luk(cri);
	// aspd
	aspd = Calc_Aspd(agi_, dex_, type, skill);
	// true_aspd
	true_aspd = Calc_True_Aspd(agi_, dex_, type, skill);
	// hpr
	hpr = Calc_Hpr(vit_, hp, type, evo_flg_1, skill, evo_skill_1);
	// spr
	spr = Calc_Spr(int_, sp, type, evo_flg_1, skill, evo_skill_1);

	var c_str = 0;
	if(str_ == "err" || str_ == "NaN") {
		c_str = "err";
	} else {
		c_str = str_ + str_plus;
	}
	var c_int = 0;
	if(int_ == "err" || int_ == "NaN") {
		c_int = "err";
	} else {
		c_int = int_ + int_plus;
	}
	var c_vit = 0;
	if(vit_ == "err" || vit_ == "NaN") {
		c_vit = "err";
	} else {
		c_vit = vit_ + vit_plus;
	}

	// atk
	atk_max = Calc_Atk_Max(level, type, evo_flg_1, c_str, c_int, skill, evo_skill_1, skill_option1);
	atk_min = Calc_Atk_Min(level, type, evo_flg_1, c_str, c_int, dex_, evo_skill_1);
	// フリットムーブ・ブラッドラスト補正
	atk_disp_max = Calc_FleetMove(atk_max, type, evo_flg_1, skill, evo_skill_1);
	atk_disp_min = Calc_FleetMove(atk_min, type, evo_flg_1, skill, evo_skill_1);
	// メンタルチェンジ補正
	if(type == 0 && evo_flg_1 == 1 && evo_skill_1 != 0) {
		def_disp = Calc_Def(level, c_vit, type, skill);
		mdef_disp = Calc_Mdef(level, c_int);
	} else {
		def_disp = 0;
		mdef_disp = 0;
	}
}

///////// 予想ステータス計算 /////////
function Hope_Status_Calc(){
	var c_str_bonus = 0;
	var c_agi_bonus = 0;
	var c_vit_bonus = 0;
	var c_int_bonus = 0;
	var c_dex_bonus = 0;
	var c_luk_bonus = 0;
	var c_hp_bonus = 0;
	var c_sp_bonus = 0;

	if (evo_flg_2 == 1) {
		if (evo_flg_1 == 0) {
			c_str_bonus = Math.round(Math.random() * 9.9 + 0.5);
			c_agi_bonus = Math.round(Math.random() * 9.9 + 0.5);
			c_vit_bonus = Math.round(Math.random() * 9.9 + 0.5);
			c_int_bonus = Math.round(Math.random() * 9.9 + 0.5);
			c_dex_bonus = Math.round(Math.random() * 9.9 + 0.5);
			c_luk_bonus = Math.round(Math.random() * 9.9 + 0.5);
			c_hp_bonus = Math.round(Math.random() * 29.9 + 0.5);
			c_sp_bonus = Math.round(Math.random() * 29.9 + 0.5);
		} else {
			c_str_bonus = eval(str_bonus);
			c_agi_bonus = eval(agi_bonus);
			c_vit_bonus = eval(vit_bonus);
			c_int_bonus = eval(int_bonus);
			c_dex_bonus = eval(dex_bonus);
			c_luk_bonus = eval(luk_bonus);
			c_hp_bonus = eval(hp_bonus);
			c_sp_bonus = eval(sp_bonus);
		}
	}
	// str
	str_2 = type_status[type][0] + Math.round(str_up * (hope_level - 1)) + c_str_bonus;
	if (str_2 > 150) {
		str_2 = 150;
	}
	// agi
	agi_2 = type_status[type][1] + Math.round(agi_up * (hope_level - 1)) + c_agi_bonus;
	if (agi_2 > 150) {
		agi_2 = 150;
	}
	// vit
	vit_2 = type_status[type][2] + Math.round(vit_up * (hope_level - 1)) + c_vit_bonus;
	if (vit_2 > 150) {
		vit_2 = 150;
	}
	// int
	int_2 = type_status[type][3] + Math.round(int_up * (hope_level - 1)) + c_int_bonus;
	if (int_2 > 150) {
		int_2 = 150;
	}
	// dex
	dex_2 = type_status[type][4] + Math.round(dex_up * (hope_level - 1)) + c_dex_bonus;
	if (dex_2 > 150) {
		dex_2 = 150;
	}
	// luk
	luk_2 = type_status[type][5] + Math.round(luk_up * (hope_level - 1)) + c_luk_bonus;
	luk_2 = Math.floor(luk_2 / 3) * 3;
	if (luk_2 > 150) {
		luk_2 = 150;
	}

	str_plus_2 = 0;
	// バニルミルト(CI/STR)
	if(type == 3 && skill_option2 == 1) {
		str_plus_2 = skill_type[type][0][hope_skill];
	}
	var c_str = str_2 + str_plus_2;

	int_plus_2 = 0;
	vit_plus_2 = 0;
	// バニルミルト(CI/INT)
	if(type == 3) {
		int_plus_2 = skill_type[type][1][hope_skill];
	}
	// リーフ(メンタルチェンジ)
	if(type == 0 && evo_flg_2 == 1) {
		vit_plus_2 = skill_type2[type][0][evo_skill_2];
		int_plus_2 = skill_type2[type][1][evo_skill_2];
	}
	var c_int = int_2 + int_plus_2;
	var c_vit = vit_2 + vit_plus_2;

	// atk(max)
	atk_max_2 = Calc_Atk_Max(hope_level, type, evo_flg_2, c_str, c_int, hope_skill, evo_skill_2, skill_option2);
	// atk(min)
	atk_min_2 = Calc_Atk_Min(hope_level, type, evo_flg_2, c_str, c_int, dex_2, evo_skill_2);
	// フリットムーブ・ブラッドラスト補正
	atk_2_disp_max = Calc_FleetMove(atk_max_2, type, evo_flg_2, hope_skill, evo_skill_2);
	atk_2_disp_min = Calc_FleetMove(atk_min_2, type, evo_flg_2, hope_skill, evo_skill_2);

	// matk
	matk_2 = Calc_Matk(c_int);
	// hit
	hit_2 = Calc_Hit(hope_level, dex_2);
	// critical
	cri_2 = Calc_Cri(luk_2);
	// def
	def_2 = Calc_Def(hope_level, c_vit, type, hope_skill);
	// mdef
	mdef_2 = Calc_Mdef(hope_level, c_int);
	// flee
	flee_2 = Calc_Flee(hope_level, agi_2);
	// aspd
	aspd_2 = Calc_Aspd(agi_2, dex_2, type, hope_skill);
	// true_aspd
	true_aspd_2 = Calc_True_Aspd(agi_2, dex_2, type, hope_skill);

	// hp
	var c_hp = type_status[type][6] + Math.floor(hp_up * (hope_level - 1)) + c_hp_bonus;
	// アミストルの場合
	if (type == 1) {
		hp_2 = c_hp + Math.floor(c_hp * skill_type[type][0][hope_skill] / 100);
	} else {
		hp_2 = c_hp;
	}

	// sp
	var c_sp = type_status[type][7] + Math.floor(sp_up * (hope_level - 1)) + c_sp_bonus;
	// リーフの場合
	if (type == 0) {
		sp_2 = c_sp + Math.floor(c_sp * skill_type[type][0][hope_skill] / 100);
	} else {
		sp_2 = c_sp;
	}

	// hpr
	hpr_2 = Calc_Hpr(vit_2, hp_2, type, evo_flg_2, hope_skill, evo_skill_2);
	// spr
	spr_2 = Calc_Spr(int_2, sp_2, type, evo_flg_2, hope_skill, evo_skill_2);
	// exp
	hope_exp = Calc_Exp(level, hope_level);

	// Amesani URL
	url_2 = Make_Url(type, hope_level, hp_2, sp_2, atk_max_2, matk_2, hit_2, cri_2, def_2, mdef_2, flee_2, hope_skill);

}

//// ポーションピッチャー計算 ////
function Calc_Potion(flg){
	lp_lv = getIndex("lp_lv", 5);
	pp_lv = getIndex("pp_lv", 1);

	var pp_min = 0;
	var pp_max = 0;
	var potion_name = new Array("赤ポーション", "紅ポーション", "黄ポーション", "白ポーション", "青ポーション");
	var potion_name_e = new Array("Red", "Orange", "Yellow", "White", "Blue");

	var c_vit = 0;
	var c_int = 0;
	if (flg == 0) {
		c_vit = vit_;
		c_int = int_;
	} else {
		c_vit = vit_2;
		c_int = int_2;
	}
	// メンタルチェンジによる増加値は含まない。
//	if (type == 0) {
//		c_vit = vit_;
//		c_int = int_;
//	} else {
//		c_vit = vit_ + vit_plus;
//		c_int = int_ + int_plus;
//	}

	for(i=0;i<=4;i++) {
		pp_min = Calc_PP(lp_lv, pp_lv, c_vit, c_int, i, 0);
		pp_max = Calc_PP(lp_lv, pp_lv, c_vit, c_int, i, 1);
		if(pp_lv > i){
			if (Langage == 0) {
				dit("pp_"+i+"_1", potion_name[i]);
			} else {
				dit("pp_"+i+"_1", potion_name_e[i]);
			}
			dit("pp_"+i+"_2", ":");
			PP_Disp("pp_"+i+"_3", pp_min, i);
			dit("pp_"+i+"_4", "~");
			PP_Disp("pp_"+i+"_5", pp_max, i);
		} else {
			dit("pp_"+i+"_1", "");
			dit("pp_"+i+"_2", "");
			PP_Disp("pp_"+i+"_3", 0, i);
			dit("pp_"+i+"_4", "");
			PP_Disp("pp_"+i+"_5", 0, i);
		}
	}
}

///////// STR計算 /////////
function Calc_Str(lv, c_atk, c_hit, c_type, c_skill, c_skill_option){
	var c_str;
	var a, b, c, d, e;

	// 最小ATK
	var c_dex = c_hit - lv;
	a = c_atk - c_dex;
	b = -1;
	do {
		b = b + 1;
		c = (b + 1) * 10 + Math.pow((b + 1), 2);
	} while (c <= a);
	d = a - (b * 10 + Math.pow(b, 2));
	c_str = b * 10 + d;
	if (c_atk > Calc_Atk_Max(lv, type, 0, c_str, 0, 0, 0, 0)) {
		return(c_str);
	}

	// 最大ATK
	// バニルミルト(CI)
//	if(c_type == 3 && c_skill_option == 0) {
//		c_atk = c_atk - skill_type[c_type][0][c_skill];
//	}
	a = c_atk - lv;
	b = -1;
	do {
		b = b + 1;
		c = (b + 1) * 20 + Math.pow((b + 1), 2);
	} while (c <= a);
	d = a - (b * 20 + Math.pow(b, 2));
	e = Math.floor(d / 2);
	c_str = b * 10 + e;
	if(c_atk != Calc_Atk_Max(lv, type, 0, c_str, 0, 0, 0, 0)) {
		c_str = "err";
	}

	return(c_str);
}

///////// AGI計算 /////////
function Calc_Agi(lv, c_flee){
	var c_agi = c_flee - lv;

	return(c_agi);
}

///////// VIT計算 /////////
function Calc_Vit(lv, c_def, c_type, c_skill){

	var c2_def;
	// アミストルの場合
	if (c_type == 1) {
		c2_def = c_def - skill_type[c_type][2][c_skill];
	} else {
		c2_def = c_def;
	}
	var c_vit = Math.ceil((c2_def - Math.floor(lv / 10)) * 5 / 6);

	if(c_def != Calc_Def(lv, c_vit, c_type, c_skill)) {
		c_vit = "err";
	}

	return(c_vit);
}

///////// INT計算 /////////
function Calc_Int(c_matk){
	var c_int;
	var a, b;

	a = -1;
	do {
		a = a + 1;
		b = (a + 1) * 5 + Math.pow((a + 1), 2);
	} while (b <= c_matk);
	c_int = c_matk - Math.pow(a, 2);

	if(c_matk != Calc_Matk(c_int)) {
		c_int = "err";
	}

	return(c_int);
}

///////// DEX計算 /////////
function Calc_Dex(lv, c_hit){
	var c_dex = c_hit - lv;

	return(c_dex);
}

///////// LUK計算 /////////
function Calc_Luk(c_critical){
	var c_luk = (c_critical - 1) * 3;

	return(c_luk);
}

////// ATK計算(最大) //////
function Calc_Atk_Max(lv, c_type, c_evoflg, c_str, c_int, c_skill, c_evo_skill, c_skill_option){
	var c_atk = 0;
	// リーフ(メンタルチェンジ)
	if (c_type == 0 && c_evoflg == 1 && c_evo_skill != 0) {
		if (c_int == "err" || c_int == "NaN") {
			c_atk = "err";
		} else {
			c_atk = c_int +  Math.pow(Math.floor(c_int / 5), 2);
		}
	} else {
		if (c_str == "err" || c_str == "NaN") {
			c_atk = "err";
		} else {
			c_atk = lv + c_str * 2 + Math.pow(Math.floor(c_str / 10), 2);
			// バニルミルト(CI)
//			if (c_type == 3 && c_skill != 0 && c_skill_option == 0) {
//				c_atk = c_atk + skill_type[c_type][0][c_skill];
//			}
		}
	}
	return(c_atk);
}

////// ATK計算(最小) //////
function Calc_Atk_Min(lv, c_type, c_evoflg, c_str, c_int, c_dex, c_skill){
	var c_atk = 0;
	// リーフ(メンタルチェンジ)
	if (c_type == 0 && c_evoflg == 1 && c_skill != 0) {
//		c_atk = c_int +  Math.pow(Math.floor(c_int / 7), 2);
		// 最大Matkで固定
		if (c_int == "err" || c_int == "NaN") {
			c_atk = "err";
		} else {
			c_atk = c_int +  Math.pow(Math.floor(c_int / 5), 2);
		}
	} else {
		if (c_str == "err" || c_str == "NaN") {
			c_atk = "err";
		} else {
			c_atk = c_dex + c_str + Math.pow(Math.floor(c_str / 10), 2);
		}
	}

	return(c_atk);
}

//////// MATK計算 /////////
function Calc_Matk(c_int){
	var c_matk = 0;
	if (c_int == "err" || c_int == "NaN") {
		c_matk = "err";
	} else {
		c_matk = c_int + Math.pow(Math.floor(c_int / 5), 2);
	}

	return(c_matk);
}

///////// HIT計算 /////////
function Calc_Hit(lv, c_dex){
	var c_hit = lv + c_dex;

	return(c_hit);
}

////// CRITICAL計算 ///////
function Calc_Cri(c_luk){
	var c_cri = Math.floor(c_luk / 3) + 1;

	return(c_cri);
}

///////// DEF計算 /////////
function Calc_Def(lv, c_vit, c_type, c_skill){
	var c_def = 0;
	if (c_vit == "err" || c_vit == "NaN") {
		c_def = "err";
	} else {
		c_def = c_vit + Math.floor(c_vit / 5) + Math.floor(lv / 10);
		// アミストルの場合
		if (c_type == 1) {
			c_def = c_def + skill_type[c_type][2][c_skill];
		}
	}

	return(c_def);
}

//////// MDEF計算 /////////
function Calc_Mdef(lv, c_int){
	var c_mdef = 0;
	if (c_int == "err" || c_int == "NaN") {
		c_mdef = "err";
	} else {
		c_mdef = Math.floor(c_int / 5) + Math.floor(lv / 10);
	}

	return(c_mdef);
}

//////// FLEE計算 /////////
function Calc_Flee(lv, c_agi){
	var c_flee = lv + c_agi;

	return(c_flee);
}

//////// ASPD計算 /////////
function Calc_Aspd(c_agi, c_dex, c_type, c_skill){
	var c_aspd = 0;
	var c_delay = 0;

	c_aspd = 200 - ( (250-(c_agi+Math.floor(c_dex/4))) / 250 * (200-type_status[c_type][8]) );
//	c_aspd = 200 - ( (250-(c_agi+c_dex/4)) / 250 * (200-type_status[c_type][8]) );

//	Math.round(aspd * 10) / 10;
	// フィーリルの場合
	if (c_type == 2) {
		c_delay = 200 - Math.round(c_aspd * 10) / 10;
		c_delay = c_delay * (100 - skill_type[c_type][1][c_skill]) / 100;
		c_aspd = 200 - c_delay;
	}

	return(c_aspd);
}

//////// 実ASPD計算 /////////
function Calc_True_Aspd(c_agi, c_dex, c_type, c_skill){
	var c_true_aspd = 0;
	var c_delay = 0;

	c_true_aspd = 200 - ( (250-(c_agi+Math.floor(c_dex/4))) / 250 * (200-true_aspd_base) );

	Math.round(aspd * 10) / 10;
	// フィーリルの場合
	if (c_type == 2) {
		c_delay = 200 - Math.round(c_true_aspd * 10) / 10;
		c_delay = c_delay * (100 - skill_type[c_type][1][c_skill]) / 100;
		c_true_aspd = 200 - c_delay;
	}

	return(c_true_aspd);
}


///////// HPR計算 /////////
function Calc_Hpr(c_vit, c_hp, c_type, c_evoflg, c_skill, c_skill2){
	var d_vit = 0;
	var c_hpr = 0;
	if (c_vit == "err" || c_vit == "NaN") {
		c_hpr = "err";
	} else {
		// リーフの場合
		if (c_type == 0 && c_evoflg == 1) {
			d_vit = c_vit + skill_type2[c_type][0][c_skill2];
		} else {
			d_vit = c_vit;
		}

		c_hpr = Math.floor(d_vit / 5) + Math.floor(c_hp / 200);
		// アミストルの場合
		if (c_type == 1) {
			c_hpr = c_hpr + Math.floor(c_hpr * skill_type[c_type][1][c_skill] / 100);
		}
	}

	return(c_hpr);
}

///////// SPR計算 /////////
function Calc_Spr(c_int, c_sp, c_type, c_evoflg, c_skill, c_skill2){
	var d_int = c_int;
	var c_spr = 0;
	if (c_int == "err" || c_int == "NaN") {
		c_spr = "err";
	} else {
		// バニルミルトの場合
		if (c_type == 3) {
			d_int = c_int + skill_type[c_type][1][c_skill];
		}
		// リーフの場合
		if (c_type == 0 && c_evoflg == 1) {
			d_int = c_int + skill_type2[c_type][1][c_skill2];
		}

		if (c_sp < 100) {
			c_spr = Math.floor(d_int / 6) + 1;
		} else {
			c_spr = Math.floor(d_int / 6) + Math.floor((c_sp - 100) / 100) + 1;
		}
		// リーフの場合
		if (c_type == 0) {
			c_spr = c_spr + Math.floor(c_spr * skill_type[c_type][1][c_skill] / 100);
		}
	}

	return(c_spr);
}

///// フリットムーブ・ブラッドラスト //////
function Calc_FleetMove(c_atk, c_type, c_evoflg, c_skill, c_skill2){
	var c_atk2 = 0;
	if (c_atk == "err" || c_atk == "NaN") {
		c_atk2 = "err";
	} else {
		if (c_type == 2) {
			c_atk2 = Math.floor(c_atk * (100 + skill_type[c_type][0][c_skill]) / 100);
		} else {
			if (c_type == 1 && c_evoflg == 1) {
				c_atk2 = Math.floor(c_atk * (100 + skill_type2[c_type][0][c_skill2]) / 100);
			} else {
				c_atk2 = c_atk;
			}
		}
	}

	return(c_atk2);
}

//////// ポーションピッチャー ////////
function Calc_PP(c_lp, c_pp, c_vit, c_int, c_lv, c_flg){
	var c_pp;
	//　POT基本回復量×（1＋[投げた人のPPのSLv]/10＋[投げた人のLPのSLv]/20）×（1＋[受ける人のVit]/50）×（1＋[受ける人のHPR]/10
	if(c_lv != 4) {
		c_pp = Math.floor(potion_recover[c_lv][c_flg] * (1 + c_pp / 10 + c_lp / 20) * (1 + c_vit / 50));
	} else {
		c_pp = Math.floor(potion_recover[c_lv][c_flg] * (1 + c_pp / 10 + c_lp / 20) * (1 + c_int / 50));
	}

	return(c_pp);
}

//////// ヒール(カオティックベネディクション/治癒の手助け) ////////
function Calc_Heal(c_lv, c_baselv, c_int){
	var c_heal;
	// ヒールレベル基本値の式 = (HealLv * 8) + 4
	// BaseLv INT による回復量の式 = floor((BaseLv + INT) / 8) * （ヒールレベル基本値）
	c_heal = Math.floor((c_baselv + c_int) / 8) * (c_lv * 8 + 4);

	return(c_heal);
}

///////// EXP計算 /////////
function Calc_Exp(lv1, lv2){
	var c_exp = 0;
	var i;

	for(i = lv1; i < lv2; i++){
		c_exp = c_exp + exp[i]
	}

	c_exp = Exp_Format(c_exp);

	return(c_exp);
}

///////// EXP書式 /////////
function Exp_Format(c_exp){
	var c_1, c_2, c_3;
	var d_2, d_3;
	var d_exp = "";
	c_1 = Math.floor(c_exp / 1000000);
	c_2 = Math.floor((c_exp - c_1 * 1000000) / 1000);
	c_3 = c_exp - (c_1 * 1000000 + c_2 * 1000);
	d_2 = "" + c_2;
	d_3 = "" + c_3;

	if (c_1 != 0) {
		d_exp = c_1 + ",";
		if (d_2.length == 2) {
			d_2 = "0" + d_2;
		}
		if (d_2.length == 1) {
			d_2 = "00" + d_2;
		}
	}
	if (c_2 != 0) {
		d_exp = d_exp + d_2 + ",";
	}

	if (c_1 != 0 || c_2 != 0) {
		if (d_3.length == 2) {
			d_3 = "0" + d_3;
		}
		if (d_3.length == 1) {
			d_3 = "00" + d_3;
		}
	}
	d_exp = d_exp + d_3;

	return(d_exp);
}

/// ステータス上昇率書式 ///
function Status_Up_Format(c_data, c_len) {

	var d_data = "" + c_data;
	var d_data2 = "" + Math.floor(c_data);

	if (d_data == "NaN") {
		d_data = " err ";
		return(d_data);
	}

	var len1 = d_data2.length;
	var len2 = d_data.length - len1;
	var len3 = c_len - len1;
	switch(len2){
		case 0:
			d_data = d_data + ".000";
			break;
		case 2:
			d_data = d_data + "00";
			break;
		case 3:
			d_data = d_data + "0";
			break;
		case 4:
			break;
	}
	if (c_len > len1) {
		if (len3 == 3) {
			d_data = "   " + d_data;
		}
		if (len3 == 2) {
			d_data = "  " + d_data;
		}
		if (len3 == 1) {
			d_data = " " + d_data;
		}
	}

	return(d_data);
}

///////// ASPD書式 /////////
function Aspd_Format(c_aspd){
//	var d_aspd = "" + Math.round(c_aspd * 10) / 10;
	var d_aspd = "" + Math.floor(c_aspd * 10) / 10;
	var d_aspd2 = "" + Math.floor(d_aspd);

	var len1 = d_aspd.length;
	var len2 = d_aspd2.length - len1;

	if (len2 == 0) {
		d_aspd = d_aspd + ".0";
	}

	return(d_aspd);
}

///// 進化ボーナス書式 /////
function EvoBonus_Format(c_bonus){
	var d_bonus = "" + c_bonus;
	var d_bonus2 = "";
	var len = d_bonus.length;

	if (len == 1) {
		d_bonus = " " + d_bonus;
	}
	d_bonus2 = "(+" + d_bonus + ")";

	return(d_bonus2);
}

///// Amesani URL作成 /////
function Make_Url(c_type, c_lv, c_hp, c_sp, c_atk, c_matk, c_hit, c_cri, c_def, c_mdef, c_flee, c_skill){
	var c_url = "";
	c_url = "http://www.amesani.org/ro/homun/statcalc.php?calc";
	switch(c_type){
		case 0:			// リーフ
			c_url = c_url + "&type=4";
			break;
		case 1:			// アミストル
			c_url = c_url + "&type=3";
			break;
		case 2:			// フィーリル
			c_url = c_url + "&type=1";
			break;
		case 3:			// バニルミルト
			c_url = c_url + "&type=2";
			break;
		default:
			c_url = c_url + "&type=0";
	}
	c_url = c_url + "&level=" + c_lv;
	c_url = c_url + "&hp=" + c_hp;
	c_url = c_url + "&sp=" + c_sp;
	c_url = c_url + "&attack=" + c_atk;
	c_url = c_url + "&mattack=" + c_matk;
	c_url = c_url + "&hit=" + c_hit;
	c_url = c_url + "&crit=" + c_cri;
	c_url = c_url + "&def=" + c_def;
	c_url = c_url + "&mdef=" + c_mdef;
	c_url = c_url + "&flee=" + c_flee;
	// Instraction Change
	if (c_type == 3) {
		c_url = c_url + "&instruct=" + c_skill;
	} else {
		c_url = c_url + "&instruct=0";
	}
	// Adamantium Skin
	if (c_type == 1) {
		c_url = c_url + "&skin=" + c_skill;
	} else {
		c_url = c_url + "&skin=0";
	}
	// Brain Surgery
	if (c_type == 0) {
		c_url = c_url + "&brain=" + c_skill;
	} else {
		c_url = c_url + "&brain=0";
	}

	return(c_url);
}

///// EvoCode取得 /////
function Get_EvoCode(){
	var c_evobonus, c_evocode;
	c_evocode = getValue("evocode");
	c_evobonus = c_evocode.split(":");

	c_evobonus[0] = Cnv_EvoBonus(c_evobonus[0], 50, 0);
	c_evobonus[1] = Cnv_EvoBonus(c_evobonus[1], 50, 0);
	c_evobonus[2] = Cnv_EvoBonus(c_evobonus[2], 15, 0);
	c_evobonus[3] = Cnv_EvoBonus(c_evobonus[3], 15, 0);
	c_evobonus[4] = Cnv_EvoBonus(c_evobonus[4], 15, 0);
	c_evobonus[5] = Cnv_EvoBonus(c_evobonus[5], 15, 0);
	c_evobonus[6] = Cnv_EvoBonus(c_evobonus[6], 15, 0);
	c_evobonus[7] = Cnv_EvoBonus(c_evobonus[7], 15, 0);

	// 進化ボーナス値表示
	setEvoBonus(c_evobonus[0], c_evobonus[1], c_evobonus[2], c_evobonus[3], c_evobonus[4], c_evobonus[5], c_evobonus[6], c_evobonus[7]);
}

/// EvoBonus変換処理 ///
function Cnv_EvoBonus(c_bonus, c_max, c_min){
	var c_evobonus;
	c_evobonus = Number(c_bonus);
	if (c_evobonus == "NaN") {
		c_evobonus = c_min;
	} else {
		if (c_evobonus < c_min) {
			c_evobonus = c_min;
		} else {
			if (c_evobonus > c_max) {
				c_evobonus = c_max;
			}
		}
	}

	return(c_evobonus);
}

///// EvoCode作成 /////
function Make_EvoCode(c_hp_bonus, c_sp_bonus, c_str_bonus, c_agi_bonus, c_vit_bonus, c_int_bonus, c_dex_bonus, c_luk_bonus){
	var c_evocode = "";
	c_evocode = c_evocode + c_hp_bonus + ":";
	c_evocode = c_evocode + c_sp_bonus + ":";
	c_evocode = c_evocode + c_str_bonus + ":";
	c_evocode = c_evocode + c_agi_bonus + ":";
	c_evocode = c_evocode + c_vit_bonus + ":";
	c_evocode = c_evocode + c_int_bonus + ":";
	c_evocode = c_evocode + c_dex_bonus + ":";
	c_evocode = c_evocode + c_luk_bonus;

	return(c_evocode);
}

window.onload = init;