游戏字体无法更改颜色怎么办？

造小梦 · 发表于 2019-3-23 00:04:19

加入我们，或者，欢迎回来。

您需要登录才可以下载或查看，没有帐号？注册会员

x

如图所示，字体无法显示原来的颜色，这是怎么回事？？？

造小梦 · 发表于 2019-3-24 17:36:41

百里_飞柳发表于 2019-3-24 17:26
#HPのスキルコスト表示色（テキストカラーIDに準じる）

HPCC = 2

我已经改过来了，不过还是谢谢你了，能这么耐心地教我

百里_飞柳 · 发表于 2019-3-24 17:26:22

造小梦发表于 2019-3-24 17:13
找不到。。。搜不到指定的文本

  #HPのスキルコスト表示色（テキストカラーIDに準じる）

  HPCC = 2

  #MPのスキルコスト表示色（テキストカラーIDに準じる）

  MPCC = 23

  #TPのスキルコスト表示色（テキストカラーIDに準じる）

  TPCC = 29

脚本中的这个地方是对各种消耗的颜色定义，但是估计原作者自己也没用过，所以都没发现这个转义符的问题

在对应的获取各种值的颜色转义符的方法中，是使用了它自己的 \ALPHAC 转义符
但是在它对于Window_Base类的转义符的扩展处理中，却没有这个转义符了，可以看出是忘了改

#新たな制御文字として\ALPHACを加える。
#\ALPHACは、文字色変更時に透過度を保持する。
alias process_escape_character_extra_cost process_escape_character
def process_escape_character(code, text, pos)
if code.upcase == 'C'
alpha = contents.font.color.alpha
change_color(text_color(obtain_escape_param(text)))
contents.font.color.alpha = alpha
return
end
process_escape_character_extra_cost(code, text, pos)
end

复制代码

改成

#新たな制御文字として\ALPHACを加える。
#\ALPHACは、文字色変更時に透過度を保持する。
alias process_escape_character_extra_cost process_escape_character
def process_escape_character(code, text, pos)
if code.upcase == 'ALPHAC'
alpha = contents.font.color.alpha
change_color(text_color(obtain_escape_param(text)))
contents.font.color.alpha = alpha
return
end
process_escape_character_extra_cost(code, text, pos)
end

复制代码

造小梦 · 发表于 2019-3-24 17:23:15

百里_飞柳发表于 2019-3-24 12:41
大概你加了什么技能消耗的扩展，然后里面有定义绘制前加的转义符，于是你自己加了\c的转义符来修改颜色？
...

好吧。。。我找到了。。。我把C改成ALPHAC就好了。。。

造小梦 · 发表于 2019-3-24 17:13:41

百里_飞柳发表于 2019-3-24 12:41
大概你加了什么技能消耗的扩展，然后里面有定义绘制前加的转义符，于是你自己加了\c的转义符来修改颜色？
...

找不到。。。搜不到指定的文本

造小梦 · 发表于 2019-3-24 14:46:24

百里_飞柳发表于 2019-3-24 12:41
大概你加了什么技能消耗的扩展，然后里面有定义绘制前加的转义符，于是你自己加了\c的转义符来修改颜色？
...

还有这个

