//--------------------------------------------------------------------------
// ● 对像敌人的随机确定
// hp0 : 限制 HP 0 的敌人
//--------------------------------------------------------------------------
public Game_Enemy random_target_enemy(bool hp0 = false)
{
// 初始化轮流
var roulette = new List <Game_Enemy>();
// 循环
foreach (var enemy in this.enemies)
{
// 条件符合的情况下
if ((!hp0 && enemy.is_exist) || (hp0 && enemy.is_hp0))
{
// 添加敌人到轮流
roulette.Add(enemy);
}
}
// 轮流尺寸为 0 的情况下
if (roulette.Count == 0)
{
return(null);
}
// 转轮盘赌，决定敌人
return(roulette[Global.rand(roulette.Count)]);
}
//--------------------------------------------------------------------------
// ● 对像角色的随机确定
// hp0 : 限制为 HP 0 的角色
//--------------------------------------------------------------------------
public Game_Actor random_target_actor(bool hp0 = false)
{
// 初始化轮流
var roulette = new List <Game_Actor>();
// 循环
foreach (var actor in this.actors)
{
// 符合条件的场合
if ((!hp0 && actor.is_exist) || (hp0 && actor.is_hp0))
{
// 获取角色职业的位置 [位置]
var position = Global.data_classes[actor.class_id].position;
// 前卫的话 n = 4、中卫的话 n = 3、后卫的话 n = 2
var n = 4 - position;
// 添加角色的轮流 n 回
for (var i = 0; i < n; i++)
{
roulette.Add(actor);
}
}
}
// 轮流大小为 0 的情况
if (roulette.Count == 0)
{
return(null);
}
// 转轮盘赌，决定角色
return(roulette[Global.rand(roulette.Count)]);
}
//--------------------------------------------------------------------------
// ● 移动类型 : 接近
//--------------------------------------------------------------------------
public void move_type_toward_player()
{
// 求得与主角坐标的差
var sx = this.x - Global.game_player.x;
var sy = this.y - Global.game_player.y;
// 求得差的绝对值
var abs_sx = sx > 0 ? sx : -sx;
var abs_sy = sy > 0 ? sy : -sy;
// 如果纵横共计离开 20 个元件
if (sx + sy >= 20)
{
// 随机
move_random();
return;
}
// 随机 0～5 的分支
switch (Global.rand(6))
{
case 0:
case 1:
case 2:
case 3: // 接近主角
move_toward_player(); break;
case 4: // 随机
move_random(); break;
case 5: // 前进一步
move_forward(); break;
}
}
//--------------------------------------------------------------------------
// ● 生成遇敌计数
//--------------------------------------------------------------------------
public void make_encounter_count()
{
// 两种颜色震动的图像
if (Global.game_map.map_id != 0)
{
var n = Global.game_map.encounter_step;
this.encounter_count = Global.rand(n) + Global.rand(n) + 1;
}
}
//--------------------------------------------------------------------------
// ● 画面更新 (同伴指令回合 : 逃跑)
//--------------------------------------------------------------------------
public void update_phase2_escape()
{
// 计算敌人速度的平均值
var enemies_agi = 0;
var enemies_number = 0;
foreach (var enemy in Global.game_troop.enemies)
{
if (enemy.is_exist)
{
enemies_agi += (int)enemy.agi;
enemies_number += 1;
}
}
if (enemies_number > 0)
{
enemies_agi /= enemies_number;
}
// 计算角色速度的平均值
var actors_agi = 0;
var actors_number = 0;
foreach (var actor in Global.game_party.actors)
{
if (actor.is_exist)
{
actors_agi += (int)actor.agi;
actors_number += 1;
}
}
if (actors_number > 0)
{
actors_agi /= actors_number;
}
// 逃跑成功判定
var success = Global.rand(100) < 50 * actors_agi / enemies_agi;
// 成功逃跑的情况下
if (success)
{
// 演奏逃跑 SE
Global.game_system.se_play(Global.data_system.escape_se);
// 还原为战斗开始前的 RPG.AudioFile
Global.game_system.bgm_play(Global.game_temp.map_bgm);
// 战斗结束
battle_end(1);
// 逃跑失败的情况下
}
else
{
// 清除全体同伴的行动
Global.game_party.clear_actions();
// 开始主回合
start_phase4();
}
}
//--------------------------------------------------------------------------
// ● 状态攻击解除 (受到物理伤害时调用)
//--------------------------------------------------------------------------
public void remove_states_shock()
{
foreach (var i in new List <int>(this.states))
{
if (Global.rand(100) < Global.data_states[i].shock_release_prob)
{
remove_state(i);
}
}
}
//--------------------------------------------------------------------------
// ● 从右向左旋转 90 度
//--------------------------------------------------------------------------
public void turn_right_or_left_90()
{
if (Global.rand(2) == 0)
{
turn_right_90();
}
else
{
turn_left_90();
}
}
//--------------------------------------------------------------------------
// ● 状态自然解除 (回合改变时调用)
//--------------------------------------------------------------------------
public void remove_states_auto()
{
foreach (var i in new List <int>(this.states_turn.Keys))
{
if (this.states_turn[i] > 0)
{
this.states_turn[i] -= 1;
}
else if (Global.rand(100) < Global.data_states[i].auto_release_prob)
{
remove_state(i);
}
}
}
//--------------------------------------------------------------------------
// ● 随机变换方向
//--------------------------------------------------------------------------
public void turn_random()
{
switch (Global.rand(4))
{
case 0:
turn_up(); break;
case 1:
turn_right(); break;
case 2:
turn_left(); break;
case 3:
turn_down(); break;
}
}
//--------------------------------------------------------------------------
// ● 随机移动
//--------------------------------------------------------------------------
public void move_random()
{
switch (Global.rand(4))
{
case 0: // 向下移动
move_down(false); break;
case 1: // 向左移动
move_left(false); break;
case 2: // 向右移动
move_right(false); break;
case 3: // 向上移动
move_up(false); break;
}
}
//--------------------------------------------------------------------------
// ● 移动类型 : 随机
//--------------------------------------------------------------------------
public void move_type_random()
{
// 随机 0～5 的分支
switch (Global.rand(6))
{
case 0:
case 1:
case 2:
case 3: // 随机
move_random(); break;
case 4: // 前进一步
move_forward(); break;
case 5: // 暂时停止
this.stop_count = 0; break;
}
}
//--------------------------------------------------------------------------
// ● 应用连续伤害效果
//--------------------------------------------------------------------------
public bool slip_damage_effect()
{
double damage = 0.0;
if (this.damage is double)
{
damage = Convert.ToDouble(this.damage);
}
// 设置伤害
damage = this.maxhp / 10;
// 分散
if (Math.Abs(damage) > 0)
{
var amp = Math.Max(Math.Abs(damage) * 15 / 100, 1);
damage += Global.rand((int)amp + 1) + Global.rand((int)amp + 1) - amp;
}
// HP 的伤害减法运算
this.hp -= damage;
this.damage = damage;
// 过程结束
return(true);
}
//--------------------------------------------------------------------------
// ● 远离主角
//--------------------------------------------------------------------------
public void move_away_from_player()
{
// 求得与主角的坐标差
var sx = this.x - Global.game_player.x;
var sy = this.y - Global.game_player.y;
// 坐标相等情况下
if (sx == 0 && sy == 0)
{
return;
}
// 求得差的绝对值
var abs_sx = Math.Abs(sx);
var abs_sy = Math.Abs(sy);
// 横距离与纵距离相等的情况下
if (abs_sx == abs_sy)
{
// 随机将边数增加 1
if (Global.rand(2) == 0)
{
abs_sx += 1;
}
else
{
abs_sy += 1;
}
}
// 横侧距离长的情况下
if (abs_sx > abs_sy)
{
// 左右方向优先。远离主角移动
if (sx > 0)
{
move_right();
}
else
{
move_left();
}
if (!is_moving && sy != 0)
{
if (sy > 0)
{
move_down();
}
else
{
move_up();
}
}
}
// 竖侧距离长的情况下
else
{
// 上下方向优先。远离主角移动
if (sy > 0)
{
move_down();
}
else
{
move_up();
}
if (!is_moving && sx != 0)
{
if (sx > 0)
{
move_right();
}
else
{
move_left();
}
}
}
}
//--------------------------------------------------------------------------
// ● 开始结束战斗回合
//--------------------------------------------------------------------------
public void start_phase5()
{
// 转移到回合 5
this.phase = 5;
// 演奏战斗结束 ME
Global.game_system.me_play(Global.game_system.battle_end_me);
// 还原为战斗开始前的 RPG.AudioFile
Global.game_system.bgm_play(Global.game_temp.map_bgm);
// 初始化 EXP、金钱、宝物
var exp = 0;
var gold = 0;
var treasures = new List <RPG.Goods>();
// 循环
foreach (var enemy in Global.game_troop.enemies)
{
// 敌人不是隐藏状态的情况下
if (!enemy.hidden)
{
// 获得 EXP、增加金钱
exp += enemy.exp;
gold += enemy.gold;
// 出现宝物判定
if (Global.rand(100) < enemy.treasure_prob)
{
if (enemy.item_id > 0)
{
treasures.Add(Global.data_items[enemy.item_id]);
}
if (enemy.weapon_id > 0)
{
treasures.Add(Global.data_weapons[enemy.weapon_id]);
}
if (enemy.armor_id > 0)
{
treasures.Add(Global.data_armors[enemy.armor_id]);
}
}
}
}
// 限制宝物数为 6 个
while (treasures.Count < 6)
{
treasures.Add(null);
}
treasures = treasures.Take(5).ToList();
// 获得 EXP
for (var i = 0; i < Global.game_party.actors.Count; i++)
{
var actor = Global.game_party.actors[i];
if (actor.is_cant_get_exp == false)
{
var last_level = actor.level;
actor.exp += exp;
if (actor.level > last_level)
{
this.status_window.level_up(i);
}
}
}
// 获得金钱
Global.game_party.gain_gold(gold);
// 获得宝物
foreach (var item_obj in treasures)
{
var item = item_obj as RPG.Item;
if (item != null)
{
Global.game_party.gain_item(item.id, 1);
}
var item1 = item_obj as RPG.Weapon;
if (item != null)
{
Global.game_party.gain_weapon(item1.id, 1);
}
var item2 = item_obj as RPG.Armor;
if (item2 != null)
{
Global.game_party.gain_armor(item2.id, 1);
}
}
// 生成战斗结果窗口
this.result_window = new Window_BattleResult(exp, gold, treasures);
// 设置等待计数
this.phase5_wait_count = 100;
}
//--------------------------------------------------------------------------
// ● 应用特技效果
// user : 特技的使用者 (battler)
// skill : 特技
//--------------------------------------------------------------------------
public bool skill_effect(Game_Battler user, RPG.Skill skill)
{
// 清除会心一击标志
this.critical = false;
// 特技的效果范围是 HP 1 以上的己方、自己的 HP 为 0、
// 或者特技的效果范围是 HP 0 的己方、自己的 HP 为 1 以上的情况下
if (((skill.scope == 3 || skill.scope == 4) && this.hp == 0) ||
((skill.scope == 5 || skill.scope == 6) && this.hp >= 1))
{
// 过程结束
return(false);
}
double damage = 0.0;
if (this.damage is double)
{
damage = Convert.ToDouble(this.damage);
}
// 清除有效标志
var effective = false;
// 公共事件 ID 是有效的情况下,设置为有效标志
effective |= skill.common_event_id > 0;
// 第一命中判定
var hit = skill.hit;
if (skill.atk_f > 0)
{
hit *= (int)(user.hit / 100);
}
var hit_result = (Global.rand(100) < hit);
// 不确定的特技的情况下设置为有效标志
effective |= hit < 100;
// 命中的情况下
if (hit_result == true)
{
// 计算威力
var power = skill.power + user.atk * skill.atk_f / 100;
if (power > 0)
{
power -= this.pdef * skill.pdef_f / 200;
power -= this.mdef * skill.mdef_f / 200;
power = Math.Max(power, 0);
}
// 计算倍率
double rate = 20;
rate += (user.str * skill.str_f / 100);
rate += (user.dex * skill.dex_f / 100);
rate += (user.agi * skill.agi_f / 100);
rate += (user.int1 * skill.int_f / 100);
// 计算基本伤害
damage = power * rate / 20;
// 属性修正
damage *= elements_correct(skill.element_set);
damage /= 100;
// 伤害符号正确的情况下
if (damage > 0)
{
// 防御修正
if (this.is_guarding)
{
damage /= 2;
}
}
// 分散
if (skill.variance > 0 && Math.Abs(damage) > 0)
{
var amp = Math.Max(Math.Abs(damage) * skill.variance / 100, 1);
damage += Global.rand((int)amp + 1) + Global.rand((int)amp + 1) - amp;
}
// 第二命中判定
var eva = 8 * this.agi / user.dex + this.eva;
hit = damage < 0 ? 100 : (int)(100 - eva * skill.eva_f / 100);
hit = this.is_cant_evade ? 100 : hit;
hit_result = (Global.rand(100) < hit);
// 不确定的特技的情况下设置为有效标志
effective |= hit < 100;
}
this.damage = damage;
// 命中的情况下
if (hit_result == true)
{
// 威力 0 以外的物理攻击的情况下
if (skill.power != 0 && skill.atk_f > 0)
{
// 状态冲击解除
remove_states_shock();
// 设置有效标志
effective = true;
}
// HP 的伤害减法运算
var last_hp = this.hp;
this.hp -= damage;
effective |= this.hp != last_hp;
// 状态变化
this.state_changed = false;
effective |= states_plus(skill.plus_state_set);
effective |= states_minus(skill.minus_state_set);
// 威力为 0 的场合
if (skill.power == 0)
{
// 伤害设置为空的字串
this.damage = "";
// 状态没有变化的情况下
if (!this.state_changed)
{
// 伤害设置为 "Miss"
this.damage = "Miss";
}
}
}
// Miss 的情况下
else
{
// 伤害设置为 "Miss"
this.damage = "Miss";
}
// 不在战斗中的情况下
if (!Global.game_temp.in_battle)
{
// 伤害设置为 null
this.damage = null;
}
// 过程结束
return(effective);
}
//--------------------------------------------------------------------------
// ● 应用物品效果
// item : 物品
//--------------------------------------------------------------------------
public bool item_effect(RPG.Item item)
{
// 清除会心一击标志
this.critical = false;
// 物品的效果范围是 HP 1 以上的己方、自己的 HP 为 0、
// 或者物品的效果范围是 HP 0 的己方、自己的 HP 为 1 以上的情况下
if (((item.scope == 3 || item.scope == 4) && this.hp == 0) ||
((item.scope == 5 || item.scope == 6) && this.hp >= 1))
{
// 过程结束
return(false);
}
// 清除有效标志
var effective = false;
// 公共事件 ID 是有效的情况下,设置为有效标志
effective |= item.common_event_id > 0;
// 命中判定
var hit_result = (Global.rand(100) < item.hit);
// 不确定的特技的情况下设置为有效标志
effective |= item.hit < 100;
// 命中的情况
if (hit_result == true)
{
// 计算回复量
var recover_hp = maxhp * item.recover_hp_rate / 100 + item.recover_hp;
var recover_sp = maxsp * item.recover_sp_rate / 100 + item.recover_sp;
if (recover_hp < 0)
{
recover_hp += this.pdef * item.pdef_f / 20;
recover_hp += this.mdef * item.mdef_f / 20;
recover_hp = Math.Min(recover_hp, 0);
}
// 属性修正
recover_hp *= elements_correct(item.element_set);
recover_hp /= 100;
recover_sp *= elements_correct(item.element_set);
recover_sp /= 100;
// 分散
if (item.variance > 0 && Math.Abs(recover_hp) > 0)
{
var amp = (int)Math.Max(Math.Abs(recover_hp) * item.variance / 100, 1);
recover_hp += Global.rand(amp + 1) + Global.rand(amp + 1) - amp;
}
if (item.variance > 0 && Math.Abs(recover_sp) > 0)
{
int amp = (int)Math.Max(Math.Abs(recover_sp) * item.variance / 100, 1);
recover_sp += Global.rand(amp + 1) + Global.rand(amp + 1) - amp;
}
// 回复量符号为负的情况下
if (recover_hp < 0)
{
// 防御修正
if (this.is_guarding)
{
recover_hp /= 2;
}
}
// HP 回复量符号的反转、设置伤害值
this.damage = -recover_hp;
// HP 以及 SP 的回复
var last_hp = this.hp;
var last_sp = this.sp;
this.hp += recover_hp;
this.sp += recover_sp;
effective |= this.hp != last_hp;
effective |= this.sp != last_sp;
// 状态变化
this.state_changed = false;
effective |= states_plus(item.plus_state_set);
effective |= states_minus(item.minus_state_set);
// 能力上升值有效的情况下
if (item.parameter_type > 0 && item.parameter_points != 0)
{
// 能力值的分支
switch (item.parameter_type)
{
case 1: // MaxHP
this.maxhp_plus += item.parameter_points; break;
case 2: // MaxSP
this.maxsp_plus += item.parameter_points; break;
case 3: // 力量
this.str_plus += item.parameter_points; break;
case 4: // 灵巧
this.dex_plus += item.parameter_points; break;
case 5: // 速度
this.agi_plus += item.parameter_points; break;
case 6: // 魔力
this.int_plus += item.parameter_points; break;
}
// 设置有效标志
effective = true;
}
// HP 回复率与回复量为 0 的情况下
if (item.recover_hp_rate == 0 && item.recover_hp == 0)
{
// 设置伤害为空的字符串
this.damage = "";
// SP 回复率与回复量为 0、能力上升值无效的情况下
if (
item.recover_sp_rate == 0 && item.recover_sp == 0 &&
(item.parameter_type == 0 || item.parameter_points == 0))
{
// 状态没有变化的情况下
if (!this.state_changed)
{
// 伤害设置为 "Miss"
this.damage = "Miss";
}
}
}
// Miss 的情况下
else
{
// 伤害设置为 "Miss"
this.damage = "Miss";
}
// 不在战斗中的情况下
if (!Global.game_temp.in_battle)
{
// 伤害设置为 null
this.damage = null;
}
// 过程结束
return(effective);
}
return(false);
}
//--------------------------------------------------------------------------
// ● 刷新画面
//--------------------------------------------------------------------------
public override void update()
{
// 循环
while (true)
{
// 按照地图、实例、主角的顺序刷新
// (本更新顺序不会在满足事件的执行条件下成为给予角色瞬间移动
// 的机会的重要因素)
Global.game_map.update();
Global.game_system.map_interpreter.update();
Global.game_player.update();
// 系统 (计时器)、画面刷新
Global.game_system.update();
Global.game_screen.update();
// 如果主角在场所移动中就中断循环
if (!Global.game_temp.player_transferring)
{
break;
}
// 执行场所移动
transfer_player();
// 处理过渡中的情况下、中断循环
if (Global.game_temp.transition_processing)
{
break;
}
}
// 刷新活动块
this.spriteset.update();
// 刷新信息窗口
this.message_window.update();
// 游戏结束的情况下
if (Global.game_temp.gameover)
{
// 切换的游戏结束画面
Global.scene = new Scene_Gameover();
return;
}
// 返回标题画面的情况下
if (Global.game_temp.to_title)
{
// 切换到标题画面
Global.scene = new Scene_Title();
return;
}
// 处理过渡中的情况下
if (Global.game_temp.transition_processing)
{
// 清除过渡处理中标志
Global.game_temp.transition_processing = false;
// 执行过渡
if (Global.game_temp.transition_name == "")
{
Graphics.transition(20);
}
else
{
Graphics.transition(40, "Graphics/Transitions/" +
Global.game_temp.transition_name);
}
}
// 显示信息窗口中的情况下
if (Global.game_temp.message_window_showing)
{
return;
}
// 遇敌计数为 0 且、且遇敌列表不为空的情况下
if (Global.game_player.encounter_count == 0 && Global.game_map.encounter_list.Count != 0)
{
// 不是在事件执行中或者禁止遇敌中
if (!(Global.game_system.map_interpreter.is_running ||
Global.game_system.encounter_disabled))
{
// 确定队伍
var n = Global.rand(Global.game_map.encounter_list.Count);
var troop_id = Global.game_map.encounter_list[n];
// 队伍有效的话
if (Global.data_troops[troop_id] != null)
{
// 设置调用战斗标志
Global.game_temp.battle_calling = true;
Global.game_temp.battle_troop_id = troop_id;
Global.game_temp.battle_can_escape = true;
Global.game_temp.battle_can_lose = false;
Global.game_temp.battle_proc = null;
}
}
}
// 按下 B 键的情况下
if (Input.is_trigger(Input.B))
{
// 不是在事件执行中或菜单禁止中
if (!(Global.game_system.map_interpreter.is_running ||
Global.game_system.menu_disabled))
{
// 设置菜单调用标志以及 SE 演奏
Global.game_temp.menu_calling = true;
Global.game_temp.menu_beep = true;
}
}
// 调试模式为 ON 并且按下 F9 键的情况下
if (Global.DEBUG && Input.is_press(Input.F9))
{
// 设置调用调试标志
Global.game_temp.debug_calling = true;
}
// 不在主角移动中的情况下
if (!Global.game_player.is_moving)
{
// 执行各种画面的调用
if (Global.game_temp.battle_calling)
{
call_battle();
}
else if (Global.game_temp.shop_calling)
{
call_shop();
}
else if (Global.game_temp.name_calling)
{
call_name();
}
else if (Global.game_temp.menu_calling)
{
call_menu();
}
else if (Global.game_temp.save_calling)
{
call_save();
}
else if (Global.game_temp.debug_calling)
{
call_debug();
}
}
}
//--------------------------------------------------------------------------
// ● 生成行动
//--------------------------------------------------------------------------
public void make_action()
{
// 清除当前行动
this.current_action.clear();
// 无法行动的情况
if (!this.is_movable)
{
// 过程结束
return;
}
// 抽取现在有效的行动
var available_actions = new List <RPG.Enemy.Action>();
var rating_max = 0;
foreach (var action in this.actions)
{
// 确认回合条件
var n = Global.game_temp.battle_turn;
var a = action.condition_turn_a;
var b = action.condition_turn_b;
if (
(b == 0 && n != a) ||
(b > 0 && (n < 1 || n < a || n % b != a % b)))
{
continue;
}
// 确认 HP 条件
if (this.hp * 100.0 / this.maxhp > action.condition_hp)
{
continue;
}
// 确认等级条件
if (Global.game_party.max_level < action.condition_level)
{
continue;
}
// 确认开关条件
var switch_id = action.condition_switch_id;
if (switch_id > 0 && Global.game_switches[switch_id] == false)
{
continue;
}
// 符合条件 : 添加本行动
available_actions.Add(action);
if (action.rating > rating_max)
{
rating_max = action.rating;
}
}
// 最大概率值作为 3 合计计算(0 除外)
var ratings_total = 0;
foreach (var action in available_actions)
{
if (action.rating > rating_max - 3)
{
ratings_total += action.rating - (rating_max - 3);
}
}
// 概率合计不为 0 的情况下
if (ratings_total > 0)
{
// 生成随机数
var value = Global.rand(ratings_total);
// 设置对应生成随机数的当前行动
foreach (var action in available_actions)
{
if (action.rating > rating_max - 3)
{
if (value < action.rating - (rating_max - 3))
{
this.current_action.kind = action.kind;
this.current_action.basic = action.basic;
this.current_action.skill_id = action.skill_id;
this.current_action.decide_random_target_for_enemy();
return;
}
else
{
value -= action.rating - (rating_max - 3);
}
}
}
}
}
//--------------------------------------------------------------------------
// ● 应用通常攻击效果
// attacker : 攻击者 (battler)
//--------------------------------------------------------------------------
public bool attack_effect(Game_Battler attacker)
{
double damage = 0.0;
if (this.damage is double)
{
damage = Convert.ToDouble(this.damage);
}
// 清除会心一击标志
this.critical = false;
// 第一命中判定
var hit_result = (Global.rand(100) < attacker.hit);
// 命中的情况下
if (hit_result == true)
{
// 计算基本伤害
var atk = Math.Max(attacker.atk - this.pdef / 2, 0);
damage = atk * (20 + attacker.str) / 20;
// 属性修正
damage *= elements_correct(attacker.element_set);
damage /= 100;
// 伤害符号正确的情况下
if (damage > 0)
{
// 会心一击修正
if (Global.rand(100) < 4 * attacker.dex / this.agi)
{
damage *= 2;
this.critical = true;
}
// 防御修正
if (this.is_guarding)
{
damage /= 2;
}
}
// 分散
if (Math.Abs(damage) > 0)
{
var amp = Math.Max(Math.Abs(damage) * 15 / 100, 1);
damage += Global.rand((int)amp + 1) + Global.rand((int)amp + 1) - amp;
}
// 第二命中判定
var eva = 8 * this.agi / attacker.dex + this.eva;
var hit = damage < 0 ? 100 : 100 - eva;
hit = this.is_cant_evade ? 100 : hit;
hit_result = (Global.rand(100) < hit);
}
// 命中的情况下
if (hit_result == true)
{
// 状态冲击解除
remove_states_shock();
// HP 的伤害计算
this.hp -= damage;
// 状态变化
this.state_changed = false;
states_plus(attacker.plus_state_set);
states_minus(attacker.minus_state_set);
}
// Miss 的情况下
else
{
// 伤害设置为 "Miss"
this.damage = "Miss";
// 清除会心一击标志
this.critical = false;
}
this.damage = damage;
// 过程结束
return(true);
}
//--------------------------------------------------------------------------
// ● 确定动作速度
//--------------------------------------------------------------------------
public int make_action_speed()
{
this.current_action.speed = (int)(agi + Global.rand(10 + (int)agi / 4));
return(this.current_action.speed);
}
//--------------------------------------------------------------------------
// ● 变量操作
//--------------------------------------------------------------------------
public bool command_122()
{
// 初始化值
var value = 0.0;
// 操作数的分支
switch ((int)this.parameters[3])
{
case 0: // 恒量
value = (int)this.parameters[4]; break;
case 1: // 变量
value = Global.game_variables[(int)this.parameters[4]]; break;
case 2: // 随机数
value = (int)this.parameters[4] + Global.rand((int)this.parameters[5] - (int)this.parameters[4] + 1); break;
case 3: // 物品
value = Global.game_party.item_number((int)this.parameters[4]); break;
case 4: // 角色
{
var actor = Global.game_actors[(int)this.parameters[4]];
if (actor != null)
{
switch ((int)this.parameters[5])
{
case 0: // 等级
value = actor.level; break;
case 1: // EXP
value = actor.exp; break;
case 2: // HP
value = actor.hp; break;
case 3: // SP
value = actor.sp; break;
case 4: // MaxHP
value = actor.maxhp; break;
case 5: // MaxSP
value = actor.maxsp; break;
case 6: // 力量
value = actor.str; break;
case 7: // 灵巧
value = actor.dex; break;
case 8: // 速度
value = actor.agi; break;
case 9: // 魔力
value = actor.int1; break;
case 10: // 攻击力
value = actor.atk; break;
case 11: // 物理防御
value = actor.pdef; break;
case 12: // 魔法防御
value = actor.mdef; break;
case 13: // 回避修正
value = actor.eva; break;
}
}
}
break;
case 5: // 敌人
{
var enemy = Global.game_troop.enemies[(int)this.parameters[4]];
if (enemy != null)
{
switch ((int)this.parameters[5])
{
case 0: // HP
value = enemy.hp; break;
case 1: // SP
value = enemy.sp; break;
case 2: // MaxHP
value = enemy.maxhp; break;
case 3: // MaxSP
value = enemy.maxsp; break;
case 4: // 力量
value = enemy.str; break;
case 5: // 灵巧
value = enemy.dex; break;
case 6: // 速度
value = enemy.agi; break;
case 7: // 魔力
value = enemy.int1; break;
case 8: // 攻击力
value = enemy.atk; break;
case 9: // 物理防御
value = enemy.pdef; break;
case 10: // 魔法防御
value = enemy.mdef; break;
case 11: // 回避修正
value = enemy.eva; break;
}
}
}
break;
case 6: // 角色
{
var character = get_character((int)this.parameters[4]);
if (character != null)
{
switch ((int)this.parameters[5])
{
case 0: // X 坐标
value = character.x; break;
case 1: // Y 坐标
value = character.y; break;
case 2: // 朝向
value = character.direction; break;
case 3: // 画面 X 坐标
value = character.screen_x; break;
case 4: // 画面 Y 坐标
value = character.screen_y; break;
case 5: // 地形标记
value = character.terrain_tag; break;
}
}
}
break;
case 7: // 其它
switch ((int)this.parameters[4])
{
case 0: // 地图 ID
value = Global.game_map.map_id; break;
case 1: // 同伴人数
value = Global.game_party.actors.Count; break;
case 2: // 金钱
value = Global.game_party.gold; break;
case 3: // 步数
value = Global.game_party.steps; break;
case 4: // 游戏时间
value = Graphics.frame_count / Graphics.frame_rate; break;
case 5: // 计时器
value = Global.game_system.timer / Graphics.frame_rate; break;
case 6: // 存档次数
value = Global.game_system.save_count; break;
}
break;
}
// 循环全部操作
for (var i = (int)this.parameters[0]; i <= (int)this.parameters[1]; i++)
{
// 操作分支
switch ((int)this.parameters[2])
{
case 0: // 代入
Global.game_variables[i] = (int)value; break;
case 1: // 加法
Global.game_variables[i] += (int)value; break;
case 2: // 减法
Global.game_variables[i] -= (int)value; break;
case 3: // 乘法
Global.game_variables[i] *= (int)value; break;
case 4: // 除法
if (value != 0)
{
Global.game_variables[i] /= (int)value;
}
break;
case 5: // 剩余
if (value != 0)
{
Global.game_variables[i] %= (int)value;
}
break;
}
// 检查上限
if (Global.game_variables[i] > 99999999)
{
Global.game_variables[i] = 99999999;
}
// 检查下限
if (Global.game_variables[i] < -99999999)
{
Global.game_variables[i] = -99999999;
}
}
// 刷新地图
Global.game_map.need_refresh = true;
// 继续
return(true);
}