自軍選擇反撃:
/*--------------------------------------------------------------------------
　反撃時に武器を選択可能にするスクリプト
■概要
敵ターンで、敵に攻撃を受けた場合の反撃時に武器を選択できるようになります。
キーワード'weapon_select'を設定したカスタムスキルを当該のユニットに設定すると、
そのユニットだけが反撃時に武器選択出来るようになります。
（初期状態では、反撃武器選択スキルを所持したユニットのみ反撃時に武器選択出来るようになっています）
ただし以下の場合は武器選択ウィンドウは出ず従来のままに処理が進みます。
１．データ設定で反撃は行わないように設定してある
２．敵武器に対して射程が合う武器を持っていない（武器未所持も含む）
３．敵or自分が一方通行の武器を持っている
４．自分が行動不能／暴走／武器使用不可のバッドステートを受けている
■カスタマイズ
１．全自軍ユニットが反撃時に武器選択が可能になるようにしたい。
　　　設定の中にある『var PlayrUnit_CounterWeaponSelectable = false;』の部分を
　　　『var PlayrUnit_CounterWeaponSelectable = true;』に書き換えて下さい。
　　　※この場合、概要に記述したカスタムスキルを所持していなくても自軍ユニットは反撃時に武器を選択できるようになります。
２．反撃しない事を選択出来るようにしたい
　　本ソース内の設定にある反撃しない事を選択出来るか（var NoEquipWeaponEnable = false;）のfalseをtrueにすると、
　　敵から攻撃を受けた時に武器選択画面下部に『キャンセルキーで反撃しない事を選択出来ます』と表示されるようになります。
　　その状態であれば、武器選択画面でキャンセルキーを押す→戦闘結果予測画面で決定キーを押す、と行うと
　　反撃しないようになります。
　　（反撃しない場合、戦闘結果予測画面で攻撃や命中のところに--が表示されるので判ると思います）
16/01/16 新規作成
16/02/25 1.060対応
16/07/26 1.085対応
16/07/30 反撃しない事を選択出来るようになる設定を追加
16/10/21 敵ターンスキップを行った場合、反撃時にエラーが発生するバグを修正
17/11/29 1.164対応
17/12/05 変数の定義ミスにより、反撃時にエラーが出る事があったのを修正
17/12/28 難易度設定で反撃不可とし、本プラグインの設定を無条件で武器選択可能の設定をした場合に
スキル：反撃を所持したユニットが武器を選択出来ないバグを修正
20/09/12 本プラグインの設定が「反撃武器選択スキル所持ならば可能」になっていたのに説明文が食い違っていた為説明文を修正
■対応バージョン
　SRPG Studio Version:1.164
■規約
・利用はSRPG Studioを使ったゲームに限ります。
・商用・非商用問いません。フリーです。
・加工等、問題ありません。どんどん改造してください。
・クレジット明記無し　OK
・再配布、転載　OK
・SRPG Studio利用規約は遵守してください。
--------------------------------------------------------------------------*/
(function() {
//-----------------------------------
// 設定
//-----------------------------------
// 自軍は全員無条件で反撃時に武器選択可能か？（true:無条件で武器選択可能、false:反撃武器選択スキル所持ならば可能）
var PlayrUnit_CounterWeaponSelectable = false;
// 反撃武器選択用のカスタムスキル名
var WeaponSelectSkill = 'weapon_select';
// 反撃しない事を選択出来るか（true:反撃しない事を選択可能 false:不可能）
var NoEquipWeaponEnable = false;
//-----------------------------------
//-----------------------------------
// 以下、ソースコードやコード内の定義
//-----------------------------------
var WeaponAutoActionMode = {
CURSORSHOW: 0,
PREATTACK: 1,
WEAPONSELECT: 3,
DISPATTACKWINDOW: 4
};
var alias1 = WeaponAutoAction.setAutoActionInfo
WeaponAutoAction.setAutoActionInfo= function(unit, combination) {
alias1.call(this, unit, combination);
this._isNoEuipedWeapon = 0;
this._weaponSelectMenu = createObject(EnemyTurnWeaponSelectMenu);
this._posSelector = createObject(EnemyTurnPosSelector);
// 敵が攻撃を行う時点では敵ユニットの位置座標は更新されておらず、移動前の位置に存在する事になっている
// 実際には敵はcombination.posIndexで指定された地点にいるので、CurrentMap.getX(combination.posIndex)などでX、Y座標を取得する必要がある
this._enemyX = CurrentMap.getX(combination.posIndex);
this._enemyY = CurrentMap.getY(combination.posIndex);
if( this._isWeaponSelectable() ) {
// 敵ルーチンでの処理なので、this._targetUnitが敵に狙われたユニット、unitが敵ユニット
// this._enemyX、this._enemyYは実際の敵座標
// this._weaponは敵の使う武器（敵は自軍と違ってUnitItemControl.getPossessionItemCount()やItemControl.getEquippedWeapon()はできない模様）
this._weaponSelectMenu.setMenuUnitAndTarget(this._targetUnit, unit, this._enemyX, this._enemyY, this._weapon );
}
}
WeaponAutoAction.enterAutoAction= function() {
var isSkipMode = this.isSkipMode();
if (isSkipMode) {
if( this._isWeaponSelectable() ) {
this.changeCycleMode(WeaponAutoActionMode.WEAPONSELECT);
}
else {
if (this._enterAttack() === EnterResult.NOTENTER) {
return EnterResult.NOTENTER;
}
this.changeCycleMode(WeaponAutoActionMode.PREATTACK);
}
}
else {
this._changeCursorShow();
this.changeCycleMode(WeaponAutoActionMode.CURSORSHOW);
}
return EnterResult.OK;
}
var alias2 = WeaponAutoAction.moveAutoAction
WeaponAutoAction.moveAutoAction= function() {
var result = MoveResult.CONTINUE;
result = alias2.call(this);
var mode = this.getCycleMode();
if (mode === WeaponAutoActionMode.WEAPONSELECT) {
result = this._moveWeaponSelect();
}
else if (mode === WeaponAutoActionMode.DISPATTACKWINDOW) {
result = this._moveAttackWindow();
}
return result;
}
var alias3 = WeaponAutoAction.drawAutoAction
WeaponAutoAction.drawAutoAction= function() {
alias3.call(this);
var mode = this.getCycleMode();
if (mode === WeaponAutoActionMode.WEAPONSELECT) {
result = this._drawWeaponSelect();
}
else if (mode === WeaponAutoActionMode.DISPATTACKWINDOW) {
result = this._drawAttackWindow();
}
}
var alias4 = WeaponAutoAction.isSkipAllowed
WeaponAutoAction.isSkipAllowed= function() {
if( alias4.call(this) === false ) {
return false;
}
var mode = this.getCycleMode();
if (mode === WeaponAutoActionMode.WEAPONSELECT) {
return false;
}
else if (mode === WeaponAutoActionMode.DISPATTACKWINDOW) {
return false;
}
return true;
}

續:
WeaponAutoAction._moveCursorShow= function() {
var isSkipMode = this.isSkipMode();
if (isSkipMode || this._autoActionCursor.moveAutoActionCursor() !== MoveResult.CONTINUE) {
if (isSkipMode) {
this._autoActionCursor.endAutoActionCursor();
}
if (this._enterAttack() === EnterResult.NOTENTER) {
return MoveResult.END;
}
if( this._isWeaponSelectable() ) {
this.changeCycleMode(WeaponAutoActionMode.WEAPONSELECT);
}
else {
this.changeCycleMode(WeaponAutoActionMode.PREATTACK);
}
}
return MoveResult.CONTINUE;
}
WeaponAutoAction._createAttackParam= function() {
var attackParam = StructureBuilder.buildAttackParamFromCounterAttackSelect();
attackParam.unit = this._unit;
attackParam.targetUnit = this._targetUnit;
attackParam.attackStartType = AttackStartType.NORMAL;
attackParam.isNoEuipedWeapon = this._isNoEuipedWeapon;
return attackParam;
}
//-------------------------------------
// BaseAttackInfoBuilderクラス
//-------------------------------------
var alias5 = BaseAttackInfoBuilder.createAttackInfo;
BaseAttackInfoBuilder.createAttackInfo= function(attackParam) {
var attackInfo = alias5.call(this, attackParam);
// 反撃しないことを設定
if( typeof attackParam.isNoEuipedWeapon === 'number' && attackParam.isNoEuipedWeapon == 1 ) {
attackInfo.isCounterattack = false;
}
return attackInfo;
}
//=====================================
// ここから追加関数群
//=====================================
//-------------------------------------
// WeaponAutoActionクラス追加関数
//-------------------------------------
// 武器選択画面での操作
WeaponAutoAction._moveWeaponSelect= function() {
var weapon, filter, indexArray;
var unit = this._targetUnit;
var input = this._weaponSelectMenu.moveWindowManager();
if (input === ScrollbarInput.SELECT) {
weapon = this._weaponSelectMenu.getSelectWeapon();
filter = FilterControl.getReverseFilter(this._targetUnit.getUnitType());
// 選択したアイテムを装備
ItemControl.setEquippedWeapon(unit, weapon);
indexArray = AttackChecker.getAttackIndexArray(unit, weapon, false);
this._posSelector.setUnitOnly(unit, weapon, indexArray, PosMenuType.Attack, filter);
this._posSelector._posMenu.changePosTarget(this._unit);
// 武器選択したので、反撃武器ありをメンバ変数に設定
this._isNoEuipedWeapon = 0;
this.changeCycleMode(WeaponAutoActionMode.DISPATTACKWINDOW);
}
else if (NoEquipWeaponEnable == true && input === ScrollbarInput.CANCEL) {
// 武器を選択していないので、武器にnullを設定
weapon = null;
filter = FilterControl.getReverseFilter(this._targetUnit.getUnitType());
indexArray = AttackChecker.getAttackIndexArray(unit, weapon, false);
this._posSelector.setUnitOnly(unit, weapon, indexArray, PosMenuType.Attack, filter);
this._posSelector._posMenu.changePosTarget(this._unit);
// 武器を選択していないので、反撃武器なしをメンバ変数に設定
this._isNoEuipedWeapon = 1;
this.changeCycleMode(WeaponAutoActionMode.DISPATTACKWINDOW);
}
return MoveResult.CONTINUE;
}

續:
// 武器決定後の戦闘予測表示での操作
WeaponAutoAction._moveAttackWindow= function() {
var attackParam;
var result = this._posSelector.movePosSelector();
if (result === PosSelectorResult.SELECT) {
this._posSelector.endPosSelector();
attackParam = this._createAttackParam();
this._preAttack = createObject(PreAttack);
result = this._preAttack.enterPreAttackCycle(attackParam);
if (result === EnterResult.NOTENTER) {
return MoveResult.END;
}
this.changeCycleMode(WeaponAutoActionMode.PREATTACK);
}
else if (result === PosSelectorResult.CANCEL) {
this._posSelector.endPosSelector();
this.changeCycleMode(WeaponAutoActionMode.WEAPONSELECT);
}
return MoveResult.CONTINUE;
}
// 武器選択画面の描画処理
WeaponAutoAction._drawWeaponSelect= function() {
this._weaponSelectMenu.drawWindowManager();
}
// 武器決定後の戦闘予測表示の描画処理
WeaponAutoAction._drawAttackWindow= function() {
this._posSelector.drawPosSelector();
}
// 反撃時の武器選択可否判定
WeaponAutoAction._isWeaponSelectable= function() {
// 被攻撃ユニットが自軍でない場合、反撃時の武器選択は不可
if (this._targetUnit.getUnitType() !== UnitType.PLAYER) {
return false;
}
// 被攻撃ユニットがバッドステートにより行動不能なら反撃武器選択は不可
if (StateControl.isBadStateOption(this._targetUnit, BadStateOption.NOACTION)) {
return false;
}
// 被攻撃ユニットがバッドステートにより暴走中なら反撃武器選択は不可
if (StateControl.isBadStateOption(this._targetUnit, BadStateOption.BERSERK)) {
return false;
}
// 被攻撃側の武器で反撃可能か？（武器非所持、射程が合わない、敵or被攻撃側いずれかが一方通行武器、ならば反撃不可）
if (this._isCounterAttackable(this._targetUnit) === false) {
return false;
}
// 「自軍は全員無条件で反撃時に武器選択可能」では無い場合、反撃武器選択スキルを所持していなければ反撃不可
if( PlayrUnit_CounterWeaponSelectable === false ) {
if( SkillControl.getPossessionCustomSkill(this._targetUnit, WeaponSelectSkill) === null ) {
return false;
}
}
return true;
}
// 被攻撃側の武器で反撃可能かの判定
WeaponAutoAction._isCounterAttackable= function(targetUnit) {
var i, item;
var count = UnitItemControl.getPossessionItemCount(targetUnit);
var weaponCount = 0;
for (i = 0; i < count; i++) {
item = targetUnit.getItem(i);
// 被攻撃側の持つ指定武器が反撃可能ならば、trueを返す
if (this._isWeaponAllowed(targetUnit, item)) {
return true;
}
}
return false;
}
// 被攻撃側の持つ指定武器は反撃可能かの判定
WeaponAutoAction._isWeaponAllowed= function(unit, item) {
// 被攻撃側が指定武器を装備出来ない（装備出来ない武器を持っていたorステートにより武器を使えない）場合は反撃不可
if (!ItemControl.isWeaponAvailable(unit, item)) {
return false;
}
// 指定武器の射程が合うか、敵or被攻撃側いずれかが一方通行武器、などをチェック
var result = AttackChecker.isCounterAttackableWeapon(this._weapon, this._enemyX, this._enemyY, unit, item, this._targetUnit);
return result;
}
//-------------------------------------
// StructureBuilder（新規関数追加）
//-------------------------------------
StructureBuilder.buildAttackParamFromCounterAttackSelect= function() {
return {
unit: null,
targetUnit: null,
attackStartType: 0,
forceBattleObject: null,
fusionAttackData: null,
isNoEuipedWeapon: 0
};
}
//-------------------------------------
// AttackChecker（新規関数追加）
//-------------------------------------
// counterUnitがcounterWeaponで反撃できるかどうかを調べる
// （enemyWeapon：敵の使用武器、unitx：敵X座標、unity：敵Y座標。敵の使用武器や座標を敵unitから取得できないので上位から引き渡している）
AttackChecker.isCounterAttackableWeapon= function(enemyWeapon, unitx, unity, counterUnit, counterWeapon, enemyUnit) {
var indexArray;
if (!Calculator.isCounterattackAllowed(enemyUnit, counterUnit)) {
return false;
}
if (enemyWeapon !== null && enemyWeapon.isOneSide()) {
// 敵が「一方向」の武器を装備している場合は、反撃は発生しない
return false;
}
// 反撃用の武器を所持していない場合は反撃できない
if (counterWeapon === null) {
return false;
}
// 「一方向」の武器は反撃できない
if (counterWeapon.isOneSide()) {
return false;
}
indexArray = IndexArray.createIndexArray(counterUnit.getMapX(), counterUnit.getMapY(), counterWeapon);
// 反撃側の武器で、攻撃側の座標を攻撃可能かチェック
var result = IndexArray.findPos(indexArray, unitx, unity);
return result;
};
//-------------------------------------

敵軍選擇武器反撃:
/*--------------------------------------------------------------------------
　自軍が攻撃した時に、敵が反撃可能武器に切り替えてくるスクリプト
■概要
自軍ユニットが敵を攻撃した際、敵が所持している武器の中で反撃可能な武器を自動で選択します。
（反撃可能武器の中で一番先に検出した武器を使用します。威力や命中が最適であるかは現在考慮してません）
■カスタマイズ
　１．同盟ユニットも反撃可能な武器を自動で選択するようにしたい
　　　→「var IS_ATTACKABLE_ALLY_ENABLE = false;」のfalseをtrueに書き換えてください
　２．敵（IS_ATTACKABLE_ALLY_ENABLE=trueなら同盟ユニットも）の一部だけ反撃可能な武器を自動で選択するようにしたい
　　　→「var IS_ATTACKABLE_AUTO_ENABLE = true;」のtrueをfalseに書き換えてください
　　　　その上で、キーワードに'sokuou'を入れたカスタムスキルを敵（同盟）ユニットに持たせてください
　　　　（クラススキルでもユニットスキルでも構いません）
　３．カスタムスキルのキーワードを変えたい
　　　→「var ATTACKABLE_SKILL_KEYWORD = 'sokuou';」のsokuouの部分を違うキーワードに変えてください
　４．反撃武器選択時、反撃可能な中で一番スコアがいい武器を選択したい
　　　→「var IS_CALCULATE_SCORE = false;」のfalseをtrueに書き換えてください
16/11/06 新規作成
16/11/07 設定を幾つか追加
17/04/15 反撃武器選択時、反撃可能な中で一番スコアがいい武器を選択する設定を追加（AIScorer.Weapon.getScore()の値が一番良い武器）
17/11/29 1.164対応
18/01/16 記述ミスにより、自軍ユニットにも「敵が反撃武器選択」の効果が発生していたバグを修正
（敵が1歩移動して攻撃してきた場合、自分は剣装備で手槍を所持していると発生）
19/04/05 superbow1.2改.txtとの競合対策実施
19/10/29 行動不能のステートになっている場合、反撃武器の選択を行わないよう修正
■対応バージョン
　SRPG Studio Version:1.206
■規約
・利用はSRPG Studioを使ったゲームに限ります。
・商用・非商用問いません。フリーです。
・加工等、問題ありません。どんどん改造してください。
・クレジット明記無し　OK
・再配布、転載　OK
・SRPG Studio利用規約は遵守してください。
--------------------------------------------------------------------------*/
(function() {
//-----------------------------------
// 設定
//-----------------------------------
// 同盟ユニットが自動反撃武器選択を行うか
var IS_ATTACKABLE_ALLY_ENABLE = true; // true：自動反撃武器選択を行う false:行わない
// 敵ユニットが（IS_ATTACKABLE_ALLY_ENABLE=trueなら同盟ユニットも）カスタムスキルなしで自動反撃武器選択を行うか
var IS_ATTACKABLE_AUTO_ENABLE = false; // true：カスタムスキルなしで自動反撃武器選択可能 false:カスタムスキルがないと自動反撃武器選択できない
// 反撃武器選択時、反撃可能な中で一番スコアがいい武器を選択するか
var IS_CALCULATE_SCORE = true; // true：スコアが一番良いものを選択 false:反撃可能な一番上の武器を選択
// カスタムスキルのキーワード
var ATTACKABLE_SKILL_KEYWORD = 'sokuou'; // IS_ATTACKABLE_AUTO_ENABLE = falseの場合、このキーワードのカスタムスキルを所持していないと自動反撃武器選択は行えない
//-------------------------------------

續--敵軍選擇武器反撃:
// PosMenuクラス
//-------------------------------------
PosMenu.changePosTarget= function(targetUnit) {
var targetItem, isLeft;
if (this._unit === null || !this._isTargetAllowed(targetUnit)) {
this._currentTarget = null;
return;
}
this._currentTarget = targetUnit;
// 攻撃対象がプレイヤーユニットでない場合は、反撃可能な武器を自動選択
if( ItemControl.isAttackableWeapon(targetUnit) == true ) {
targetItem = ItemControl.getAttackableWeapon(targetUnit, this._unit);
if( targetItem != null ) {
ItemControl.setEquippedWeapon(targetUnit, targetItem);
}
}
targetItem = ItemControl.getEquippedWeapon(targetUnit);
// srcを常に左側に表示するものとする
isLeft = Miscellaneous.isUnitSrcPriority(this._unit, targetUnit);
// 自軍を左側に表示することを優先している(左側の方が見やすいと判断)
// このため、自軍が仕掛けた場合は当然左側に表示されるが、
// 自軍が仕掛けられた場合でも左側に表示される。
// 両方、自軍である場合は仕掛けた方を左側に表示する。
if (isLeft) {
// 仕掛けたのは自軍であるため、これを_posWindowLeftに指定
this._posWindowLeft.setPosTarget(this._unit, this._item, targetUnit, targetItem, true);
this._posWindowRight.setPosTarget(targetUnit, targetItem, this._unit, this._item, false);
}
else {
// 仕掛けたのは自軍ではない。
// この場合、targetUnitが自軍であるため、これを_posWindowLeftに指定。
this._posWindowLeft.setPosTarget(targetUnit, targetItem, this._unit, this._item, true);
this._posWindowRight.setPosTarget(this._unit, this._item, targetUnit, targetItem, false);
}
}
//-------------------------------------
// ItemControlクラス
//-------------------------------------
// 被攻撃側が、攻撃側に自動反撃可能かどうかの判定
ItemControl.isAttackableWeapon= function(unit) {
// 自軍ユニットの場合は自動反撃武器選択は行わない
if( unit.getUnitType() == UnitType.PLAYER ) {
return false;
}
// 同盟ユニットの場合、IS_ATTACKABLE_ALLY_ENABLEがtrueでない場合は自動反撃武器選択は行わない
if( unit.getUnitType() == UnitType.ALLY && IS_ATTACKABLE_ALLY_ENABLE == false ) {
return false;
}
// 自動反撃武器選択フラグ（IS_ATTACKABLE_AUTO_ENABLE）がfalse、かつ、
// キーワード（ATTACKABLE_SKILL_KEYWORD）のカスタムスキル未所持なら自動反撃武器選択は行わない
if( IS_ATTACKABLE_AUTO_ENABLE == false && !SkillControl.getPossessionCustomSkill(unit, ATTACKABLE_SKILL_KEYWORD) ) {
return false;
}
// 行動不能の場合はfalseを返す
if (StateControl.isBadStateOption(unit, BadStateOption.NOACTION)) {
return false;
}
// 自動反撃武器選択フラグ（IS_ATTACKABLE_AUTO_ENABLE）がtrue、または、
// カスタムスキル名（ATTACKABLE_SKILL_NAME）のスキルを所持するユニットなら自動反撃武器選択を行う
return true;
}
// 被攻撃側で、攻撃側に反撃可能な武器を探して取得する
// 反撃可能な一番上の武器を使用する場合
if( IS_CALCULATE_SCORE == false ) {
ItemControl.getAttackableWeapon= function(targetUnit, unit) {
var indexArray;
var weapon;
var count;
var i;
var targetweapon;
var result;
// 反撃が許可されていない場合は処理終了
if (!Calculator.isCounterattackAllowed(unit, targetUnit)) {
return null;
}
weapon = ItemControl.getEquippedWeapon(unit);
if (weapon !== null && weapon.isOneSide()) {
// 攻撃側が「一方向」の武器を装備している場合は、反撃出来ない為処理終了
return null;
}
count = UnitItemControl.getPossessionItemCount(targetUnit);
// 所持ている武器の中から、反撃可能な武器を探す
for (i = 0; i < count; i++) {
targetweapon = UnitItemControl.getItem(targetUnit, i);
if (targetweapon !== null && this.isWeaponAvailable(targetUnit, targetweapon)) {
// 「一方向」の武器は反撃できない
if (targetweapon.isOneSide()) {
continue;
}
// superbow1.2改.txtが無い場合はこちら
if( typeof SKILL_SUPERBOW_USE_ENABLE === 'undefined' || SKILL_SUPERBOW_USE_ENABLE !== true ) {
indexArray = IndexArray.createIndexArray(targetUnit.getMapX(), targetUnit.getMapY(), targetweapon);
}
// superbow1.2改.txtが入っていれば強弓などを加味する
else {
skill_superbow = SkillControl.getPossessionCustomSkill(targetUnit,'superbow');
skill_proximity = SkillControl.getPossessionCustomSkill(targetUnit,'Proximity_fire');
indexArray = IndexArray.createsuperbowBySkill(targetUnit.getMapX(), targetUnit.getMapY(), targetweapon, skill_superbow, skill_proximity);
}
// 反撃側の武器で、攻撃側の座標を攻撃可能ならばその武器を返す
// 一番最初に検出した反撃可能な武器を返している（最適な武器を取り出していない）
result = IndexArray.findPos(indexArray, unit.getMapX(), unit.getMapY());
if( result == true ) {
return targetweapon;
}
}
}
return null;
};
}

續--敵軍選擇武器反撃:
// スコアが一番良いものを使用する場合
else {
ItemControl.getAttackableWeapon= function(targetUnit, unit) {
var indexArray;
var weapon;
var count;
var i;
var targetweapon;
var result;
var skill_superbow;
var skill_proximity;
var maxWeapon = null;
var max_score = 0;
var score = 0;
var combination = {};
combination.targetUnit = unit;
combination.plusScore = 0;
// 反撃が許可されていない場合は処理終了
if (!Calculator.isCounterattackAllowed(unit, targetUnit)) {
return null;
}
weapon = ItemControl.getEquippedWeapon(unit);
if (weapon !== null && weapon.isOneSide()) {
// 攻撃側が「一方向」の武器を装備している場合は、反撃出来ない為処理終了
return null;
}
count = UnitItemControl.getPossessionItemCount(targetUnit);
// 所持ている武器の中から、反撃可能な武器を探す
for (i = 0; i < count; i++) {
targetweapon = UnitItemControl.getItem(targetUnit, i);
if (targetweapon !== null && this.isWeaponAvailable(targetUnit, targetweapon)) {
// 「一方向」の武器は反撃できない
if (targetweapon.isOneSide()) {
continue;
}
// superbow1.2改.txtが無い場合はこちら
if( typeof SKILL_SUPERBOW_USE_ENABLE === 'undefined' || SKILL_SUPERBOW_USE_ENABLE !== true ) {
indexArray = IndexArray.createIndexArray(targetUnit.getMapX(), targetUnit.getMapY(), targetweapon);
}
// superbow1.2改.txtが入っていれば強弓などを加味する
else {
skill_superbow = SkillControl.getPossessionCustomSkill(targetUnit,'superbow');
skill_proximity = SkillControl.getPossessionCustomSkill(targetUnit,'Proximity_fire');
indexArray = IndexArray.createsuperbowBySkill(targetUnit.getMapX(), targetUnit.getMapY(), targetweapon, skill_superbow, skill_proximity);
}
// 反撃側の武器で、攻撃側の座標を攻撃可能ならばその武器のスコアを算出し
// 一番スコアがいい武器を返す
result = IndexArray.findPos(indexArray, unit.getMapX(), unit.getMapY());
if( result == true ) {
combination.item = targetweapon;
score = AIScorer.Weapon.getScore(targetUnit, combination);
// 反撃可能武器のスコア（デバッグ用）
//root.log(targetweapon.getName()+':'+score);
if( score > max_score ) {
max_score = score;
maxWeapon = targetweapon;
}
}
}
}
// 選んだ反撃可能武器のスコア（デバッグ用）
//if( maxWeapon != null){
// root.log('result '+maxWeapon.getName()+':'+max_score);
//}
//else{
// root.log('result maxWeapon null');
//}
return maxWeapon;
};
}
//-------------------------------------

續--敵軍選擇武器反撃:
// AttackCheckerクラス
//-------------------------------------
// 反撃可能かのチェック（座標単位）※敵AIで、反撃のスコア算出時のみ呼び出されている関数に武器持ち替え処理を追加した
AttackChecker.isCounterattackPos= function(unit, targetUnit, x, y) {
var indexArray;
var weapon;
// 敵、同盟ユニットが自動反撃可能ならば反撃可能な武器に持ち替える
if( ItemControl.isAttackableWeapon(targetUnit) == true ) {
weapon = ItemControl.getAttackableWeapon(targetUnit, unit);
if (weapon === null) {
return false;
}
ItemControl.setEquippedWeapon(targetUnit, weapon);
}
// 敵、同盟ユニットが自動反撃可能でなければ通常通り
else {
weapon = ItemControl.getEquippedWeapon(targetUnit);
if (weapon === null) {
return false;
}
}
// superbow1.2改.txtが無い場合はこちら
if( typeof SKILL_SUPERBOW_USE_ENABLE === 'undefined' || SKILL_SUPERBOW_USE_ENABLE !== true ) {
indexArray = IndexArray.createIndexArray(targetUnit.getMapX(), targetUnit.getMapY(), weapon);
}
// superbow1.2改.txtが入っていれば強弓などを加味する
else {
var skill_superbow = SkillControl.getPossessionCustomSkill(targetUnit,'superbow');
var skill_proximity = SkillControl.getPossessionCustomSkill(targetUnit,'Proximity_fire');
indexArray = IndexArray.createsuperbowBySkill(targetUnit.getMapX(), targetUnit.getMapY(), weapon, skill_superbow, skill_proximity);
}
return IndexArray.findPos(indexArray, x, y);
}
})();