module IS_USABLE
#使用条件用ワード
WORD_BASE = "使用条件"
#アクター専用条件化
WORD_ACTOR = "アクター用"
#エネミー専用条件化
WORD_ENEMY = "エネミー用"
#条件の判別を味方全体化
WORD_F_ALL = "*味全*"
#条件の判別を敵全体化
WORD_O_ALL = "*敵全*"
#条件の判別を敵・味方全体化
WORD_A_ALL = "*敵味全*"
#条件の判別を味方全体化
WORD_ACTOR_A = "A"
#条件の判別を味方全体化
WORD_PARTY_P = "P"
#条件の判別を味方全体化
WORD_ENEMY_E = "E"
#条件の判別を味方全体化
WORD_TROOP_T = "T"
#能力値・変数の場合の設定
#～より上
WORD_A = "超过"
#～以上
WORD_B = "以上"
#～より下
WORD_C = "未满"
#～以下
WORD_D = "以下"
#～と同じ数値
WORD_E = "相同"
#～と同じ数値ではない
WORD_F = "以外"
#スイッチの場合の設定
#ONの場合
WORD_G = "关闭"
#OFFの場合
WORD_H = "开启"
#ステート・パーティの場合の設定
#ONの場合
WORD_I = "前提"
#OFFの場合
WORD_J = "禁止"
#数値単位の指定（現在HP・現在MP・現在TP関連のみ有効）
#ONの場合
WORD_K = "数值"
#OFFの場合
WORD_L = "割合"
#スクリプトの場合、エラーとなった際の設定
#ONの場合
WORD_M = "OK"
#OFFの場合
WORD_N = "NG"
#能力値名設定
#現在HP
WORD1 = "HP"
#現在MP
WORD2 = "MP"
#現在TP
WORD3 = "TP"
#最大HP
WORD4 = "MHP"
#最大MP
WORD5 = "MMP"
#攻撃力
WORD6 = "ATK"
#防御力
WORD7 = "DEF"
#魔法力
WORD8 = "MAT"
#魔法防御
WORD9 = "MDF"
#敏捷性
WORD10 = "AGI"
#運
WORD11 = "LUK"
#命中率
WORD12 = "HIT"
#回避率
WORD13 = "EVA"
#会心率
WORD14 = "CRI"
#会心回避率
WORD15 = "CEV"
#魔法回避率
WORD16 = "MEV"
#魔法反射率
WORD17 = "MRF"
#反撃率
WORD18 = "CNT"
#HP再生率
WORD19 = "HRG"
#MP再生率
WORD20 = "MRG"
#TP再生率
WORD21 = "TRG"
#狙われ率
WORD22 = "TGR"
#防御効果率
WORD23 = "GRD"
#回復効果率
WORD24 = "REC"
#薬の知識
WORD25 = "PHA"
#MP消費率
WORD26 = "MCR"
#TPチャージ率
WORD27 = "TCR"
#物理ダメージ率
WORD28 = "PDR"
#魔法ダメージ率
WORD29 = "MDR"
#床ダメージ率
WORD30 = "FDR"
#経験獲得率
WORD31 = "EXR"
#属性有効度
WORD32 = "ELP"
#弱体有効度
WORD33 = "DBP"
#ステート有効度
WORD34 = "STP"
#状态
WORD35 = "STT"
#开关
WORD36 = "SWT"
#変数
WORD37 = "VAR"
#敵で特定ステートにかかっている者の数
WORD38 = "OPS"
#味方で特定ステートにかかっている者の数
WORD39 = "FRS"
#敵で生存している者の数
WORD40 = "OPA"
#味方で生存している者の数
WORD41 = "FRA"
#敵で死亡している者の数
WORD42 = "OPD"
#味方で死亡している者の数
WORD43 = "FRD"
#敵で行動可能者の数
WORD44 = "OPM"
#味方で行動可能者の数
WORD45 = "FRM"
#敵で行動不能者の数
WORD46 = "ONM"
#味方で行動不能者の数
WORD47 = "FNM"
#敵の現在HP平均値
WORD48 = "OHA"
#味方の現在HP平均値
WORD49 = "FHA"
#敵の現在MP平均値
WORD50 = "OMA"
#味方の現在MP平均値
WORD51 = "FMA"
#敵の現在TP平均値
WORD52 = "OTA"
#味方の現在TP平均値
WORD53 = "FTA"
#敵の現在HP合計値
WORD54 = "OHT"
#味方の現在HP合計値
WORD55 = "FHT"
#敵の現在MP合計値
WORD56 = "OMT"
#味方の現在MP合計値
WORD57 = "FMT"
#敵の現在TP合計値
WORD58 = "OTT"
#味方の現在TP合計値
WORD59 = "FTT"
#パーティ/敵グループ内にいるかどうかの判定
#アクターの場合はパーティにいるか否かと戦闘メンバーにいるか否か
#エネミーの場合は敵グループにいるか否かと隠れているか否かを判定
WORD60 = "API"
#スクリプトを用いた特殊な判定
#スクリプトにある程度理解がある方向け
WORD61 = "SCR"
end
class Game_BattlerBase
#--------------------------------------------------------------------------
# スキル／アイテムの共通使用可能条件チェック1
#--------------------------------------------------------------------------
alias usable_item_conditions_met_ex1? usable_item_conditions_met?
def usable_item_conditions_met?(item)
#本来の処理と追加条件を判定する。
#両方の条件を満たしているか否かを返す。
usable_item_conditions_met_ex1?(item) && usable_item_conditions_met_ex2?(item)
end
#--------------------------------------------------------------------------
# スキル／アイテムの共通使用可能条件チェック2
#--------------------------------------------------------------------------
def usable_item_conditions_met_ex2?(item)
#追加条件のハッシュを取得する。
base_data = item.use_condition_array
#追加条件が何も存在しない場合はtrueを返す。
return true if base_data.empty?
#追加条件をそれぞれ判定する。
base_data.each {|use_condition|
#データタイプを初期化する。
data_type = 0
#判定対象を取得する。
case use_condition[:condition_target]
#明確な設定が無い場合、まず対象用の空の配列を作成する。
when 0;condition_target = []
#アクター用配列が空ではない時
if !use_condition[:array_a].empty?
#配列の要素別に判定する。
use_condition[:array_a].each {|i|
#対象の配列に加える。
condition_target.push($game_actors[i.to_i])
}
#パーティ用配列が空ではない時
elsif !use_condition[:array_p].empty?
#配列の要素別に判定する。
use_condition[:array_p].each {|i|
#該当者が存在しない場合は条件を満たさない物とする。
return false unless $game_party.members[i.to_i - 1]
#対象の配列に加える。
condition_target.push($game_party.members[i.to_i - 1])
}
#エネミー用配列が空ではない時
elsif !use_condition[:array_e].empty?
#配列の要素別に判定する。
use_condition[:array_e].each {|i|
#該当するエネミーIDを持つ敵を選別する。
tm = $game_troop.members.select {|m| m.enemy_id == i.to_i}
#対象の配列に加える。
condition_target = condition_target + tm unless tm.empty?
}
#敵グループ用配列が空ではない時
elsif !use_condition[:array_t].empty?
#配列の要素別に判定する。
use_condition[:array_t].each {|i|
#該当者が存在しない場合は条件を満たさない物とする。
return false unless $game_troop.members[i.to_i - 1]
condition_target.push($game_troop.members[i.to_i - 1] )
}
#どれにも該当しない時（自分のみ）
else;condition_target.push(self)
end
#味方グループの場合
when 1;condition_target = friends_unit.members
#敵グループの場合
when 2;condition_target = opponents_unit.members
#敵グループと味方グループ全体の場合
when 3;condition_target = friends_unit.members + opponents_unit.members
end
#該当者が存在しない場合はfalseを返す。
return false if condition_target.empty?
#判定対象別に条件を判定する。
condition_target.each {|character|
#対象が存在しない場合は飛ばす。
next unless character
#条件がアクター専用/エネミー専用か否かを判定し
#当てはまらない場合は処理を飛ばす。
case use_condition[:user_type]
#アクター専用
when 1;next if !character.actor?
#エネミー専用
when 2;next if character.actor?
end
#条件の配列を取得する。
array = use_condition[:array]
#配列の1つ目の値で種類分けを行う。
case array[0]
#現在HP（データタイプ1）
when IS_USABLE::WORD1;data_type = 1
#配列の2番目の文字列で数値か割合かを判定。
case array[1]
#数値の場合
when IS_USABLE::WORD_K;data = character.hp
#割合の場合
when IS_USABLE::WORD_L;data = character.hp_rate * 100
end
#現在MP（データタイプ1）
when IS_USABLE::WORD2;data_type = 1
#配列の2番目の文字列で数値か割合かを判定。
case array[1]
#数値の場合
when IS_USABLE::WORD_K;data = character.mp
#割合の場合
when IS_USABLE::WORD_L;data = character.mp_rate * 100
end
#現在TP（データタイプ1）
when IS_USABLE::WORD3;data_type = 1
#配列の2番目の文字列で数値か割合かを判定。
case array[1]
#数値の場合
when IS_USABLE::WORD_K;data = character.tp
#割合の場合
when IS_USABLE::WORD_L;data = character.tp_rate * 100
end
#最大HP（データタイプ0）
when IS_USABLE::WORD4;data = character.param(0)
#最大MP（データタイプ0）
when IS_USABLE::WORD5;data = character.param(1)
#攻撃力（データタイプ0）
when IS_USABLE::WORD6;data = character.param(2)
#防御力（データタイプ0）
when IS_USABLE::WORD7;data = character.param(3)
#魔法力（データタイプ0）
when IS_USABLE::WORD8;data = character.param(4)
#魔法防御（データタイプ0）
when IS_USABLE::WORD9;data = character.param(5)
#敏捷性（データタイプ0）
when IS_USABLE::WORD10;data = character.param(6)
#運（データタイプ0）
when IS_USABLE::WORD11;data = character.param(7)
#命中率（データタイプ0）
when IS_USABLE::WORD12;data = character.xparam(0) * 100
#回避率（データタイプ0）
when IS_USABLE::WORD13;data = character.xparam(1) * 100
#会心率（データタイプ0）
when IS_USABLE::WORD14;data = character.xparam(2) * 100
#会心回避率（データタイプ0）
when IS_USABLE::WORD15;data = character.xparam(3) * 100
#魔法回避率（データタイプ0）
when IS_USABLE::WORD16;data = character.xparam(4) * 100
#魔法反射率（データタイプ0）
when IS_USABLE::WORD17;data = character.xparam(5) * 100
#反撃率（データタイプ0）
when IS_USABLE::WORD18;data = character.xparam(6) * 100
#HP再生率（データタイプ0）
when IS_USABLE::WORD19;data = character.xparam(7) * 100
#MP再生率（データタイプ0）
when IS_USABLE::WORD20;data = character.xparam(8) * 100
#TP再生率（データタイプ0）
when IS_USABLE::WORD21;data = character.xparam(9) * 100
#狙われ率（データタイプ0）
when IS_USABLE::WORD22;data = character.sparam(0) * 100
#防御効果率（データタイプ0）
when IS_USABLE::WORD23;data = character.sparam(1) * 100
#回復効果率（データタイプ0）
when IS_USABLE::WORD24;data = character.sparam(2) * 100
#薬の知識（データタイプ0）
when IS_USABLE::WORD25;data = character.sparam(3) * 100
#MP消費率（データタイプ0）
when IS_USABLE::WORD26;data = character.sparam(4) * 100
#TPチャージ率（データタイプ0）
when IS_USABLE::WORD27;data = character.sparam(5) * 100
#物理ダメージ率（データタイプ0）
when IS_USABLE::WORD28;data = character.sparam(6) * 100
#魔法ダメージ率（データタイプ0）
when IS_USABLE::WORD29;data = character.sparam(7) * 100
#床ダメージ率（データタイプ0）
when IS_USABLE::WORD30;data = character.sparam(8) * 100
#経験獲得率（データタイプ0）
when IS_USABLE::WORD31;data = character.sparam(9) * 100
#属性有効度（データタイプ1）
when IS_USABLE::WORD32;data_type = 1
data = character.element_rate(array[1].to_i) * 100
#弱体有効度（データタイプ1）
when IS_USABLE::WORD33;data_type = 1
data = character.debuff_rate(array[1].to_i) * 100
#ステート有効度（データタイプ1）
when IS_USABLE::WORD34;data_type = 1
data = character.state_rate(array[1].to_i) * 100
#ステート（データタイプ2）
when IS_USABLE::WORD35;data_type = 2
#スイッチ（データタイプ3）
when IS_USABLE::WORD36;data_type = 3
#変数（データタイプ1）
when IS_USABLE::WORD37;data_type = 1
data = $game_variables[(array[1]).to_i]
#敵で特定ステートにかかっている者の数（データタイプ1）
when IS_USABLE::WORD38;data_type = 1
data = opponents_unit.members_state_check((array[1]).to_i)
#味方で特定ステートにかかっている者の数（データタイプ1）
when IS_USABLE::WORD39;data_type = 1
data = friends_unit.members_state_check((array[1]).to_i)
#敵で生存している者の数（データタイプ0）
when IS_USABLE::WORD40;data = opponents_unit.alive_members.size
#味方で生存している者の数（データタイプ0）
when IS_USABLE::WORD41;data = friends_unit.alive_members.size
#敵で死亡している者の数（データタイプ0）
when IS_USABLE::WORD42;data = opponents_unit.dead_members.size
#味方で死亡している者の数（データタイプ0）
when IS_USABLE::WORD43;data = friends_unit.dead_members.size
#敵で行動可能者の数（データタイプ0）
when IS_USABLE::WORD44;data = opponents_unit.movable_members_ex.size
#味方で行動可能者の数（データタイプ0）
when IS_USABLE::WORD45;data = friends_unit.movable_members_ex.size
#敵で行動不能者の数（データタイプ0）
when IS_USABLE::WORD46;data = opponents_unit.not_movable_members_ex.size
#味方で行動不能者の数（データタイプ0）
when IS_USABLE::WORD47;data = friends_unit.not_movable_members_ex.size
#敵の現在HP平均値（データタイプ1）
when IS_USABLE::WORD48;data_type = 1
#配列の2番目の文字列で数値か割合かを判定。
case array[1]
#数値の場合
when IS_USABLE::WORD_K;data = opponents_unit.hp(0)
#割合の場合
when IS_USABLE::WORD_L;data = opponents_unit.hp(1)
end
#味方の現在HP平均値（データタイプ1）
when IS_USABLE::WORD49;data_type = 1
#配列の2番目の文字列で数値か割合かを判定。
case array[1]
#数値の場合
when IS_USABLE::WORD_K;data = friends_unit.hp(0)
#割合の場合
when IS_USABLE::WORD_L;data = friends_unit.hp(1)
end
#敵の現在MP平均値（データタイプ1）
when IS_USABLE::WORD50;data_type = 1
#配列の2番目の文字列で数値か割合かを判定。
case array[1]
#数値の場合
when IS_USABLE::WORD_K;data = opponents_unit.mp(0)
#割合の場合
when IS_USABLE::WORD_L;data = opponents_unit.mp(1)
end
#味方の現在MP平均値（データタイプ1）
when IS_USABLE::WORD51;data_type = 1
#配列の2番目の文字列で数値か割合かを判定。
case array[1]
#数値の場合
when IS_USABLE::WORD_K;data = friends_unit.mp(0)
#割合の場合
when IS_USABLE::WORD_L;data = friends_unit.mp(1)
end
#敵の現在TP平均値（データタイプ1）
when IS_USABLE::WORD52;data_type = 1
#配列の2番目の文字列で数値か割合かを判定。
case array[1]
#数値の場合
when IS_USABLE::WORD_K;data = opponents_unit.tp(0)
#割合の場合
when IS_USABLE::WORD_L;data = opponents_unit.tp(1)
end
#味方の現在TP平均値（データタイプ1）
when IS_USABLE::WORD53;data_type = 1
#配列の2番目の文字列で数値か割合かを判定。
case array[1]
#数値の場合
when IS_USABLE::WORD_K;data = friends_unit.tp(0)
#割合の場合
when IS_USABLE::WORD_L;data = friends_unit.tp(1)
end
#敵の現在HP合計値（データタイプ0）
when IS_USABLE::WORD54;data = opponents_unit.hptotal
#味方の現在HP合計値（データタイプ0）
when IS_USABLE::WORD55;data = friends_unit.hptotal
#敵の現在MP合計値（データタイプ0）
when IS_USABLE::WORD56;data = opponents_unit.mptotal
#味方の現在MP合計値（データタイプ0）
when IS_USABLE::WORD57;data = friends_unit.mptotal
#敵の現在TP合計値（データタイプ0）
when IS_USABLE::WORD58;data = opponents_unit.tptotal
#味方の現在TP合計値（データタイプ0）
when IS_USABLE::WORD59;data = friends_unit.tptotal
#味方の現在TP合計値（データタイプ4）
when IS_USABLE::WORD60;data_type = 4
#スクリプト（データタイプ5）
when IS_USABLE::WORD61;data_type = 5
end
#データタイプで分岐。
case data_type
#データタイプが0の場合、まず取得したデータを整数化してから処理を続行。
when 0;data = data.to_i
#配列内の3番目の文字列で分岐。
case array[2]
#超過
when IS_USABLE::WORD_A;return false if data <= array[1].to_i
#以上
when IS_USABLE::WORD_B;return false if data < array[1].to_i
#未満
when IS_USABLE::WORD_C;return false if data >= array[1].to_i
#以下
when IS_USABLE::WORD_D;return false if data > array[1].to_i
#同値
when IS_USABLE::WORD_E;return false if data != array[1].to_i
#以外
when IS_USABLE::WORD_F;return false if data == array[1].to_i
end
#データタイプが1の場合、まず取得したデータを整数化してから処理を続行。
when 1;data = data.to_i
#配列内の4番目の文字列で分岐。
case array[3]
#超過
when IS_USABLE::WORD_A;return false if data <= array[2].to_i
#以上
when IS_USABLE::WORD_B;return false if data < array[2].to_i
#未満
when IS_USABLE::WORD_C;return false if data >= array[2].to_i
#以下
when IS_USABLE::WORD_D;return false if data > array[2].to_i
#同値
when IS_USABLE::WORD_E;return false if data != array[2].to_i
#以外
when IS_USABLE::WORD_F;return false if data == array[2].to_i
end
#データタイプが2の場合
when 2
#ステートIDを取得。
data = array[1].to_i
#配列内の3番目の文字列で分岐。
case array[2]
#ステートにかかっているか？
when IS_USABLE::WORD_I;return false unless character.state?(data)
#ステートにかかっていないか？
when IS_USABLE::WORD_J;return false if character.state?(data)
end
#データタイプが3の場合
when 3
#スイッチIDを取得。
data = $game_switches[(array[1]).to_i]
#配列内の3番目の文字列で分岐。
case array[2]
#スイッチがONか？
when IS_USABLE::WORD_G;return false unless data
#スイッチがOFFか？
when IS_USABLE::WORD_H;return false if data
end
#データタイプが4の場合
when 4
#キャラクターがアクターかどうかを判定。
if character.actor?
#配列の2番目の文字列で分岐。
case array[1]
#PT内にいなければならないか？
when IS_USABLE::WORD_I;
return false unless $game_party.all_members.include?(character)
#配列の3番目の文字列で分岐。
case array[2]
#戦闘メンバー内にいなければならないか？
when IS_USABLE::WORD_I;return false unless $game_party.members.include?(character)
#戦闘メンバー内にいてはならないか？
when IS_USABLE::WORD_J;return false if $game_party.members.include?(character)
end
#PT内にいてはならないか？
when IS_USABLE::WORD_J;return false if $game_party.all_members.include?(character)
end
else
#配列の2番目の文字列で分岐。
case array[1]
#PT内にいなければならないか？
when IS_USABLE::WORD_I;
return false unless $game_troop.members.include?(character)
#配列の3番目の文字列で分岐。
case array[2]
#戦闘メンバー内にいなければならないか？
when IS_USABLE::WORD_I;return false unless character.hidden?
#戦闘メンバー内にいてはならないか？
when IS_USABLE::WORD_J;return false if character.hidden?
end
#PT内にいてはならないか？
when IS_USABLE::WORD_J;return false if $game_troop.members.include?(character)
end
end
#データタイプが5の場合
when 5
begin
#配列の3番目の文字列をスクリプトとして実行。
a = character
return false unless eval(array[2])
rescue
#エラーとなった場合は、配列の2番目の文字列で分岐。
case array[1]
#OKの場合は次の条件の処理を行う。
when IS_USABLE::WORD_M;next
#NGの場合はfalseを返す。
when IS_USABLE::WORD_N;return false
end
end
end
}
}
#全ての条件を満たすのでtrueを返す。
true
end
end
class Game_Unit
#--------------------------------------------------------------------------
# 隠れていないメンバーの配列取得
#--------------------------------------------------------------------------
def unhidden_members
members.select {|member| member.hidden? == false}
end
#--------------------------------------------------------------------------
# 行動可能なメンバーの配列取得
#--------------------------------------------------------------------------
def movable_members_ex
unhidden_members.select {|member| member.movable?}
end
#--------------------------------------------------------------------------
# 行動不能なメンバーの配列取得
#--------------------------------------------------------------------------
def not_movable_members_ex
unhidden_members.select {|member| member.movable? == false}
end
#--------------------------------------------------------------------------
# メンバーステートチェック
#--------------------------------------------------------------------------
def members_state_check(state_id)
#初期値を取得。
data = 0
#メンバーが該当ステートを付与されている場合はデータに1加算。
members.each {|i| data += 1 if i.state?(state_id)}
#データを返す。
data
end
#--------------------------------------------------------------------------
# HPの平均値を計算
#--------------------------------------------------------------------------
def hp(type)
#メンバー数が0の場合は0を返す。
return 0 if members.size == 0
#タイプが0の場合
if type == 0;members.inject(0) {|r, member| r += member.hp} / members.size
#タイプが1の場合
elsif type == 1;members.inject(0) {|r, member| r += member.hp_rate * 100} / members.size
end
end
#--------------------------------------------------------------------------
# MPの平均値を計算
#--------------------------------------------------------------------------
def mp(type)
#メンバー数が0の場合は0を返す。
return 0 if members.size == 0
#タイプが0の場合
if type == 0;members.inject(0) {|r, member| r += member.mp} / members.size
#タイプが1の場合
elsif type == 1;members.inject(0) {|r, member| r += member.mp_rate * 100} / members.size
end
end
#--------------------------------------------------------------------------
# TPの平均値を計算
#--------------------------------------------------------------------------
def tp(type)
#メンバー数が0の場合は0を返す。
return 0 if members.size == 0
#タイプが0の場合
if type == 0;members.inject(0) {|r, member| r += member.tp} / members.size
#タイプが1の場合
elsif type == 1;members.inject(0) {|r, member| r += member.tp_rate * 100} / members.size
end
end
#--------------------------------------------------------------------------
# HPの合計値を計算
#--------------------------------------------------------------------------
def hptotal
return 0 if members.size == 0
members.inject(0) {|r, member| r += member.hp}
end
#--------------------------------------------------------------------------
# MPの合計値を計算
#--------------------------------------------------------------------------
def mptotal
return 0 if members.size == 0
members.inject(0) {|r, member| r += member.mp}
end
#--------------------------------------------------------------------------
# TPの合計値を計算
#--------------------------------------------------------------------------
def tptotal
return 0 if members.size == 0
members.inject(0) {|r, member| r += member.tp}
end
end
class RPG::UsableItem < RPG::BaseItem
#--------------------------------------------------------------------------
# 使用条件の配列を作成
#--------------------------------------------------------------------------
def use_condition_array
#キャッシュが存在する場合はキャッシュを返す。
return @use_condition_array if @use_condition_array != nil
#配列を作成する。
@use_condition_array = []
#メモ欄の各行からデータを取得。
self.note.each_line {|line|
array = line.scan(/<#{IS_USABLE::WORD_BASE}[：:](\S+)>/).flatten
#配列が存在しないか空の場合は空の配列にする。
#そうでない場合は配列を分解した配列にする。
array = array != nil && !array.empty? ? array[0].split(/\s*,\s*/) : []
#配列の要素数が3より小さい、もしくは4より大きい場合は
#無効と判断し、次の行の判定を開始する。
next if array.size < 3 or array.size > 4
#アクターのみ条件が発生する場合、条件タイプは1とする。
if line.include?(IS_USABLE::WORD_ACTOR);user_type = 1
#エネミーのみ条件が発生する場合、条件タイプは2とする。
elsif line.include?(IS_USABLE::WORD_ENEMY);user_type = 2
#誰でも条件が発生する場合、条件タイプは0とする。
else;user_type = 0
end
#味方全体に条件が発生する場合、判定対象は1とする。
if line.include?(IS_USABLE::WORD_F_ALL);condition_target = 1
#敵全体に条件が発生する場合、判定対象は2とする。
elsif line.include?(IS_USABLE::WORD_O_ALL);condition_target = 2
#敵味方全体に条件が発生する場合、判定対象は3とする。
elsif line.include?(IS_USABLE::WORD_A_ALL);condition_target = 3
#自分のみに条件が発生する場合、判定対象は0とする。
else;condition_target = 0
array_a = line.scan(/~#{IS_USABLE::WORD_ACTOR_A}[：:](\S+)~/).flatten
array_a = array_a[0].split(/\s*,\s*/) if array_a != nil && !array_a.empty?
array_p = line.scan(/~#{IS_USABLE::WORD_PARTY_P}[：:](\S+)~/).flatten
array_p = array_p[0].split(/\s*,\s*/) if array_p != nil && !array_p.empty?
array_e = line.scan(/~#{IS_USABLE::WORD_ENEMY_E}[：:](\S+)~/).flatten
array_e = array_e[0].split(/\s*,\s*/) if array_e != nil && !array_e.empty?
array_t = line.scan(/~#{IS_USABLE::WORD_TROOP_T}[：:](\S+)~/).flatten
array_t = array_t[0].split(/\s*,\s*/) if array_t != nil && !array_t.empty?
end
#条件配列、条件タイプ、判定対象のデータを元にハッシュを作成する。
hash = {:array => array, :user_type => user_type, :condition_target => condition_target}
#アクター・パーティ・エネミー・敵グループ用のデータを加える。
hash[:array_a] = array_a != nil ? array_a : []
hash[:array_p] = array_p != nil ? array_p : []
hash[:array_e] = array_e != nil ? array_e : []
hash[:array_t] = array_t != nil ? array_t : []
#配列にハッシュを加える。
@use_condition_array.push(hash)
}
#配列を返す。
@use_condition_array
end
end

复制代码

造小梦 · 发表于 2019-3-24 14:45:33

百里_飞柳发表于 2019-3-24 12:41
大概你加了什么技能消耗的扩展，然后里面有定义绘制前加的转义符，于是你自己加了\c的转义符来修改颜色？
...

我找不到啊。。。这个是对技能消耗有改动的脚本，您看看呗

module EXTRA_SKILL_COST
#コストとしてアイテムを消費する場合の設定用ワード
WORD1A = "物品消耗"
#コストとして武器を消費する場合の設定用ワード
WORD1B = "武器消耗"
#コストとして防具を消費する場合の設定用ワード
WORD1C = "防具消耗"
#コストとして所持金を固定値消費する場合の設定用ワード
WORD2A = "灵魂消耗"
#コストとして所持金を割合消費する場合の設定用ワード
WORD2B = "灵魂比例消耗"
#コストとして所持金を消費する式を設定する場合の設定用ワード
WORD2C = "所持金消費式"
#コストとして変数の値を固定値消費する場合の設定用ワード
WORD3A = "変数固定消費"
#コストとして変数の値を割合消費する場合の設定用ワード
WORD3B = "変数割合消費"
#コストとして変数の値を消費する式を設定する場合の設定用ワード
WORD3C = "変数消費式"
#コストとしてHPを固定値消費する場合の設定用ワード
WORD4A = "HP损耗"
#コストとしてHPを割合消費する場合の設定用ワード
WORD4B = "HP比例损耗"
#コストとしてHPを最大値に対する一定割合分消費する式を設定する場合の設定用ワード
WORD4C = "最大HP比例损耗"
#コストとしてHPを消費する式を設定する場合の設定用ワード
WORD4D = "HP消費式"
#コストとしてMPを固定値消費する場合の設定用ワード
WORD5A = "MP损耗"
#コストとしてMPを割合消費する場合の設定用ワード
WORD5B = "MP比例损耗"
#コストとしてMPを最大値に対する一定割合分消費する式を設定する場合の設定用ワード
WORD5C = "最大MP割合消費"
#コストとしてMPを消費する式を設定する場合の設定用ワード
WORD5D = "MP消費式"
#コストとしてTPを固定値消費する場合の設定用ワード
WORD6A = "TP损耗"
#コストとしてTPを割合消費する場合の設定用ワード
WORD6B = "TP比例损耗"
#コストとしてTPを最大値に対する一定割合分消費する式を設定する場合の設定用ワード
WORD6C = "最大TP比例损耗"
#コストとしてTPを消費する式を設定する場合の設定用ワード
WORD6D = "TP消費式"
#消費HP軽減特徴の設定用ワード
WORD7A = "消費HP軽減割合"
#消費HP軽減無効スキルの設定用ワード
WORD7B = "消費HP軽減無効"
#消費MP軽減無効スキルの設定用ワード
WORD8 = "消費MP軽減無効"
#消費TP軽減特徴の設定用ワード
WORD9A = "消費TP軽減割合"
#消費TP軽減無効スキルの設定用ワード
WORD9B = "消費TP軽減無効"
#スキル使用時、消費HPによる戦闘不能を有効にするか否かの設定用ワード
WORD10 = "戦闘不能許可"
WORD11 ="暴击率"
#HPのスキルコスト表示色（テキストカラーIDに準じる）
HPCC = 2
#MPのスキルコスト表示色（テキストカラーIDに準じる）
MPCC = 23
#TPのスキルコスト表示色（テキストカラーIDに準じる）
TPCC = 29
#コストとして変数の値を消費する場合
#使用後、変数の値がマイナスになる場合でも使用可とするか
#true = 使用可能　false = 使用不可
V_MIN1 = false
#コストとして変数の値を消費する場合
#敵が使用する場合も判定を行うか
#true = 行う　false = 行わない
V_MIN2 = false
#HP/MP/TPコストの表示形式
#0 デフォルト（HPは表示しない）
#1 HP/MP/TPを全て表示（表示形式は揃えない）
#2～数字分だけ区切って表示
COST_D = 1
#COST_Dが2以上の場合の表示設定
#HPを表示するか（trueで表示 falseで非表示）
HP_D = true
#MPを表示するか
MP_D = true
#TPを表示するか
TP_D = true
#スキルコストの対象表示（項目名の短縮名表示 trueで表示 falseで非表示）
CTITLE = true
#スキルリストの桁数
COLMAX = 2
#スキルコスト表示位置の調整
COS_OX = 0#-2
end
class Game_BattlerBase
#MP・TPコストの計算に別名定義で変更
alias skill_cost_payable_extra_cost? skill_cost_payable?
def skill_cost_payable?(skill)
#元の処理を実行
return false unless skill_cost_payable_extra_cost?(skill)
#追加された消費系統の可否を判定
return false unless skill_ex_cost_payble(skill)
#全てクリアならtrueを返す
return true
end
#概念ごと新たに追加された消費系統の可否
def skill_ex_cost_payble(skill)
#アクターの場合のみ、アイテムと所持金のコスト判定を行う
if self.actor?
#アイテムのコスト可否判定
return false unless skill_item_cost_payble(skill)
#所持金のコスト可否判定
return false unless skill_gold_cost_payble(skill)
end
#変数のコスト可否判定
return false unless skill_var_cost_payble(skill)
#HPのコスト可否判定
return false unless skill_hp_cost_payble(skill)
return true
end
#HP以外で新たに追加された消費系統の実行
alias pay_skill_cost_extra_cost pay_skill_cost
def pay_skill_cost(skill)
#元の処理を実行
pay_skill_cost_extra_cost(skill)
#アクターの場合のみ、アイテムと所持金のコスト消費を行う
if self.actor?
#アイテムのコスト処理
pay_item_cost(skill)
#所持金のコスト処理
pay_gold_cost(skill)
end
#変数のコスト処理
pay_var_cost(skill)
end
#総合アイテム消費可否
def skill_item_cost_payble(skill)
#アイテムコストが存在しない場合はtrueを返す
return true if skill.item_cost.empty?
#コスト別に判定
skill.item_cost.each do |data|
case data[0]
when 0#アイテムの場合
item = $data_items[data[1]]
when 1#武器の場合
item = $data_weapons[data[1]]
when 2#防具の場合
item = $data_armors[data[1]]
end
#指定された消費量より所持数が少ない場合はfalseを返す
return false if $game_party.item_number(item) < data[2]
end
#trueを返す
return true
end
#総合アイテム消費
def pay_item_cost(skill)
#アイテムコストが存在しない場合は処理しない
return if skill.item_cost.empty?
#コスト別に処理
skill.item_cost.each do |data|
case data[0]
when 0#アイテムの場合
item = $data_items[data[1]]
when 1#武器の場合
item = $data_weapons[data[1]]
when 2#防具の場合
item = $data_armors[data[1]]
end
#アイテム消費処理
$game_party.lose_item(item, data[2])
end
end
#総合所持金消費可否
def skill_gold_cost_payble(skill)
#所持金が消費量以上か？
$game_party.gold >= skill_gold_cost(skill)
end
#総合所持金消費
def pay_gold_cost(skill)
#所持金の消費処理
$game_party.gain_gold(-skill_gold_cost(skill))
end
#総合所持金消費量
def skill_gold_cost(skill)
#それぞれの所持金消費量計算をまとめた後、整数化する
(gold_cost_fix(skill) + gold_cost_rate(skill) + gold_cost_eval(skill)).to_i
end
#所持金固定値消費
def gold_cost_fix(skill)
#スキルの所持金固定値消費を返す
skill.gold_cost_fix
end
#所持金消費割合
def gold_cost_rate(skill)
#スキルの所持金消費割合と現在値をかけた後、0.01をかけた数字を返す
skill.gold_cost_rate * $game_party.gold * 0.01
end
#所持金消費式
def gold_cost_eval(skill)
#スキルの所持金消費式を返す
eval(skill.gold_cost_eval)
end
#全ての消費変数の消費可否
def skill_var_cost_payble(skill)
#設定次第では、判定を無視する
return true if EXTRA_SKILL_COST::V_MIN1
#設定次第では、敵の場合は判定を無視する
return true if !self.actor? && !EXTRA_SKILL_COST::V_MIN2
#変数の固定値消費
#変数の固定値消費が存在しない場合は飛ばす
if !skill.var_cost_fix.empty?
#消費データ別に判定
skill.var_cost_fix.each do |data|
#消費可否判定
return false unless var_cost_fix_payble(data)
end
end
#変数の割合消費
#変数の割合消費が存在しない場合は飛ばす
if !skill.var_cost_rate.empty?
#消費データ別に判定
skill.var_cost_rate.each do |data|
#消費可否判定
return false unless var_cost_rate_payble(data)
end
end
#変数の消費式
#変数の消費式が存在しない場合は飛ばす
if !skill.var_cost_eval.empty?
#消費データ別に判定
skill.var_cost_eval.each do |data|
#消費可否判定
return false unless var_cost_eval_payble(data)
end
end
#全てクリアならtrueを返す
return true
end
#全ての消費変数の消費実行
def pay_var_cost(skill)
#設定次第では、敵の場合は処理をしない
return if !self.actor? && !EXTRA_SKILL_COST::V_MIN2
#変数の固定値消費
#変数の固定値消費が存在しない場合は飛ばす
if !skill.var_cost_fix.empty?
#消費データ別に処理
skill.var_cost_fix.each do |data|
#消費処理
pay_var_cost_fix(data)
end
end
#変数の割合消費
#変数の割合消費が存在しない場合は飛ばす
if !skill.var_cost_rate.empty?
#消費データ別に処理
skill.var_cost_rate.each do |data|
#消費処理
pay_var_cost_rate(data)
end
end
#変数の消費式
#変数の消費式が存在しない場合は飛ばす
if !skill.var_cost_eval.empty?
#消費データ別に処理
skill.var_cost_eval.each do |data|
#消費処理
pay_var_cost_eval(data)
end
end
end
#消費固定変数の可否
def var_cost_fix_payble(data)
#変数の値が消費値以上か否か
$game_variables[data[0]] >= data[1]
end
#消費割合変数の可否
def var_cost_rate_payble(data)
#変数の値が消費割合で計算された消費値以上か否か
$game_variables[data[0]] >= ($game_variables[data[0]] * data[1]) * 0.01
end
#消費変数式の可否
def var_cost_eval_payble(data)
#変数の値が消費式で計算された消費値以上か否か
$game_variables[data[0]] >= eval(data[1])
end
#消費固定変数の消費
def pay_var_cost_fix(data)
#変数の固定値消費実行
$game_variables[data[0]] -= data[1]
end
#消費割合変数の消費
def pay_var_cost_rate(data)
#変数の割合消費実行
$game_variables[data[0]] -= (($game_variables[data[0]] * data[1]) * 0.01).to_i
end
#消費変数式の消費
def pay_var_cost_eval(data)
#変数の消費式実行
$game_variables[data[0]] -= eval(data[1])
end
#総合消費HPの可否
def skill_hp_cost_payble(skill)
#スキルによる自滅が認められていない場合は現在HPが消費HP以上か否か。
#認められている場合はtrueを返す
!skill.suicidable? ? self.hp > skill_hp_cost(skill) : true
end
#総合消費HP
def skill_hp_cost(skill)
#それぞれのHP消費をまとめた後、整数化する
((hp_cost_fix(skill) + hp_cost_rate(skill) + hp_cost_mrate(skill) + hp_cost_eval(skill)) * special_ex_hcr(skill)).to_i
end
#消費固定HP
def hp_cost_fix(skill)
#スキルの消費固定HPを返す
skill.hp_cost_fix
end
#消費HP割合（現在値）
def hp_cost_rate(skill)
#スキルの消費HP割合と現在値をかけた後、0.01をかけた数字を返す
skill.hp_cost_rate * self.hp * 0.01
end
#消費HP割合（最大値）
def hp_cost_mrate(skill)
#スキルの消費最大HP割合と最大値をかけた後、0.01をかけた数字を返す
skill.hp_cost_mrate * self.mhp * 0.01
end
#消費HP式
def hp_cost_eval(skill)
#スキルの消費HP割合式を返す
eval(skill.hp_cost_eval)
end
#消費HP軽減割合
def special_ex_hcr(skill)
#消費HP軽減特徴が無効の場合は消費HP軽減特徴の効果を反映させる
return [(100.0 - ex_hcr)/100, 0].max unless skill.ex_hcr_zero?
#消費HP軽減特徴が有効の場合は1.0を返す
return 1.0
end
#MP消費計算を別名定義で変更し、総合消費MPを計算
alias skill_mp_cost_extra_cost skill_mp_cost
def skill_mp_cost(skill)
#元のデータを取得する
data = skill_mp_cost_extra_cost(skill)
#元のデータに新規処理の総和を足す
data += (mp_cost_fix(skill) + mp_cost_rate(skill) + mp_cost_mrate(skill) + mp_cost_eval(skill)) * special_mcr(skill)
#整数化して返す
return data.to_i
end
#消費固定MP
def mp_cost_fix(skill)
#スキルの消費固定MPを返す
skill.mp_cost_fix
end
#消費MP割合（現在値）
def mp_cost_rate(skill)
#スキルの消費MP割合と現在値をかけた後、0.01をかけた数字を返す
skill.mp_cost_rate * self.mp * 0.01
end
#消費MP割合（最大値）
def mp_cost_mrate(skill)
#スキルの消費最大MP割合と最大値をかけた後、0.01をかけた数字を返す
skill.mp_cost_mrate * self.mmp * 0.01
end
#消費MP式
def mp_cost_eval(skill)
#スキルの消費MP割合式を返す
eval(skill.mp_cost_eval)
end
#消費MP軽減割合
def special_mcr(skill)
#消費MP軽減特徴が無効の場合は消費MP軽減特徴の効果を反映させる
return mcr unless skill.mcr_zero?
#消費MP軽減特徴が有効の場合は1.0を返す
return 1.0
end
#TP消費計算を別名定義で変更し、総合消費TPを計算
alias skill_tp_cost_extra_cost skill_tp_cost
def skill_tp_cost(skill)
#元のデータを取得する
data = skill_tp_cost_extra_cost(skill)
#元のデータに新規処理の総和を足す
data += tp_cost_fix(skill) + tp_cost_rate(skill) + tp_cost_mrate(skill) + tp_cost_eval(skill)
#軽減特徴を適用
data *= special_ex_tcr(skill)
#整数化して返す
return data.to_i
end
#消費固定TP
def tp_cost_fix(skill)
#スキルの消費固定TPを返す
skill.tp_cost_fix
end
#消費TP割合（現在値）
def tp_cost_rate(skill)
#スキルの消費TP割合と現在値をかけた後、0.01をかけた数字を返す
skill.tp_cost_rate * self.tp * 0.01
end
#消費TP割合（最大値）
def tp_cost_mrate(skill)
#スキルの消費最大TP割合と最大値をかけた後、0.01をかけた数字を返す
skill.tp_cost_mrate * self.max_tp * 0.01
end
#消費TP式
def tp_cost_eval(skill)
#スキルの消費TP割合式を返す
eval(skill.tp_cost_eval)
end
#消費TP軽減割合
def special_ex_tcr(skill)
#消費TP軽減特徴が無効の場合は消費MP軽減特徴の効果を反映させる
return [(100.0 - ex_tcr)/100, 0].max unless skill.ex_tcr_zero?
#消費TP軽減特徴が有効の場合は1.0を返す
return 1.0
end
#消費HP軽減割合の取得
def ex_hcr
#とりあえず0にする
data = 0
#特徴別に処理
feature_objects.each do |f|
#消費HP軽減割合を加算
data += f.ex_hcr
end
#データを返す
return data
end
#消費TP軽減割合の取得
def ex_tcr
#とりあえず0にする
data = 0
#特徴別に処理
feature_objects.each do |f|
#消費TP軽減割合を加算
data += f.ex_tcr
end
#データを返す
return data
end
end
class Scene_Skill < Scene_ItemBase
#スキル使用時のアクターへの効果のタイミングで
#HP消費の効果を反映させる。
alias use_item_to_actors_extra_cost use_item_to_actors
def use_item_to_actors
#使用者とスキルを取得。
target = user
item = target.last_skill.object
#本来の処理を実行。
use_item_to_actors_extra_cost
#スキルではない場合は処理を飛ばす。
return unless item.is_a?(RPG::Skill)
#スキル使用による戦闘不能が認められていて
#なおかつ使用者が生存している場合はHP消費を反映。
#認められていない場合は、HPの最低値を1としてHP消費を反映。
if target.alive? && target.hp > 0
if item.suicidable?
target.hp -= target.skill_hp_cost(item)
else
target.hp = [target.hp - target.skill_hp_cost(item), 1].max
end
end
end
end
class Scene_Battle < Scene_Base
#スキル使用後のタイミングで
#HP消費の効果を反映させる。
alias use_item_extra_cost use_item
def use_item
#使用者とスキルを取得。
target = @subject
item = target.current_action.item
#本来の処理を実行。
use_item_extra_cost
#スキルではない場合は処理を飛ばす。
return unless item.is_a?(RPG::Skill)
#スキル使用による戦闘不能が認められていて
#なおかつ使用者が生存している場合はHP消費を反映。
#認められていない場合は、HPの最低値を1としてHP消費を反映。
if target.alive? && target.hp > 0
if item.suicidable?
target.hp -= target.skill_hp_cost(item)
#HP消費によって戦闘不能となった場合
#ログウィンドウにその旨を出力する。
if !target.alive?
state = $data_states[1]
state_msg = target.actor? ? state.message1 : state.message2
target.perform_collapse_effect
@log_window.replace_text(target.name + state_msg)
@log_window.wait
@log_window.wait_for_effect
end
else
target.hp = [target.hp - target.skill_hp_cost(item), 1].max
end
end
end
end
class Window_Base < Window
#新たな制御文字として\ALPHACを加える。
#\ALPHACは、文字色変更時に透過度を保持する。
alias process_escape_character_extra_cost process_escape_character
def process_escape_character(code, text, pos)
if code.upcase == 'C'
alpha = contents.font.color.alpha
change_color(text_color(obtain_escape_param(text)))
contents.font.color.alpha = alpha
return
end
process_escape_character_extra_cost(code, text, pos)
end
#コスト表示用に、制御文字付きの描写方法を新たに定義する。
#通常の制御文字付き文章描画と異なり、文体のリセットを行わない。
def draw_text_ex_cost(x, y, text)
text = convert_escape_characters(text)
pos = {:x => x, :y => y, :new_x => x, :height => calc_line_height(text)}
process_character(text.slice!(0, 1), text, pos) until text.empty?
end
end
class Window_SkillList < Window_Selectable
#桁数の変更
alias col_max_extra_cost col_max
def col_max
data = col_max_extra_cost
data = EXTRA_SKILL_COST::COLMAX if data != EXTRA_SKILL_COST::COLMAX
return data
end
#スキルコストの記述方法を変更。
alias draw_skill_cost_extra_cost draw_skill_cost
def draw_skill_cost(rect, skill)
#表示形式が0の場合は本来の処理を実行
return draw_skill_cost_extra_cost(rect, skill) if EXTRA_SKILL_COST::COST_D == 0
#HP/MP/TP消費量を取得。
flag = [@actor.skill_hp_cost(skill),@actor.skill_mp_cost(skill),@actor.skill_tp_cost(skill)]
#スキルの使用可否に応じて記述内容の透過度を設定する。
contents.font.color.alpha = enable?(skill) ? 255 : translucent_alpha
#文字列の長さを取得する為、二つの文字列データを作成する。
text = ""
sub_text = ""
#HP
if EXTRA_SKILL_COST::HP_D && (EXTRA_SKILL_COST::COST_D > 1 or flag[0] > 0)
t = EXTRA_SKILL_COST::CTITLE ? Vocab::basic(3) : ""
if EXTRA_SKILL_COST::COST_D > 1 && flag[0].to_s.length != EXTRA_SKILL_COST::COST_D
number = EXTRA_SKILL_COST::COST_D - flag[0].to_s.length
number.times do
t+= " "
end
end
t += flag[0].to_s
sub_text += t
text += hp_cost_color_text + t
end
#MP
if EXTRA_SKILL_COST::MP_D && (EXTRA_SKILL_COST::COST_D > 1 or flag[1] > 0)
if text != ""
text += "\\ALPHAC[0]/"
sub_text += "/"
end
t = EXTRA_SKILL_COST::CTITLE ? Vocab::basic(5) : ""
if EXTRA_SKILL_COST::COST_D > 1 && flag[1].to_s.length != EXTRA_SKILL_COST::COST_D
number = EXTRA_SKILL_COST::COST_D - flag[1].to_s.length
number.times do
t+= " "
end
end
t += flag[1].to_s
sub_text += t
text += mp_cost_color_text + t
end
#TP
if EXTRA_SKILL_COST::TP_D && (EXTRA_SKILL_COST::COST_D > 1 or flag[2] > 0)
if text != ""
text += "\\ALPHAC[0]/"
sub_text += "/"
end
t = EXTRA_SKILL_COST::CTITLE ? Vocab::basic(7) : ""
if EXTRA_SKILL_COST::COST_D > 1 && flag[2].to_s.length != EXTRA_SKILL_COST::COST_D
number = EXTRA_SKILL_COST::COST_D - flag[2].to_s.length
number.times do
t+= " "
end
end
t += flag[2].to_s
sub_text += t
text += tp_cost_color_text + t
end
#文字列の長さを取得し、描写を実行する。
sub_x = text_size(sub_text).width
x = rect.x + rect.width - sub_x + EXTRA_SKILL_COST::COS_OX
y = rect.y
draw_text_ex_cost(x, y, text)
end
#消費HP記述用のキャッシュを生成。
def hp_cost_color_text
return @hp_cost_color_set if @hp_cost_color_set != nil
@hp_cost_color_set = "\\ALPHAC[" + EXTRA_SKILL_COST::HPCC.to_s + "]"
return @hp_cost_color_set
end
#消費MP記述用のキャッシュを生成。
def mp_cost_color_text
return @mp_cost_color_set if @mp_cost_color_set != nil
@mp_cost_color_set = "\\ALPHAC[" + EXTRA_SKILL_COST::MPCC.to_s + "]"
return @mp_cost_color_set
end
#消費TP記述用のキャッシュを生成。
def tp_cost_color_text
return @tp_cost_color_set if @tp_cost_color_set != nil
@tp_cost_color_set = "\\ALPHAC[" + EXTRA_SKILL_COST::TPCC.to_s + "]"
return @tp_cost_color_set
end
end
class RPG::BaseItem
#消費HP軽減特徴。
def ex_hcr
#キャッシュがある場合はキャッシュを返す。
return @feature_ex_hcr if @feature_ex_hcr != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD7A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@feature_ex_hcr = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @feature_ex_hcr
end
#消費TP軽減特徴。
def ex_tcr
#キャッシュがある場合はキャッシュを返す。
return @feature_ex_tcr if @feature_ex_tcr != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD9A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@feature_ex_tcr = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @feature_ex_tcr
end
end
class RPG::Skill < RPG::UsableItem
#消費HP軽減無効。
def ex_hcr_zero?
#キャッシュがある場合はキャッシュを返す。
return @ex_hcr_zero if @ex_hcr_zero != nil
#メモ欄からデータを取得。
@ex_hcr_zero = self.note.include?(EXTRA_SKILL_COST::WORD7B)
#データを返す。
return @ex_hcr_zero
end
#消費MP軽減無効。
def mcr_zero?
#キャッシュがある場合はキャッシュを返す。
return @mcr_zero if @mcr_zero != nil
#メモ欄からデータを取得。
@mcr_zero = self.note.include?(EXTRA_SKILL_COST::WORD8)
#データを返す。
return @mcr_zero
end
#消費TP軽減無効。
def ex_tcr_zero?
#キャッシュがある場合はキャッシュを返す。
return @ex_tcr_zero if @ex_tcr_zero != nil
#メモ欄からデータを取得。
@ex_tcr_zero = self.note.include?(EXTRA_SKILL_COST::WORD9B)
#データを返す。
return @ex_tcr_zero
end
def item_cost
#キャッシュがある場合はキャッシュを返す。
return @item_cost if @item_cost != nil
@item_cost = []
#メモ欄からデータを取得。
self.note.each_line do |l|
memo = l.scan(/<#{EXTRA_SKILL_COST::WORD1A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は飛ばす。
if memo != nil && !memo.empty?
memo = memo[0].split(/\s*,\s*/)
@item_cost.push([0, memo[0].to_i, memo[1] ? memo[1].to_i : 1])
end
memo = l.scan(/<#{EXTRA_SKILL_COST::WORD1B}[：:](\S+)>/).flatten
#データを取得出来無かった場合は飛ばす。
if memo != nil && !memo.empty?
memo = memo[0].split(/\s*,\s*/)
@item_cost.push([1, memo[0].to_i, memo[1] ? memo[1].to_i : 1])
end
memo = l.scan(/<#{EXTRA_SKILL_COST::WORD1C}[：:](\S+)>/).flatten
#データを取得出来無かった場合は飛ばす。
if memo != nil && !memo.empty?
memo = memo[0].split(/\s*,\s*/)
@item_cost.push([2, memo[0].to_i, memo[1] ? memo[1].to_i : 1])
end
end
#データを返す。
return @item_cost
end
def gold_cost_fix
#キャッシュがある場合はキャッシュを返す。
return @gold_cost_fix if @gold_cost_fix != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD2A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@gold_cost_fix = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @gold_cost_fix
end
def gold_cost_rate
#キャッシュがある場合はキャッシュを返す。
return @gold_cost_rate if @gold_cost_rate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD2B}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@gold_cost_rate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @gold_cost_rate
end
def gold_cost_eval
#キャッシュがある場合はキャッシュを返す。
return @gold_cost_eval if @gold_cost_eval != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD2C}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@gold_cost_eval = (memo != nil && !memo.empty?) ? memo[0].to_s : "0"
#データを返す。
return @gold_cost_eval
end
def var_cost_fix
#キャッシュがある場合はキャッシュを返す。
return @var_cost_fix if @var_cost_fix != nil
#配列を作成。
@var_cost_fix = []
#メモ欄からデータを取得。
self.note.each_line do |l|
memo = l.scan(/<#{EXTRA_SKILL_COST::WORD3A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は飛ばす。
if memo != nil && !memo.empty?
memo = memo[0].split(/\s*,\s*/)
@var_cost_fix.push([memo[0].to_i, memo[1].to_i])
end
end
#データを返す。
return @var_cost_fix
end
def var_cost_rate
#キャッシュがある場合はキャッシュを返す。
return @var_cost_rate if @var_cost_rate != nil
#配列を作成。
@var_cost_rate = []
#メモ欄からデータを取得。
self.note.each_line do |l|
memo = l.scan(/<#{EXTRA_SKILL_COST::WORD3B}[：:](\S+)>/).flatten
#データを取得出来無かった場合は飛ばす。
if memo != nil && !memo.empty?
memo = memo[0].split(/\s*,\s*/)
@var_cost_rate.push([memo[0].to_i, memo[1].to_i])
end
end
#データを返す。
return @var_cost_rate
end
def var_cost_eval
#キャッシュがある場合はキャッシュを返す。
return @var_cost_eval if @var_cost_eval != nil
#配列を作成。
@var_cost_eval = []
#メモ欄からデータを取得。
self.note.each_line do |l|
memo = l.scan(/<#{EXTRA_SKILL_COST::WORD3C}[：:](\S+)>/).flatten
#データを取得出来無かった場合は飛ばす。
if memo != nil && !memo.empty?
memo = memo[0].split(/\s*,\s*/)
@var_cost_eval.push([memo[0].to_i, memo[1].to_s])
end
end
#データを返す。
return @var_cost_eval
end
def hp_cost_fix
#キャッシュがある場合はキャッシュを返す。
return @hp_cost_fix if @hp_cost_fix != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD4A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@hp_cost_fix = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @hp_cost_fix
end
def hp_cost_rate
#キャッシュがある場合はキャッシュを返す。
return @hp_cost_rate if @hp_cost_rate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD4B}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@hp_cost_rate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @hp_cost_rate
end
def hp_cost_mrate
#キャッシュがある場合はキャッシュを返す。
return @hp_cost_mrate if @hp_cost_mrate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD4C}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@hp_cost_mrate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @hp_cost_mrate
end
def hp_cost_eval
#キャッシュがある場合はキャッシュを返す。
return @hp_cost_eval if @hp_cost_eval != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD4D}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@hp_cost_eval = (memo != nil && !memo.empty?) ? memo[0].to_s : "0"
#データを返す。
return @hp_cost_eval
end
def mp_cost_fix
#キャッシュがある場合はキャッシュを返す。
return @mp_cost_fix if @mp_cost_fix != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD5A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@mp_cost_fix = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @mp_cost_fix
end
def mp_cost_rate
#キャッシュがある場合はキャッシュを返す。
return @mp_cost_rate if @mp_cost_rate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD5B}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@mp_cost_rate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @mp_cost_rate
end
def mp_cost_mrate
#キャッシュがある場合はキャッシュを返す。
return @mp_cost_mrate if @mp_cost_mrate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD5C}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@mp_cost_mrate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @mp_cost_mrate
end
def mp_cost_eval
#キャッシュがある場合はキャッシュを返す。
return @mp_cost_eval if @mp_cost_eval != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD5D}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@mp_cost_eval = (memo != nil && !memo.empty?) ? memo[0].to_s : "0"
#データを返す。
return @mp_cost_eval
end
def tp_cost_fix
#キャッシュがある場合はキャッシュを返す。
return @tp_cost_fix if @tp_cost_fix != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD6A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@tp_cost_fix = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @tp_cost_fix
end
def tp_cost_rate
#キャッシュがある場合はキャッシュを返す。
return @tp_cost_rate if @tp_cost_rate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD6B}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@tp_cost_rate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @tp_cost_rate
end
def tp_cost_mrate
#キャッシュがある場合はキャッシュを返す。
return @tp_cost_mrate if @tp_cost_mrate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD6C}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@tp_cost_mrate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @tp_cost_mrate
end
def tp_cost_eval
#キャッシュがある場合はキャッシュを返す。
return @tp_cost_eval if @tp_cost_eval != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD6D}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@tp_cost_eval = (memo != nil && !memo.empty?) ? memo[0].to_s : "0"
#データを返す。
return @tp_cost_eval
end
def suicidable?
#キャッシュがある場合はキャッシュを返す。
return @suicidable if @suicidable != nil
#メモ欄からデータを取得。
@suicidable = self.note.include?(EXTRA_SKILL_COST::WORD10)
#データを返す。
return @suicidable
end
end

复制代码

造小梦 · 发表于 2019-3-24 14:44:43

造小梦发表于 2019-3-24 14:26
我没加什么转义符啊，我直接导入脚本就用的

我找不到啊。。。这个是对技能消耗y

module EXTRA_SKILL_COST
#コストとしてアイテムを消費する場合の設定用ワード
WORD1A = "物品消耗"
#コストとして有改动的脚本，您看看呗武器を消費する場合の設定用ワード
WORD1B = "武器消耗"
#コストとして防具を消費する場合の設定用ワード
WORD1C = "防具消耗"
#コストとして所持金を固定値消費する場合の設定用ワード
WORD2A = "灵魂消耗"
#コストとして所持金を割合消費する場合の設定用ワード
WORD2B = "灵魂比例消耗"
#コストとして所持金を消費する式を設定する場合の設定用ワード
WORD2C = "所持金消費式"
#コストとして変数の値を固定値消費する場合の設定用ワード
WORD3A = "変数固定消費"
#コストとして変数の値を割合消費する場合の設定用ワード
WORD3B = "変数割合消費"
#コストとして変数の値を消費する式を設定する場合の設定用ワード
WORD3C = "変数消費式"
#コストとしてHPを固定値消費する場合の設定用ワード
WORD4A = "HP损耗"
#コストとしてHPを割合消費する場合の設定用ワード
WORD4B = "HP比例损耗"
#コストとしてHPを最大値に対する一定割合分消費する式を設定する場合の設定用ワード
WORD4C = "最大HP比例损耗"
#コストとしてHPを消費する式を設定する場合の設定用ワード
WORD4D = "HP消費式"
#コストとしてMPを固定値消費する場合の設定用ワード
WORD5A = "MP损耗"
#コストとしてMPを割合消費する場合の設定用ワード
WORD5B = "MP比例损耗"
#コストとしてMPを最大値に対する一定割合分消費する式を設定する場合の設定用ワード
WORD5C = "最大MP割合消費"
#コストとしてMPを消費する式を設定する場合の設定用ワード
WORD5D = "MP消費式"
#コストとしてTPを固定値消費する場合の設定用ワード
WORD6A = "TP损耗"
#コストとしてTPを割合消費する場合の設定用ワード
WORD6B = "TP比例损耗"
#コストとしてTPを最大値に対する一定割合分消費する式を設定する場合の設定用ワード
WORD6C = "最大TP比例损耗"
#コストとしてTPを消費する式を設定する場合の設定用ワード
WORD6D = "TP消費式"
#消費HP軽減特徴の設定用ワード
WORD7A = "消費HP軽減割合"
#消費HP軽減無効スキルの設定用ワード
WORD7B = "消費HP軽減無効"
#消費MP軽減無効スキルの設定用ワード
WORD8 = "消費MP軽減無効"
#消費TP軽減特徴の設定用ワード
WORD9A = "消費TP軽減割合"
#消費TP軽減無効スキルの設定用ワード
WORD9B = "消費TP軽減無効"
#スキル使用時、消費HPによる戦闘不能を有効にするか否かの設定用ワード
WORD10 = "戦闘不能許可"
WORD11 ="暴击率"
#HPのスキルコスト表示色（テキストカラーIDに準じる）
HPCC = 2
#MPのスキルコスト表示色（テキストカラーIDに準じる）
MPCC = 23
#TPのスキルコスト表示色（テキストカラーIDに準じる）
TPCC = 29
#コストとして変数の値を消費する場合
#使用後、変数の値がマイナスになる場合でも使用可とするか
#true = 使用可能　false = 使用不可
V_MIN1 = false
#コストとして変数の値を消費する場合
#敵が使用する場合も判定を行うか
#true = 行う　false = 行わない
V_MIN2 = false
#HP/MP/TPコストの表示形式
#0 デフォルト（HPは表示しない）
#1 HP/MP/TPを全て表示（表示形式は揃えない）
#2～数字分だけ区切って表示
COST_D = 1
#COST_Dが2以上の場合の表示設定
#HPを表示するか（trueで表示 falseで非表示）
HP_D = true
#MPを表示するか
MP_D = true
#TPを表示するか
TP_D = true
#スキルコストの対象表示（項目名の短縮名表示 trueで表示 falseで非表示）
CTITLE = true
#スキルリストの桁数
COLMAX = 2
#スキルコスト表示位置の調整
COS_OX = 0#-2
end
class Game_BattlerBase
#MP・TPコストの計算に別名定義で変更
alias skill_cost_payable_extra_cost? skill_cost_payable?
def skill_cost_payable?(skill)
#元の処理を実行
return false unless skill_cost_payable_extra_cost?(skill)
#追加された消費系統の可否を判定
return false unless skill_ex_cost_payble(skill)
#全てクリアならtrueを返す
return true
end
#概念ごと新たに追加された消費系統の可否
def skill_ex_cost_payble(skill)
#アクターの場合のみ、アイテムと所持金のコスト判定を行う
if self.actor?
#アイテムのコスト可否判定
return false unless skill_item_cost_payble(skill)
#所持金のコスト可否判定
return false unless skill_gold_cost_payble(skill)
end
#変数のコスト可否判定
return false unless skill_var_cost_payble(skill)
#HPのコスト可否判定
return false unless skill_hp_cost_payble(skill)
return true
end
#HP以外で新たに追加された消費系統の実行
alias pay_skill_cost_extra_cost pay_skill_cost
def pay_skill_cost(skill)
#元の処理を実行
pay_skill_cost_extra_cost(skill)
#アクターの場合のみ、アイテムと所持金のコスト消費を行う
if self.actor?
#アイテムのコスト処理
pay_item_cost(skill)
#所持金のコスト処理
pay_gold_cost(skill)
end
#変数のコスト処理
pay_var_cost(skill)
end
#総合アイテム消費可否
def skill_item_cost_payble(skill)
#アイテムコストが存在しない場合はtrueを返す
return true if skill.item_cost.empty?
#コスト別に判定
skill.item_cost.each do |data|
case data[0]
when 0#アイテムの場合
item = $data_items[data[1]]
when 1#武器の場合
item = $data_weapons[data[1]]
when 2#防具の場合
item = $data_armors[data[1]]
end
#指定された消費量より所持数が少ない場合はfalseを返す
return false if $game_party.item_number(item) < data[2]
end
#trueを返す
return true
end
#総合アイテム消費
def pay_item_cost(skill)
#アイテムコストが存在しない場合は処理しない
return if skill.item_cost.empty?
#コスト別に処理
skill.item_cost.each do |data|
case data[0]
when 0#アイテムの場合
item = $data_items[data[1]]
when 1#武器の場合
item = $data_weapons[data[1]]
when 2#防具の場合
item = $data_armors[data[1]]
end
#アイテム消費処理
$game_party.lose_item(item, data[2])
end
end
#総合所持金消費可否
def skill_gold_cost_payble(skill)
#所持金が消費量以上か？
$game_party.gold >= skill_gold_cost(skill)
end
#総合所持金消費
def pay_gold_cost(skill)
#所持金の消費処理
$game_party.gain_gold(-skill_gold_cost(skill))
end
#総合所持金消費量
def skill_gold_cost(skill)
#それぞれの所持金消費量計算をまとめた後、整数化する
(gold_cost_fix(skill) + gold_cost_rate(skill) + gold_cost_eval(skill)).to_i
end
#所持金固定値消費
def gold_cost_fix(skill)
#スキルの所持金固定値消費を返す
skill.gold_cost_fix
end
#所持金消費割合
def gold_cost_rate(skill)
#スキルの所持金消費割合と現在値をかけた後、0.01をかけた数字を返す
skill.gold_cost_rate * $game_party.gold * 0.01
end
#所持金消費式
def gold_cost_eval(skill)
#スキルの所持金消費式を返す
eval(skill.gold_cost_eval)
end
#全ての消費変数の消費可否
def skill_var_cost_payble(skill)
#設定次第では、判定を無視する
return true if EXTRA_SKILL_COST::V_MIN1
#設定次第では、敵の場合は判定を無視する
return true if !self.actor? && !EXTRA_SKILL_COST::V_MIN2
#変数の固定値消費
#変数の固定値消費が存在しない場合は飛ばす
if !skill.var_cost_fix.empty?
#消費データ別に判定
skill.var_cost_fix.each do |data|
#消費可否判定
return false unless var_cost_fix_payble(data)
end
end
#変数の割合消費
#変数の割合消費が存在しない場合は飛ばす
if !skill.var_cost_rate.empty?
#消費データ別に判定
skill.var_cost_rate.each do |data|
#消費可否判定
return false unless var_cost_rate_payble(data)
end
end
#変数の消費式
#変数の消費式が存在しない場合は飛ばす
if !skill.var_cost_eval.empty?
#消費データ別に判定
skill.var_cost_eval.each do |data|
#消費可否判定
return false unless var_cost_eval_payble(data)
end
end
#全てクリアならtrueを返す
return true
end
#全ての消費変数の消費実行
def pay_var_cost(skill)
#設定次第では、敵の場合は処理をしない
return if !self.actor? && !EXTRA_SKILL_COST::V_MIN2
#変数の固定値消費
#変数の固定値消費が存在しない場合は飛ばす
if !skill.var_cost_fix.empty?
#消費データ別に処理
skill.var_cost_fix.each do |data|
#消費処理
pay_var_cost_fix(data)
end
end
#変数の割合消費
#変数の割合消費が存在しない場合は飛ばす
if !skill.var_cost_rate.empty?
#消費データ別に処理
skill.var_cost_rate.each do |data|
#消費処理
pay_var_cost_rate(data)
end
end
#変数の消費式
#変数の消費式が存在しない場合は飛ばす
if !skill.var_cost_eval.empty?
#消費データ別に処理
skill.var_cost_eval.each do |data|
#消費処理
pay_var_cost_eval(data)
end
end
end
#消費固定変数の可否
def var_cost_fix_payble(data)
#変数の値が消費値以上か否か
$game_variables[data[0]] >= data[1]
end
#消費割合変数の可否
def var_cost_rate_payble(data)
#変数の値が消費割合で計算された消費値以上か否か
$game_variables[data[0]] >= ($game_variables[data[0]] * data[1]) * 0.01
end
#消費変数式の可否
def var_cost_eval_payble(data)
#変数の値が消費式で計算された消費値以上か否か
$game_variables[data[0]] >= eval(data[1])
end
#消費固定変数の消費
def pay_var_cost_fix(data)
#変数の固定値消費実行
$game_variables[data[0]] -= data[1]
end
#消費割合変数の消費
def pay_var_cost_rate(data)
#変数の割合消費実行
$game_variables[data[0]] -= (($game_variables[data[0]] * data[1]) * 0.01).to_i
end
#消費変数式の消費
def pay_var_cost_eval(data)
#変数の消費式実行
$game_variables[data[0]] -= eval(data[1])
end
#総合消費HPの可否
def skill_hp_cost_payble(skill)
#スキルによる自滅が認められていない場合は現在HPが消費HP以上か否か。
#認められている場合はtrueを返す
!skill.suicidable? ? self.hp > skill_hp_cost(skill) : true
end
#総合消費HP
def skill_hp_cost(skill)
#それぞれのHP消費をまとめた後、整数化する
((hp_cost_fix(skill) + hp_cost_rate(skill) + hp_cost_mrate(skill) + hp_cost_eval(skill)) * special_ex_hcr(skill)).to_i
end
#消費固定HP
def hp_cost_fix(skill)
#スキルの消費固定HPを返す
skill.hp_cost_fix
end
#消費HP割合（現在値）
def hp_cost_rate(skill)
#スキルの消費HP割合と現在値をかけた後、0.01をかけた数字を返す
skill.hp_cost_rate * self.hp * 0.01
end
#消費HP割合（最大値）
def hp_cost_mrate(skill)
#スキルの消費最大HP割合と最大値をかけた後、0.01をかけた数字を返す
skill.hp_cost_mrate * self.mhp * 0.01
end
#消費HP式
def hp_cost_eval(skill)
#スキルの消費HP割合式を返す
eval(skill.hp_cost_eval)
end
#消費HP軽減割合
def special_ex_hcr(skill)
#消費HP軽減特徴が無効の場合は消費HP軽減特徴の効果を反映させる
return [(100.0 - ex_hcr)/100, 0].max unless skill.ex_hcr_zero?
#消費HP軽減特徴が有効の場合は1.0を返す
return 1.0
end
#MP消費計算を別名定義で変更し、総合消費MPを計算
alias skill_mp_cost_extra_cost skill_mp_cost
def skill_mp_cost(skill)
#元のデータを取得する
data = skill_mp_cost_extra_cost(skill)
#元のデータに新規処理の総和を足す
data += (mp_cost_fix(skill) + mp_cost_rate(skill) + mp_cost_mrate(skill) + mp_cost_eval(skill)) * special_mcr(skill)
#整数化して返す
return data.to_i
end
#消費固定MP
def mp_cost_fix(skill)
#スキルの消費固定MPを返す
skill.mp_cost_fix
end
#消費MP割合（現在値）
def mp_cost_rate(skill)
#スキルの消費MP割合と現在値をかけた後、0.01をかけた数字を返す
skill.mp_cost_rate * self.mp * 0.01
end
#消費MP割合（最大値）
def mp_cost_mrate(skill)
#スキルの消費最大MP割合と最大値をかけた後、0.01をかけた数字を返す
skill.mp_cost_mrate * self.mmp * 0.01
end
#消費MP式
def mp_cost_eval(skill)
#スキルの消費MP割合式を返す
eval(skill.mp_cost_eval)
end
#消費MP軽減割合
def special_mcr(skill)
#消費MP軽減特徴が無効の場合は消費MP軽減特徴の効果を反映させる
return mcr unless skill.mcr_zero?
#消費MP軽減特徴が有効の場合は1.0を返す
return 1.0
end
#TP消費計算を別名定義で変更し、総合消費TPを計算
alias skill_tp_cost_extra_cost skill_tp_cost
def skill_tp_cost(skill)
#元のデータを取得する
data = skill_tp_cost_extra_cost(skill)
#元のデータに新規処理の総和を足す
data += tp_cost_fix(skill) + tp_cost_rate(skill) + tp_cost_mrate(skill) + tp_cost_eval(skill)
#軽減特徴を適用
data *= special_ex_tcr(skill)
#整数化して返す
return data.to_i
end
#消費固定TP
def tp_cost_fix(skill)
#スキルの消費固定TPを返す
skill.tp_cost_fix
end
#消費TP割合（現在値）
def tp_cost_rate(skill)
#スキルの消費TP割合と現在値をかけた後、0.01をかけた数字を返す
skill.tp_cost_rate * self.tp * 0.01
end
#消費TP割合（最大値）
def tp_cost_mrate(skill)
#スキルの消費最大TP割合と最大値をかけた後、0.01をかけた数字を返す
skill.tp_cost_mrate * self.max_tp * 0.01
end
#消費TP式
def tp_cost_eval(skill)
#スキルの消費TP割合式を返す
eval(skill.tp_cost_eval)
end
#消費TP軽減割合
def special_ex_tcr(skill)
#消費TP軽減特徴が無効の場合は消費MP軽減特徴の効果を反映させる
return [(100.0 - ex_tcr)/100, 0].max unless skill.ex_tcr_zero?
#消費TP軽減特徴が有効の場合は1.0を返す
return 1.0
end
#消費HP軽減割合の取得
def ex_hcr
#とりあえず0にする
data = 0
#特徴別に処理
feature_objects.each do |f|
#消費HP軽減割合を加算
data += f.ex_hcr
end
#データを返す
return data
end
#消費TP軽減割合の取得
def ex_tcr
#とりあえず0にする
data = 0
#特徴別に処理
feature_objects.each do |f|
#消費TP軽減割合を加算
data += f.ex_tcr
end
#データを返す
return data
end
end
class Scene_Skill < Scene_ItemBase
#スキル使用時のアクターへの効果のタイミングで
#HP消費の効果を反映させる。
alias use_item_to_actors_extra_cost use_item_to_actors
def use_item_to_actors
#使用者とスキルを取得。
target = user
item = target.last_skill.object
#本来の処理を実行。
use_item_to_actors_extra_cost
#スキルではない場合は処理を飛ばす。
return unless item.is_a?(RPG::Skill)
#スキル使用による戦闘不能が認められていて
#なおかつ使用者が生存している場合はHP消費を反映。
#認められていない場合は、HPの最低値を1としてHP消費を反映。
if target.alive? && target.hp > 0
if item.suicidable?
target.hp -= target.skill_hp_cost(item)
else
target.hp = [target.hp - target.skill_hp_cost(item), 1].max
end
end
end
end
class Scene_Battle < Scene_Base
#スキル使用後のタイミングで
#HP消費の効果を反映させる。
alias use_item_extra_cost use_item
def use_item
#使用者とスキルを取得。
target = @subject
item = target.current_action.item
#本来の処理を実行。
use_item_extra_cost
#スキルではない場合は処理を飛ばす。
return unless item.is_a?(RPG::Skill)
#スキル使用による戦闘不能が認められていて
#なおかつ使用者が生存している場合はHP消費を反映。
#認められていない場合は、HPの最低値を1としてHP消費を反映。
if target.alive? && target.hp > 0
if item.suicidable?
target.hp -= target.skill_hp_cost(item)
#HP消費によって戦闘不能となった場合
#ログウィンドウにその旨を出力する。
if !target.alive?
state = $data_states[1]
state_msg = target.actor? ? state.message1 : state.message2
target.perform_collapse_effect
@log_window.replace_text(target.name + state_msg)
@log_window.wait
@log_window.wait_for_effect
end
else
target.hp = [target.hp - target.skill_hp_cost(item), 1].max
end
end
end
end
class Window_Base < Window
#新たな制御文字として\ALPHACを加える。
#\ALPHACは、文字色変更時に透過度を保持する。
alias process_escape_character_extra_cost process_escape_character
def process_escape_character(code, text, pos)
if code.upcase == 'C'
alpha = contents.font.color.alpha
change_color(text_color(obtain_escape_param(text)))
contents.font.color.alpha = alpha
return
end
process_escape_character_extra_cost(code, text, pos)
end
#コスト表示用に、制御文字付きの描写方法を新たに定義する。
#通常の制御文字付き文章描画と異なり、文体のリセットを行わない。
def draw_text_ex_cost(x, y, text)
text = convert_escape_characters(text)
pos = {:x => x, :y => y, :new_x => x, :height => calc_line_height(text)}
process_character(text.slice!(0, 1), text, pos) until text.empty?
end
end
class Window_SkillList < Window_Selectable
#桁数の変更
alias col_max_extra_cost col_max
def col_max
data = col_max_extra_cost
data = EXTRA_SKILL_COST::COLMAX if data != EXTRA_SKILL_COST::COLMAX
return data
end
#スキルコストの記述方法を変更。
alias draw_skill_cost_extra_cost draw_skill_cost
def draw_skill_cost(rect, skill)
#表示形式が0の場合は本来の処理を実行
return draw_skill_cost_extra_cost(rect, skill) if EXTRA_SKILL_COST::COST_D == 0
#HP/MP/TP消費量を取得。
flag = [@actor.skill_hp_cost(skill),@actor.skill_mp_cost(skill),@actor.skill_tp_cost(skill)]
#スキルの使用可否に応じて記述内容の透過度を設定する。
contents.font.color.alpha = enable?(skill) ? 255 : translucent_alpha
#文字列の長さを取得する為、二つの文字列データを作成する。
text = ""
sub_text = ""
#HP
if EXTRA_SKILL_COST::HP_D && (EXTRA_SKILL_COST::COST_D > 1 or flag[0] > 0)
t = EXTRA_SKILL_COST::CTITLE ? Vocab::basic(3) : ""
if EXTRA_SKILL_COST::COST_D > 1 && flag[0].to_s.length != EXTRA_SKILL_COST::COST_D
number = EXTRA_SKILL_COST::COST_D - flag[0].to_s.length
number.times do
t+= " "
end
end
t += flag[0].to_s
sub_text += t
text += hp_cost_color_text + t
end
#MP
if EXTRA_SKILL_COST::MP_D && (EXTRA_SKILL_COST::COST_D > 1 or flag[1] > 0)
if text != ""
text += "\\ALPHAC[0]/"
sub_text += "/"
end
t = EXTRA_SKILL_COST::CTITLE ? Vocab::basic(5) : ""
if EXTRA_SKILL_COST::COST_D > 1 && flag[1].to_s.length != EXTRA_SKILL_COST::COST_D
number = EXTRA_SKILL_COST::COST_D - flag[1].to_s.length
number.times do
t+= " "
end
end
t += flag[1].to_s
sub_text += t
text += mp_cost_color_text + t
end
#TP
if EXTRA_SKILL_COST::TP_D && (EXTRA_SKILL_COST::COST_D > 1 or flag[2] > 0)
if text != ""
text += "\\ALPHAC[0]/"
sub_text += "/"
end
t = EXTRA_SKILL_COST::CTITLE ? Vocab::basic(7) : ""
if EXTRA_SKILL_COST::COST_D > 1 && flag[2].to_s.length != EXTRA_SKILL_COST::COST_D
number = EXTRA_SKILL_COST::COST_D - flag[2].to_s.length
number.times do
t+= " "
end
end
t += flag[2].to_s
sub_text += t
text += tp_cost_color_text + t
end
#文字列の長さを取得し、描写を実行する。
sub_x = text_size(sub_text).width
x = rect.x + rect.width - sub_x + EXTRA_SKILL_COST::COS_OX
y = rect.y
draw_text_ex_cost(x, y, text)
end
#消費HP記述用のキャッシュを生成。
def hp_cost_color_text
return @hp_cost_color_set if @hp_cost_color_set != nil
@hp_cost_color_set = "\\ALPHAC[" + EXTRA_SKILL_COST::HPCC.to_s + "]"
return @hp_cost_color_set
end
#消費MP記述用のキャッシュを生成。
def mp_cost_color_text
return @mp_cost_color_set if @mp_cost_color_set != nil
@mp_cost_color_set = "\\ALPHAC[" + EXTRA_SKILL_COST::MPCC.to_s + "]"
return @mp_cost_color_set
end
#消費TP記述用のキャッシュを生成。
def tp_cost_color_text
return @tp_cost_color_set if @tp_cost_color_set != nil
@tp_cost_color_set = "\\ALPHAC[" + EXTRA_SKILL_COST::TPCC.to_s + "]"
return @tp_cost_color_set
end
end
class RPG::BaseItem
#消費HP軽減特徴。
def ex_hcr
#キャッシュがある場合はキャッシュを返す。
return @feature_ex_hcr if @feature_ex_hcr != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD7A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@feature_ex_hcr = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @feature_ex_hcr
end
#消費TP軽減特徴。
def ex_tcr
#キャッシュがある場合はキャッシュを返す。
return @feature_ex_tcr if @feature_ex_tcr != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD9A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@feature_ex_tcr = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @feature_ex_tcr
end
end
class RPG::Skill < RPG::UsableItem
#消費HP軽減無効。
def ex_hcr_zero?
#キャッシュがある場合はキャッシュを返す。
return @ex_hcr_zero if @ex_hcr_zero != nil
#メモ欄からデータを取得。
@ex_hcr_zero = self.note.include?(EXTRA_SKILL_COST::WORD7B)
#データを返す。
return @ex_hcr_zero
end
#消費MP軽減無効。
def mcr_zero?
#キャッシュがある場合はキャッシュを返す。
return @mcr_zero if @mcr_zero != nil
#メモ欄からデータを取得。
@mcr_zero = self.note.include?(EXTRA_SKILL_COST::WORD8)
#データを返す。
return @mcr_zero
end
#消費TP軽減無効。
def ex_tcr_zero?
#キャッシュがある場合はキャッシュを返す。
return @ex_tcr_zero if @ex_tcr_zero != nil
#メモ欄からデータを取得。
@ex_tcr_zero = self.note.include?(EXTRA_SKILL_COST::WORD9B)
#データを返す。
return @ex_tcr_zero
end
def item_cost
#キャッシュがある場合はキャッシュを返す。
return @item_cost if @item_cost != nil
@item_cost = []
#メモ欄からデータを取得。
self.note.each_line do |l|
memo = l.scan(/<#{EXTRA_SKILL_COST::WORD1A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は飛ばす。
if memo != nil && !memo.empty?
memo = memo[0].split(/\s*,\s*/)
@item_cost.push([0, memo[0].to_i, memo[1] ? memo[1].to_i : 1])
end
memo = l.scan(/<#{EXTRA_SKILL_COST::WORD1B}[：:](\S+)>/).flatten
#データを取得出来無かった場合は飛ばす。
if memo != nil && !memo.empty?
memo = memo[0].split(/\s*,\s*/)
@item_cost.push([1, memo[0].to_i, memo[1] ? memo[1].to_i : 1])
end
memo = l.scan(/<#{EXTRA_SKILL_COST::WORD1C}[：:](\S+)>/).flatten
#データを取得出来無かった場合は飛ばす。
if memo != nil && !memo.empty?
memo = memo[0].split(/\s*,\s*/)
@item_cost.push([2, memo[0].to_i, memo[1] ? memo[1].to_i : 1])
end
end
#データを返す。
return @item_cost
end
def gold_cost_fix
#キャッシュがある場合はキャッシュを返す。
return @gold_cost_fix if @gold_cost_fix != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD2A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@gold_cost_fix = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @gold_cost_fix
end
def gold_cost_rate
#キャッシュがある場合はキャッシュを返す。
return @gold_cost_rate if @gold_cost_rate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD2B}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@gold_cost_rate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @gold_cost_rate
end
def gold_cost_eval
#キャッシュがある場合はキャッシュを返す。
return @gold_cost_eval if @gold_cost_eval != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD2C}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@gold_cost_eval = (memo != nil && !memo.empty?) ? memo[0].to_s : "0"
#データを返す。
return @gold_cost_eval
end
def var_cost_fix
#キャッシュがある場合はキャッシュを返す。
return @var_cost_fix if @var_cost_fix != nil
#配列を作成。
@var_cost_fix = []
#メモ欄からデータを取得。
self.note.each_line do |l|
memo = l.scan(/<#{EXTRA_SKILL_COST::WORD3A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は飛ばす。
if memo != nil && !memo.empty?
memo = memo[0].split(/\s*,\s*/)
@var_cost_fix.push([memo[0].to_i, memo[1].to_i])
end
end
#データを返す。
return @var_cost_fix
end
def var_cost_rate
#キャッシュがある場合はキャッシュを返す。
return @var_cost_rate if @var_cost_rate != nil
#配列を作成。
@var_cost_rate = []
#メモ欄からデータを取得。
self.note.each_line do |l|
memo = l.scan(/<#{EXTRA_SKILL_COST::WORD3B}[：:](\S+)>/).flatten
#データを取得出来無かった場合は飛ばす。
if memo != nil && !memo.empty?
memo = memo[0].split(/\s*,\s*/)
@var_cost_rate.push([memo[0].to_i, memo[1].to_i])
end
end
#データを返す。
return @var_cost_rate
end
def var_cost_eval
#キャッシュがある場合はキャッシュを返す。
return @var_cost_eval if @var_cost_eval != nil
#配列を作成。
@var_cost_eval = []
#メモ欄からデータを取得。
self.note.each_line do |l|
memo = l.scan(/<#{EXTRA_SKILL_COST::WORD3C}[：:](\S+)>/).flatten
#データを取得出来無かった場合は飛ばす。
if memo != nil && !memo.empty?
memo = memo[0].split(/\s*,\s*/)
@var_cost_eval.push([memo[0].to_i, memo[1].to_s])
end
end
#データを返す。
return @var_cost_eval
end
def hp_cost_fix
#キャッシュがある場合はキャッシュを返す。
return @hp_cost_fix if @hp_cost_fix != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD4A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@hp_cost_fix = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @hp_cost_fix
end
def hp_cost_rate
#キャッシュがある場合はキャッシュを返す。
return @hp_cost_rate if @hp_cost_rate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD4B}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@hp_cost_rate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @hp_cost_rate
end
def hp_cost_mrate
#キャッシュがある場合はキャッシュを返す。
return @hp_cost_mrate if @hp_cost_mrate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD4C}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@hp_cost_mrate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @hp_cost_mrate
end
def hp_cost_eval
#キャッシュがある場合はキャッシュを返す。
return @hp_cost_eval if @hp_cost_eval != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD4D}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@hp_cost_eval = (memo != nil && !memo.empty?) ? memo[0].to_s : "0"
#データを返す。
return @hp_cost_eval
end
def mp_cost_fix
#キャッシュがある場合はキャッシュを返す。
return @mp_cost_fix if @mp_cost_fix != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD5A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@mp_cost_fix = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @mp_cost_fix
end
def mp_cost_rate
#キャッシュがある場合はキャッシュを返す。
return @mp_cost_rate if @mp_cost_rate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD5B}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@mp_cost_rate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @mp_cost_rate
end
def mp_cost_mrate
#キャッシュがある場合はキャッシュを返す。
return @mp_cost_mrate if @mp_cost_mrate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD5C}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@mp_cost_mrate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @mp_cost_mrate
end
def mp_cost_eval
#キャッシュがある場合はキャッシュを返す。
return @mp_cost_eval if @mp_cost_eval != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD5D}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@mp_cost_eval = (memo != nil && !memo.empty?) ? memo[0].to_s : "0"
#データを返す。
return @mp_cost_eval
end
def tp_cost_fix
#キャッシュがある場合はキャッシュを返す。
return @tp_cost_fix if @tp_cost_fix != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD6A}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@tp_cost_fix = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @tp_cost_fix
end
def tp_cost_rate
#キャッシュがある場合はキャッシュを返す。
return @tp_cost_rate if @tp_cost_rate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD6B}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@tp_cost_rate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @tp_cost_rate
end
def tp_cost_mrate
#キャッシュがある場合はキャッシュを返す。
return @tp_cost_mrate if @tp_cost_mrate != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD6C}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@tp_cost_mrate = (memo != nil && !memo.empty?) ? memo[0].to_i : 0
#データを返す。
return @tp_cost_mrate
end
def tp_cost_eval
#キャッシュがある場合はキャッシュを返す。
return @tp_cost_eval if @tp_cost_eval != nil
#メモ欄からデータを取得。
memo = self.note.scan(/<#{EXTRA_SKILL_COST::WORD6D}[：:](\S+)>/).flatten
#データを取得出来無かった場合は0に設定する。
@tp_cost_eval = (memo != nil && !memo.empty?) ? memo[0].to_s : "0"
#データを返す。
return @tp_cost_eval
end
def suicidable?
#キャッシュがある場合はキャッシュを返す。
return @suicidable if @suicidable != nil
#メモ欄からデータを取得。
@suicidable = self.note.include?(EXTRA_SKILL_COST::WORD10)
#データを返す。
return @suicidable
end
end

复制代码

造小梦 · 发表于 2019-3-24 14:26:58

百里_飞柳发表于 2019-3-24 12:41
大概你加了什么技能消耗的扩展，然后里面有定义绘制前加的转义符，于是你自己加了\c的转义符来修改颜色？
...

我没加什么转义符啊，我直接导入脚本就用的

帐号		自动登录	找回密码
密码			注册会员

[已经解决] 游戏字体无法更改颜色怎么办？

加入我们，或者，欢迎回来。

评分

评分

点评

点评

极短24评委

极短23参与

极短22参与

极短21评委

老司机慢点开

短篇十吟唱者组别冠军

开拓者

剧作品鉴家