Escape from Funcraft: Beta 2 configs, mods, etc.

tacz/elitex_quality_guns/assets/elitex/scripts/aks_state_machine.lua

@@ -0,0 +1,233 @@
+-- 脚本的位置是 "{命名空间}:{路径}"，那么 require 的格式为 "{命名空间}_{路径}"
+-- 注意！require 取得的内容不应该被修改，应仅调用
+local default = require("tacz_default_state_machine")
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local MAIN_TRACK = default.MAIN_TRACK
+local main_track_states = default.main_track_states
+local static_track_top = default.static_track_top
+
+local inspect_state = setmetatable({}, {__index = main_track_states.inspect})
+local idle_state = setmetatable({}, {__index = main_track_states.idle})
+
+
+-- 相当于 obj.value++
+local function increment(obj)
+    obj.value = obj.value + 1
+    return obj.value - 1
+end
+
+local FIRE_MODE_TRACK = increment(static_track_top)
+local SWITCH_MODE_TRACK = increment(static_track_top)
+
+-- 检查当前是否还有弹药
+local function isNoAmmo(context)
+    -- 这里同时检查了枪管和弹匣
+    return (not context:hasBulletInBarrel()) and (context:getAmmoCount() <= 0)
+end
+
+local function runReloadAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+    -- 根据当前整枪内是否还有弹药决定是播放战术换弹还是空枪换弹
+    if (isNoAmmo(context)) then
+        -- "ext"表示扩容插件等级,"0"代表不装扩容插件
+        if (ext == 0) then
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+local function runInspectAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+    -- 根据当前整枪内是否还有弹药决定是播放普通检视还是空枪检视
+    if (isNoAmmo(context)) then
+        -- "ext"表示扩容插件等级,"0"代表不装扩容插件
+        if (ext == 0) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect_extended_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect_extended_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect_extended", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect_extended", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+function idle_state.transition(this, context, input)
+    if (input == INPUT_RELOAD) then
+        runReloadAnimation(context)
+        return this.main_track_states.idle
+    end
+    if (input == INPUT_PUT_AWAY) then
+        local put_away_time = context:getPutAwayTime()
+        -- 此处获取的轨道是位于主轨道行上的主轨道
+        local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+        -- 停下切换模式动画
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+        -- 播放 put_away 动画,并且将其过渡时长设为从上下文里传入的 put_away_time * 0.75
+        context:runAnimation("put_away", track, false, PLAY_ONCE_HOLD, put_away_time * 0.75)
+        -- 设定动画进度为最后一帧
+        context:setAnimationProgress(track, 1, true)
+        -- 将动画进度向前拨动 {put_away_time}
+        context:adjustAnimationProgress(track, -put_away_time, false)
+        return this.main_track_states.final
+    end
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        return inspect_state
+    end
+    return main_track_states.idle.transition(this, context, input)
+end
+
+-- 此处为开火模式轨道的状态,专门为快慢机动画服务,兼容其他动作,可按需求添加三种射击模式(semi、burst、auto)
+local fire_mode_state = {
+    -- 半自动状态
+    semi = {},
+    -- 全自动状态
+    auto = {},
+    -- 掏枪状态
+    draw = {}
+}
+-- 这一块专门用来检测枪械在掏枪(播放draw)时枪械处于什么射击模式,并切换到对应模式的idle
+function fire_mode_state.draw.update(this, context)
+    context:trigger(this.INPUT_MODE_DRAW)
+end
+
+function fire_mode_state.draw.transition(this, context,input)
+    if (input == this.INPUT_MODE_DRAW) then
+        if (context:getFireMode() == SEMI) then
+            context:runAnimation("static_semi", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.semi
+        elseif (context:getFireMode() == AUTO) then
+            context:runAnimation("static_auto", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.auto
+        end
+    end
+end
+-- 注意!后面关于每个开火模式对应状态之间的切换,需要按照data里填写的顺序进行转换
+function fire_mode_state.semi.update(this, context)
+    -- 当进入特定开火模式的状态时,挂起动画
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_semi", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    -- 为特定开火模式定义输入状态
+    if (context:getFireMode() == AUTO) then
+        context:trigger(this.INPUT_MODE_AUTO)
+    end
+end
+-- 当检测到对应输入状态时播放对应快慢机动画
+function fire_mode_state.semi.transition(this, context,input)
+    if(input == this.INPUT_MODE_AUTO)then
+        context:runAnimation("switch_auto", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.auto
+    end
+-- 检测到开火输入,换弹输入,检视输入时后停止播放动画,不然会出现两个动画在不同的轨道播放,从而出现动画衔接问题
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+-- 和上面同理
+function fire_mode_state.auto.update(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_auto", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    if (context:getFireMode() == SEMI) then
+        context:trigger(this.INPUT_MODE_SEMI)
+    end
+end
+
+function fire_mode_state.auto.transition(this, context,input)
+    if(input == this.INPUT_MODE_SEMI)then
+        context:runAnimation("switch_semi", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.semi
+    end
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT )then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+
+-- 当检测到开火模式切换输入时应该直接停止动画并返回闲置态
+function inspect_state.transition(this, context, input)
+    if (input == INPUT_FIRE_SELECT) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))
+        return this.main_track_states.idle
+    end
+    return main_track_states.inspect.transition(this, context, input)
+end
+
+
+-- 用元表的方式继承默认状态机的属性
+local M = setmetatable({
+    main_track_states = setmetatable({
+        idle = idle_state,
+        inspect = inspect_state
+    }, {__index = main_track_states}),
+    FIRE_MODE_TRACK = FIRE_MODE_TRACK,
+    SWITCH_MODE_TRACK = SWITCH_MODE_TRACK,
+    INPUT_MODE_SEMI = "input_mode_semi",
+    INPUT_MODE_AUTO = "input_mode_auto",
+    INPUT_MODE_DRAW = "input_mode_draw",
+    fire_mode_state = fire_mode_state
+}, {__index = default})
+function M:initialize(context)
+    default.initialize(self, context)
+end
+-- 继承默认状态机需要重新初始化状态
+function M:states()
+    return {
+        self.base_track_state,
+        self.bolt_caught_states.normal,
+        self.main_track_states.start,
+        self.gun_kick_state,
+        self.movement_track_states.idle,
+        self.ADS_states.normal,
+        self.slide_states.normal,
+        self.fire_mode_state.draw
+    }
+end
+-- 导出状态机
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/lee_state_machine.lua

@@ -0,0 +1,582 @@
+local track_line_top = {value = 0}
+local static_track_top = {value = 0}
+local blending_track_top = {value = 0}
+
+-- Credit goes to Silver hamster the creator of gunpowder revolution gunpack
+local function increment(obj)
+    obj.value = obj.value + 1
+    return obj.value - 1
+end
+
+local STATIC_TRACK_LINE = increment(track_line_top)
+local BASE_TRACK = increment(static_track_top)
+local BOLT_CAUGHT_TRACK = increment(static_track_top)
+local SAFETY_TRACK = increment(static_track_top) -- 待实现
+local ADS_TRACK = increment(blending_track_top)
+local MAIN_TRACK = increment(static_track_top)
+
+local GUN_KICK_TRACK_LINE = increment(track_line_top)
+
+local BLENDING_TRACK_LINE = increment(track_line_top)
+local MOVEMENT_TRACK = increment(blending_track_top)
+local LOOP_TRACK = increment(blending_track_top)
+
+local function runPutAwayAnimation(context)
+    local put_away_time = context:getPutAwayTime()
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    -- 播放 put_away 动画，并且将其剩余时长设为 context 传入的 put_away_time
+    context:runAnimation("put_away", track, false, PLAY_ONCE_HOLD, put_away_time * 0.75)
+    context:setAnimationProgress(track, 1, true)
+    context:adjustAnimationProgress(track, -put_away_time, false)
+end
+
+local function isNoAmmo(context)
+    return (not context:hasBulletInBarrel()) and (context:getAmmoCount() <= 0)
+end
+
+local function runReloadAnimation(context)
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    if (isNoAmmo(context)) then
+        context:runAnimation("reload_howell_empty", track, false, PLAY_ONCE_STOP, 0)
+    else
+        context:runAnimation("reload_howell", track, false, PLAY_ONCE_STOP, 0)
+    end
+end
+
+local function runInspectAnimation(context)
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    if (isNoAmmo(context)) then
+        context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+    else
+        context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+    end
+end
+
+local base_track_state = {}
+
+function base_track_state.entry(this, context)
+    context:runAnimation("static_idle", context:getTrack(STATIC_TRACK_LINE, BASE_TRACK), false, LOOP, 0.2)
+end
+
+function base_track_state.update(this, context)
+    if (context:getAttachment("MUZZLE") ~= "hamster:gas_tube") then
+        context:runAnimation("static_idle", context:getTrack(STATIC_TRACK_LINE, BASE_TRACK), false, LOOP, 0)
+    else
+        context:runAnimation("howell_idle", context:getTrack(STATIC_TRACK_LINE, BASE_TRACK), false, LOOP, 0)
+    end
+end
+
+local bolt_caught_states = {
+    normal = {},
+    bolt_caught = {}
+}
+
+function bolt_caught_states.normal.update(this, context)
+    if (not context:hasBulletInBarrel()) then
+        context:trigger(this.INPUT_BOLT_CAUGHT)
+    end
+end
+
+function bolt_caught_states.normal.entry(this, context)
+    this.bolt_caught_states.normal.update(this, context)
+end
+
+function bolt_caught_states.normal.transition(this, context, input)
+    if (input == this.INPUT_BOLT_CAUGHT) then
+        return this.bolt_caught_states.bolt_caught
+    end
+end
+
+function bolt_caught_states.bolt_caught.entry(this, context)
+    context:runAnimation("static_bolt_caught", context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK), false, LOOP, 0)
+end
+
+function bolt_caught_states.bolt_caught.update(this, context)
+    if (context:hasBulletInBarrel()) then
+        context:trigger(this.INPUT_BOLT_NORMAL)
+    end
+end
+
+function bolt_caught_states.bolt_caught.transition(this, context, input)
+    if (input == this.INPUT_BOLT_NORMAL) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK))
+        return this.bolt_caught_states.normal
+    end
+end
+
+local main_track_states = {
+    start = {},
+    idle = {},
+    reload = {
+        retreat = "reload_retreat",
+        need_ammo = 0,
+        loaded_ammo = 0,
+        emptyload = 0
+    },
+    inspect = {
+        retreat = "inspect_retreat"
+    },
+    shoot_mode = 0,
+    final = {},
+    bayonet_counter = 0
+}
+
+function main_track_states.start.transition(this, context, input)
+    if (input == INPUT_DRAW) then
+        context:runAnimation("draw", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0)
+        return main_track_states.idle
+    end
+end
+
+function main_track_states.idle.transition(this, context, input)
+    if (input == INPUT_PUT_AWAY) then
+        runPutAwayAnimation(context)
+        return main_track_states.final
+    end
+    if (input == INPUT_RELOAD) then
+        if (context:getAttachment("MUZZLE") ~= "hamster:gas_tube") then
+            return main_track_states.reload
+        else
+            runReloadAnimation(context)
+            return this.main_track_states.idle
+        end
+    end
+    if (input == INPUT_BOLT and context:getAttachment("MUZZLE") ~= "hamster:gas_tube") then
+        if (main_track_states.shoot_mode == 1) then
+            context:runAnimation("rapid_bolt", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        else
+            if (context:getAttachment("SCOPE") ~= "tacz:empty") then
+                context:runAnimation("bolt_scope", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+            else
+                context:runAnimation("bolt", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+            end
+            context:runAnimation("bolt_charge", context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        end
+        return main_track_states.idle
+    end
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        return main_track_states.inspect
+    end
+    if (input == INPUT_BAYONET_MUZZLE) then
+        local counter = main_track_states.bayonet_counter
+        local animationName = "melee_bayonet_" .. tostring(counter + 1)
+        main_track_states.bayonet_counter = (counter + 1) % 3
+        context:runAnimation(animationName, context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        return main_track_states.idle
+    end
+    if (input == INPUT_BAYONET_STOCK) then
+        context:runAnimation("melee_stock", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        return main_track_states.idle
+    end
+    if (input == INPUT_BAYONET_PUSH) then
+        context:runAnimation("melee_push", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        return main_track_states.idle
+    end
+end
+
+function main_track_states.reload.entry(this, context)
+    if (isNoAmmo(context)) then
+        main_track_states.reload.emptyload = 1
+        context:runAnimation("reload_start_empty", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_HOLD, 0.1)
+    elseif(context:getAmmoCount() == 0) then
+        context:runAnimation("reload_start_1round", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_HOLD, 0.1)
+    else
+        context:runAnimation("reload_start", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_HOLD, 0.1)
+    end
+    main_track_states.reload.need_ammo = context:getMaxAmmoCount() - context:getAmmoCount()
+    main_track_states.reload.loaded_ammo = 0
+    if(context:hasBulletInBarrel())then
+        main_track_states.reload.loaded_ammo = main_track_states.reload.loaded_ammo + 1
+    end
+end
+
+function main_track_states.reload.update(this, context)
+    if (main_track_states.reload.loaded_ammo > main_track_states.reload.need_ammo or not context:hasAmmoToConsume()) then
+        context:trigger(main_track_states.reload.retreat)
+    else
+        local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+        -- 等待 intro 结束，然后循环播放 loop 动画
+        if(context:isHolding(track)) then
+            if(main_track_states.reload.emptyload == 1) then
+                if (main_track_states.reload.need_ammo - main_track_states.reload.loaded_ammo >= 5) then
+                    context:runAnimation("reload_loop_clip_empty", track, false, PLAY_ONCE_HOLD, 0)
+                    main_track_states.reload.loaded_ammo = main_track_states.reload.loaded_ammo + 5
+                else
+                    context:runAnimation("reload_loop_empty", track, false, PLAY_ONCE_HOLD, 0)
+                    main_track_states.reload.loaded_ammo = main_track_states.reload.loaded_ammo + 1
+                end
+                main_track_states.reload.emptyload = 0
+            else
+                if (main_track_states.reload.need_ammo - main_track_states.reload.loaded_ammo >= 5) then
+                    context:runAnimation("reload_loop_clip", track, false, PLAY_ONCE_HOLD, 0)
+                    main_track_states.reload.loaded_ammo = main_track_states.reload.loaded_ammo + 5
+                else
+                    context:runAnimation("reload_loop", track, false, PLAY_ONCE_HOLD, 0)
+                    main_track_states.reload.loaded_ammo = main_track_states.reload.loaded_ammo + 1
+                end
+            end
+        end
+    end
+end
+
+function main_track_states.reload.transition(this, context, input)
+    if (input == main_track_states.reload.retreat or input == INPUT_CANCEL_RELOAD) then
+        context:runAnimation("reload_end", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.1)
+        main_track_states.reload.emptyload = 0
+        return main_track_states.idle
+    end
+    return this.main_track_states.idle.transition(this, context, input)
+end
+
+
+function main_track_states.inspect.entry(this, context)
+    context:setShouldHideCrossHair(true)
+end
+
+function main_track_states.inspect.exit(this, context)
+    context:setShouldHideCrossHair(false)
+end
+
+function main_track_states.inspect.update(this, context)
+    if (context:isStopped(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))) then
+        context:trigger(main_track_states.inspect.retreat)
+    end
+end
+
+function main_track_states.inspect.transition(this, context, input)
+    if (input == main_track_states.inspect.retreat) then
+        return main_track_states.idle
+    end
+    if (input == INPUT_SHOOT) then -- 特殊地，射击也应当打断检视
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))
+        return main_track_states.idle
+    end
+    return this.main_track_states.idle.transition(this, context, input)
+end
+
+local gun_kick_state = {}
+
+function gun_kick_state.transition(this, context, input)
+    if (input == INPUT_SHOOT) then
+        local track = context:findIdleTrack(GUN_KICK_TRACK_LINE, false)
+        if (context:getAttachment("MUZZLE") ~= "hamster:gas_tube") then
+            if (context:getAttachment("SCOPE") ~= "tacz:empty") then
+                context:runAnimation("shoot_scope", track, true, PLAY_ONCE_STOP, 0)
+            else
+                context:runAnimation("shoot", track, true, PLAY_ONCE_STOP, 0)
+            end
+        else
+            if (context:getAttachment("SCOPE") ~= "tacz:empty") then
+                context:runAnimation("shoot_howell_scope", track, true, PLAY_ONCE_STOP, 0)
+            else
+                context:runAnimation("shoot_howell", track, true, PLAY_ONCE_STOP, 0)
+            end
+        end
+        if (context:getAimingProgress() == 0) then
+            main_track_states.shoot_mode = 1
+        else
+            main_track_states.shoot_mode = 0
+        end
+    end
+    return nil
+end
+
+-- 移动轨道的状态,这部分到 450 行结束
+local movement_track_states = {
+    -- 静止不动(或者在天上)
+    idle = {},
+    -- 奔跑, -1 是没有奔跑, 0 是在奔跑中
+    run = {
+        mode = -1,
+        time = 0
+    },
+    -- 行走, -1 是没有行走, 0 是在空中, 1 是正在瞄准, 2 是在向前走, 3 是向后退, 4 是向侧面走
+    walk = {
+        mode = -1
+    }
+}
+
+-- 更新静止态
+function movement_track_states.idle.update(this, context)
+    -- 此处获取的是混合轨道行的移动轨道
+    local track = context:getTrack(BLENDING_TRACK_LINE, MOVEMENT_TRACK)
+    -- 如果轨道空闲，则播放 idle 动画
+    -- 注意此处没有写成是在 entry 播放 idle 动画是因为要实时检测轨道是否空闲
+    if (context:isStopped(track) or context:isHolding(track)) then
+        context:runAnimation("idle", track, true, LOOP, 0)
+    end
+end
+
+-- 转出静止态
+function movement_track_states.idle.transition(this, context, input)
+    -- 如果玩家在奔跑则转去奔跑态
+    if (input == INPUT_RUN) then
+        if (context:isStopped(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))) then
+            return this.movement_track_states.run
+        else
+            return this.movement_track_states.walk
+        end
+        -- 如果玩家在行走则转去行走态
+    elseif (input == INPUT_WALK) then
+        return this.movement_track_states.walk
+    end
+end
+
+-- 进入奔跑态
+function movement_track_states.run.entry(this, context)
+    this.movement_track_states.run.mode = -1
+    this.movement_track_states.run.time = context:getCurrentTimestamp()
+    -- 此处播放的轨道是混合轨道行的移动轨道,播放的动画是奔跑的起手式,播放结束后是挂起动画而不是停止
+    context:runAnimation("run_start", context:getTrack(BLENDING_TRACK_LINE, MOVEMENT_TRACK), true, PLAY_ONCE_HOLD, 0.2)
+end
+
+-- 退出奔跑态
+function movement_track_states.run.exit(this, context)
+    -- 此时播放的动画是奔跑结束回到 idle 的动画,同理播放完后挂起
+    context:runAnimation("run_end", context:getTrack(BLENDING_TRACK_LINE, MOVEMENT_TRACK), true, PLAY_ONCE_HOLD, 0.3)
+end
+
+-- 更新奔跑态
+function movement_track_states.run.update(this, context)
+    local track = context:getTrack(BLENDING_TRACK_LINE, MOVEMENT_TRACK)
+    local state = this.movement_track_states.run;
+    -- 等待 run_start 结束,然后循环播放 run ,此处的判断准则是轨道是否挂起,也就是为什么 entry 里播放动画要选 PLAY_ONCE_HOLD 模式
+    if (context:isHolding(track)) then
+        context:runAnimation("run", track, true, LOOP, 0.2)
+        -- 检测是否奔跑的标志位 0
+        state.mode = 0
+        context:anchorWalkDist() -- 打 walkDist 锚点，确保 run 动画的起点一致
+    end
+    if (state.mode ~= -1) then
+        if (not context:isOnGround()) then
+            -- 如果玩家在空中，则播放 run_hold 动画以稳定枪身
+            if (state.mode ~= 1) then
+                state.mode = 1
+                context:runAnimation("run_hold", track, true, LOOP, 0.6)
+            end
+        else
+            -- 如果玩家在地面，则切换回 run 动画
+            if (state.mode ~= 0) then
+                state.mode = 0
+                context:runAnimation("run", track, true, LOOP, 0.2)
+            end
+            -- 根据 walkDist 设置 run 动画的进度
+            context:setAnimationProgress(track, (context:getWalkDist() % 2.0) / 2.0, true)
+        end
+    end
+end
+
+-- 转出奔跑态
+function movement_track_states.run.transition(this, context, input)
+    -- 收到闲置输入则转去闲置态
+    if (input == INPUT_IDLE) then
+        return this.movement_track_states.idle
+        -- 收到行走输入则转去行走态
+    elseif (input == INPUT_WALK or not context:isStopped(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))) then
+        return this.movement_track_states.walk
+    end
+end
+
+
+-- 进入行走态
+function movement_track_states.walk.entry(this, context)
+    -- 此时给标志位置为 -1 相当于一个初始化
+    this.movement_track_states.walk.mode = -1
+end
+
+-- 退出行走态
+function movement_track_states.walk.exit(this, context)
+    -- 手动播放一次 idle 动画以打断 walk 动画的循环
+    context:runAnimation("idle", context:getTrack(BLENDING_TRACK_LINE, MOVEMENT_TRACK), true, PLAY_ONCE_HOLD, 0.4)
+end
+
+-- 更新行走态
+function movement_track_states.walk.update(this, context)
+    -- 此处获取的是混合轨道行的移动轨道
+    local track = context:getTrack(BLENDING_TRACK_LINE, MOVEMENT_TRACK)
+    -- 这里的 state 代指自身,相当于一个简化写法
+    local state = this.movement_track_states.walk
+    if (context:getShootCoolDown() > 0) then
+        -- 如果刚刚开火，则播放 idle 动画以稳定枪身
+        if (state.mode ~= 0) then
+            state.mode = 0
+            context:runAnimation("idle", track, true, LOOP, 0.3)
+        end
+    elseif (not context:isOnGround()) then
+        -- 如果玩家在空中，则播放 idle 动画以稳定枪身
+        if (state.mode ~= 0) then
+            state.mode = 0
+            context:runAnimation("idle", track, true, LOOP, 0.6)
+        end
+    elseif (context:getAimingProgress() > 0.5) then
+        -- 如果正在喵准，则需要播放 walk_aiming 动画
+        if (state.mode ~= 1) then
+            state.mode = 1
+            context:runAnimation("walk_aiming", track, true, LOOP, 0.3)
+        end
+    elseif (context:isInputUp()) then
+        -- 如果正在向前走，则需要播放 walk_forward 动画
+        if (state.mode ~= 2) then
+            state.mode = 2
+            context:runAnimation("walk_forward", track, true, LOOP, 0.4)
+            context:anchorWalkDist() -- 打 walkDist 锚点，确保行走动画的起点一致
+        end
+    elseif (context:isInputDown()) then
+        -- 如果正在向后退，则需要播放 walk_backward 动画
+        if (state.mode ~= 3) then
+            state.mode = 3
+            context:runAnimation("walk_backward", track, true, LOOP, 0.4)
+            context:anchorWalkDist() -- 打 walkDist 锚点，确保行走动画的起点一致
+        end
+    elseif (context:isInputLeft() or context:isInputRight()) then
+        -- 如果正在向侧面，则需要播放 walk_sideway 动画
+        if (state.mode ~= 4) then
+            state.mode = 4
+            context:runAnimation("walk_sideway", track, true, LOOP, 0.4)
+            context:anchorWalkDist() -- 打 walkDist 锚点，确保行走动画的起点一致
+        end
+    end
+    -- 根据 walkDist 设置行走动画的进度
+    if (state.mode >= 1 and state.mode <= 4) then
+        context:setAnimationProgress(track, (context:getWalkDist() % 2.0) / 2.0, true)
+    end
+end
+
+-- 转出行走态,这部分和转出奔跑态是一样的
+function movement_track_states.walk.transition(this, context, input)
+    -- 收到闲置信号则转到闲置态
+    if (input == INPUT_IDLE) then
+        return this.movement_track_states.idle
+        -- 收到奔跑信号则转到奔跑态
+    elseif (input == INPUT_RUN) then
+        if (context:isStopped(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))) then
+            return this.movement_track_states.run
+        end
+    end
+end
+-- 结束移动轨道的状态
+
+local ADS_states = {
+    aiming_progress = 0,-- 记录瞄准进度
+    normal = {},-- 不瞄准状态
+    aiming = {}-- 瞄准状态
+}
+
+-- 进入不瞄准状态
+function ADS_states.normal.entry(this, context)
+    this.ADS_states.normal.update(this, context)
+end
+
+-- 更新不瞄准状态
+function ADS_states.normal.update(this, context)
+    -- 当瞄准进度正在增加时转到瞄准状态
+    if (context:getAttachment("MUZZLE") == "hamster:gas_tube" and context:getAttachment("SCOPE") == "tacz:empty") then
+        if (context:getAimingProgress() > this.ADS_states.aiming_progress or context:getAimingProgress() == 1) then
+            context:trigger(this.INPUT_AIM)
+        else
+            -- 如果没有增加，则记录当前的瞄准进度
+            this.ADS_states.aiming_progress = context:getAimingProgress()
+        end
+    end
+end
+
+-- 转出不瞄准状态
+function ADS_states.normal.transition(this, context, input)
+    -- 接收到上文 update 方法的输入，则转到瞄准状态
+    if (input == this.INPUT_AIM) then
+        return this.ADS_states.aiming
+    end
+end
+
+-- 进入瞄准状态
+function ADS_states.aiming.entry(this, context)
+    -- 开始瞄准时播放瞄准动画，并且将其挂起
+    local track = context:getTrack(BLENDING_TRACK_LINE, ADS_TRACK)
+    context:runAnimation("aim_start", track, true, PLAY_ONCE_HOLD, 0.2)
+    -- 打断检视动画
+    context:trigger(this.INPUT_INSPECT_RETREAT)
+end
+
+-- 更新瞄准状态
+function ADS_states.aiming.update(this, context)
+    local track = context:getTrack(BLENDING_TRACK_LINE, ADS_TRACK)
+    if (context:isHolding(track)) then
+        -- 循环播放瞄准时的动画
+        context:runAnimation("aim", track, true, PLAY_ONCE_HOLD, 0.2)
+    end
+    -- 当瞄准进度正在减小时转到不瞄准状态，也即取消瞄准
+    if (context:getAimingProgress() < this.ADS_states.aiming_progress) then
+        context:trigger(this.INPUT_AIM_RETREAT)
+    else
+        -- 如果没有减小，则记录当前瞄准进度
+        this.ADS_states.aiming_progress = context:getAimingProgress()
+    end
+end
+
+-- 转出瞄准状态
+function ADS_states.aiming.transition(this, context, input)
+    local track = context:getTrack(BLENDING_TRACK_LINE, ADS_TRACK)
+    if (input == this.INPUT_AIM_RETREAT) then
+        --播放瞄准结束动画，并调整动画进度使开镜动画与当前的开镜进度相对应
+        context:runAnimation("aim_end", track, true, PLAY_ONCE_STOP, 0.2)
+        return this.ADS_states.normal
+    end
+end
+
+local M = {
+    -- track lines
+    track_line_top = track_line_top,
+    STATIC_TRACK_LINE = STATIC_TRACK_LINE,
+    GUN_KICK_TRACK_LINE = GUN_KICK_TRACK_LINE,
+    BLENDING_TRACK_LINE = BLENDING_TRACK_LINE,
+    -- static tracks
+    static_track_top = static_track_top,
+    BASE_TRACK = BASE_TRACK,
+    BOLT_CAUGHT_TRACK = BOLT_CAUGHT_TRACK,
+    SAFETY_TRACK = SAFETY_TRACK,
+    ADS_TRACK = ADS_TRACK,
+    MAIN_TRACK = MAIN_TRACK,
+    -- blending tracks
+    blending_track_top = blending_track_top,
+    MOVEMENT_TRACK = MOVEMENT_TRACK,
+    LOOP_TRACK = LOOP_TRACK,
+    -- states
+    base_track_state = base_track_state,
+    bolt_caught_states = bolt_caught_states,
+    main_track_states = main_track_states,
+    gun_kick_state = gun_kick_state,
+    movement_track_states = movement_track_states,
+    ADS_states = ADS_states,
+    -- inputs
+    INPUT_BOLT_CAUGHT = "bolt_caught",
+    INPUT_BOLT_NORMAL = "bolt_normal",
+    INPUT_INSPECT_RETREAT = "inspect_retreat",
+    INPUT_AIM = "aim",
+    INPUT_AIM_RETREAT = "aim_retreat"
+}
+
+function M:initialize(context)
+    context:ensureTrackLineSize(track_line_top.value)
+    context:ensureTracksAmount(STATIC_TRACK_LINE, static_track_top.value)
+    context:ensureTracksAmount(BLENDING_TRACK_LINE, blending_track_top.value)
+    self.movement_track_states.run.mode = -1
+    self.movement_track_states.walk.mode = -1
+end
+
+function M:exit(context)
+    -- do some cleaning up things
+end
+
+function M:states()
+    return {
+        self.base_track_state,
+        self.bolt_caught_states.normal,
+        self.main_track_states.start,
+        self.gun_kick_state,
+        self.movement_track_states.idle,
+        self.ADS_states.normal
+    }
+end
+
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/lee_state_machine_backup.lua

@@ -0,0 +1,70 @@
+-- Striker-12 State Machine (now using 'reload_start')
+
+local default = require("tacz_manual_action_state_machine")
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local MAIN_TRACK = default.MAIN_TRACK
+local main_track_states = default.main_track_states
+
+local idle_state = setmetatable({}, {__index = main_track_states.idle})
+
+function idle_state.transition(this, context, input)
+    if (input == INPUT_RELOAD) then
+        return this.main_track_states.reload
+    end
+    if (input == INPUT_INSPECT) then
+        context:runAnimation("inspect", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        return this.main_track_states.inspect
+    end
+    return main_track_states.idle.transition(this, context, input)
+end
+
+local reload_state = {
+    need_ammo = 0,
+    loaded_ammo = 0
+}
+
+function reload_state.entry(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    context:runAnimation("reload_start", track, false, PLAY_ONCE_HOLD, 0.2)
+    local state = this.main_track_states.reload
+    state.need_ammo = context:getMaxAmmoCount() - context:getAmmoCount()
+    state.loaded_ammo = 0
+end
+
+function reload_state.update(this, context)
+    local state = this.main_track_states.reload
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+
+    if (context:isHolding(track)) then
+        if (state.loaded_ammo < state.need_ammo and context:hasAmmoToConsume()) then
+            context:runAnimation("reload_loop", track, false, PLAY_ONCE_HOLD, 0)
+            state.loaded_ammo = state.loaded_ammo + 1
+        else
+            context:trigger(this.INPUT_RELOAD_RETREAT)
+        end
+    end
+end
+
+function reload_state.transition(this, context, input)
+    if (input == this.INPUT_RELOAD_RETREAT or input == INPUT_CANCEL_RELOAD) then
+        context:runAnimation("reload_end", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        return this.main_track_states.idle
+    end
+    return this.main_track_states.idle.transition(this, context, input)
+end
+
+local M = setmetatable({
+    main_track_states = setmetatable({
+        idle = idle_state,
+        reload = reload_state,
+    }, {__index = main_track_states}),
+    INPUT_RELOAD_RETREAT = "reload_retreat",
+}, {__index = default})
+
+function M:initialize(context)
+    default.initialize(self, context)
+    self.main_track_states.reload.need_ammo = 0
+    self.main_track_states.reload.loaded_ammo = 0
+end
+
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/m16_state_machine.lua

@@ -0,0 +1,271 @@
+-- 脚本的位置是 "{命名空间}:{路径}"，那么 require 的格式为 "{命名空间}_{路径}"
+-- 注意！require 取得的内容不应该被修改，应仅调用
+local default = require("tacz_default_state_machine")
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local MAIN_TRACK = default.MAIN_TRACK
+local main_track_states = default.main_track_states
+local static_track_top = default.static_track_top
+
+local inspect_state = setmetatable({}, {__index = main_track_states.inspect})
+local idle_state = setmetatable({}, {__index = main_track_states.idle})
+
+
+-- 相当于 obj.value++
+local function increment(obj)
+    obj.value = obj.value + 1
+    return obj.value - 1
+end
+
+local FIRE_MODE_TRACK = increment(static_track_top)
+local SWITCH_MODE_TRACK = increment(static_track_top)
+
+-- 检查当前是否还有弹药
+local function isNoAmmo(context)
+    -- 这里同时检查了枪管和弹匣
+    return (not context:hasBulletInBarrel()) and (context:getAmmoCount() <= 0)
+end
+
+local function runReloadAnimation(context)
+
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+
+    if (isNoAmmo(context)) then
+
+        if (ext == 0) then
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_extended_empty_1", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2) then
+            context:runAnimation("reload_extended_empty_2", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 3) then
+            context:runAnimation("reload_extended_empty_2", track, false, PLAY_ONCE_STOP, 0.2)
+
+        else
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_extended_1", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2) then
+           context:runAnimation("reload_extended_2", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 3) then
+           context:runAnimation("reload_extended_2", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+local function runInspectAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+    -- 根据当前整枪内是否还有弹药决定是播放普通检视还是空枪检视
+    if (isNoAmmo(context)) then
+        -- "ext"表示扩容插件等级,"0"代表不装扩容插件
+        if (ext == 0) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+function idle_state.transition(this, context, input)
+    if (input == INPUT_RELOAD) then
+        runReloadAnimation(context)
+        return this.main_track_states.idle
+    end
+    if (input == INPUT_PUT_AWAY) then
+        local put_away_time = context:getPutAwayTime()
+        -- 此处获取的轨道是位于主轨道行上的主轨道
+        local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+        -- 停下切换模式动画
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+        -- 播放 put_away 动画,并且将其过渡时长设为从上下文里传入的 put_away_time * 0.75
+        context:runAnimation("put_away", track, false, PLAY_ONCE_HOLD, put_away_time * 0.75)
+        -- 设定动画进度为最后一帧
+        context:setAnimationProgress(track, 1, true)
+        -- 将动画进度向前拨动 {put_away_time}
+        context:adjustAnimationProgress(track, -put_away_time, false)
+        return this.main_track_states.final
+    end
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        return inspect_state
+    end
+    return main_track_states.idle.transition(this, context, input)
+end
+
+-- 此处为开火模式轨道的状态,专门为快慢机动画服务,兼容其他动作,可按需求添加三种射击模式(semi、burst、auto)
+local fire_mode_state = {
+    -- 半自动状态
+    semi = {},
+    -- 连射状态
+    burst = {},
+    -- 全自动状态
+    auto = {},
+    -- 掏枪状态
+    draw = {}
+}
+-- 这一块专门用来检测枪械在掏枪(播放draw)时枪械处于什么射击模式,并切换到对应模式的idle
+function fire_mode_state.draw.update(this, context)
+    context:trigger(this.INPUT_MODE_DRAW)
+end
+
+function fire_mode_state.draw.transition(this, context,input)
+    if (input == this.INPUT_MODE_DRAW) then
+        if (context:getFireMode() == SEMI) then
+            context:runAnimation("static_semi", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.semi
+        elseif (context:getFireMode() == BURST) then
+            context:runAnimation("static_burst", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.burst
+        elseif (context:getFireMode() == AUTO) then
+            context:runAnimation("static_auto", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.auto
+        end
+    end
+end
+-- 注意!后面关于每个开火模式对应状态之间的切换,需要按照data里填写的顺序进行转换
+function fire_mode_state.semi.update(this, context)
+    -- 当进入特定开火模式的状态时,挂起动画
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_semi", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    -- 为特定开火模式定义输入状态
+    if (context:getFireMode() == AUTO) then
+        context:trigger(this.INPUT_MODE_AUTO)
+    end
+end
+-- 当检测到对应输入状态时播放对应快慢机动画
+function fire_mode_state.semi.transition(this, context,input)
+    if(input == this.INPUT_MODE_AUTO)then
+        context:runAnimation("switch_auto", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.auto
+    end
+-- 检测到开火输入,换弹输入,检视输入时后停止播放动画,不然会出现两个动画在不同的轨道播放,从而出现动画衔接问题
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+-- 和上面同理
+function fire_mode_state.burst.update(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_burst", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    if (context:getFireMode() == SEMI) then
+        context:trigger(this.INPUT_MODE_SEMI)
+    end
+end
+
+function fire_mode_state.burst.transition(this, context,input)
+    if(input == this.INPUT_MODE_SEMI)then
+        context:runAnimation("switch_semi", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.semi
+    end
+
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+
+function fire_mode_state.auto.update(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_auto", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    if (context:getFireMode() == BURST) then
+        context:trigger(this.INPUT_MODE_BURST)
+    end
+end
+
+function fire_mode_state.auto.transition(this, context,input)
+    if(input == this.INPUT_MODE_BURST)then
+        context:runAnimation("switch_burst", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.burst
+    end
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT )then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+
+-- 当检测到开火模式切换输入时应该直接停止动画并返回闲置态
+function inspect_state.transition(this, context, input)
+    if (input == INPUT_FIRE_SELECT) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))
+        return main_track_states.idle
+    end
+    return main_track_states.inspect.transition(this, context, input)
+end
+
+
+-- 用元表的方式继承默认状态机的属性
+local M = setmetatable({
+    main_track_states = setmetatable({
+        idle = idle_state,
+        inspect = inspect_state
+    }, {__index = main_track_states}),
+    FIRE_MODE_TRACK = FIRE_MODE_TRACK,
+    SWITCH_MODE_TRACK = SWITCH_MODE_TRACK,
+    INPUT_MODE_SEMI = "input_mode_semi",
+    INPUT_MODE_BURST = "input_mode_burst",
+    INPUT_MODE_AUTO = "input_mode_auto",
+    INPUT_MODE_DRAW = "input_mode_draw",
+    fire_mode_state = fire_mode_state
+}, {__index = default})
+function M:initialize(context)
+    default.initialize(self, context)
+end
+-- 继承默认状态机需要重新初始化状态
+function M:states()
+    return {
+        self.base_track_state,
+        self.bolt_caught_states.normal,
+        self.main_track_states.start,
+        self.gun_kick_state,
+        self.movement_track_states.idle,
+        self.ADS_states.normal,
+        self.slide_states.normal,
+        self.fire_mode_state.draw
+    }
+end
+-- 导出状态机
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/m1_garand_state_machine.lua

@@ -0,0 +1,29 @@
+local default = require("tacz_default_state_machine")
+local GUN_KICK_TRACK_LINE = default.GUN_KICK_TRACK_LINE
+
+local gun_kick_state = setmetatable({}, { __index = default.gun_kick_state })
+
+function gun_kick_state.transition(this, context, input)
+    if input == INPUT_SHOOT then
+        local track = context:findIdleTrack(GUN_KICK_TRACK_LINE, false)
+        local ammo = context:getAmmoCount()
+
+        if ammo == 1 then
+            -- Play shoot_last, fallback to STOP if HOLD causes visual issues
+            context:runAnimation("shoot_last", track, true, PLAY_ONCE_STOP, 0)
+        elseif ammo > 1 then
+            context:runAnimation("shoot", track, true, PLAY_ONCE_STOP, 0)
+        end
+    end
+    return nil
+end
+
+local M = setmetatable({
+    gun_kick_state = gun_kick_state
+}, { __index = default })
+
+function M:initialize(context)
+    default.initialize(self, context)
+end
+
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/m1_garand_state_machine_BACKUP2.lua

@@ -0,0 +1,110 @@
+local default = require("tacz_default_state_machine")
+local GUN_KICK_TRACK_LINE = default.GUN_KICK_TRACK_LINE
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local BOLT_CAUGHT_TRACK = default.BOLT_CAUGHT_TRACK
+local main_track_states = default.main_track_states
+local MAIN_TRACK = default.MAIN_TRACK
+
+local bolt_caught_states = default.bolt_caught_states
+
+local gun_kick_state = setmetatable({}, {__index = default.gun_kick_state})
+local bolt_caught = setmetatable({
+    mode = -1
+}, {__index = bolt_caught_states.bolt_caught})
+local normal = setmetatable({}, {__index = bolt_caught_states.normal})
+
+local idle_state = setmetatable({
+    empty = -1
+}, {__index = main_track_states.idle})
+
+function gun_kick_state.transition(this, context, input)
+    if (input == INPUT_SHOOT) then
+        local track = context:findIdleTrack(GUN_KICK_TRACK_LINE, false)
+        if(context:getAmmoCount() ~= 1) then
+            context:runAnimation("shoot", track, true, PLAY_ONCE_STOP, 0)
+        else
+            context:runAnimation("shoot_last", context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK), true, PLAY_ONCE_HOLD, 0)
+        end
+    end
+    return nil
+end
+
+function idle_state.transition(this, context, input)
+    if (input == INPUT_RELOAD) then
+        if (context:getAmmoCount() <= 0) then
+            context:runAnimation("reload_empty", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        else
+            idle_state.empty = context:getCurrentTimestamp()
+            context:runAnimation("reload_tactical", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+            context:runAnimation("ammo_display", context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK), false, PLAY_ONCE_STOP, 0)
+        end
+        return this.main_track_states.idle
+    end
+    return main_track_states.idle.transition(this, context, input)
+end
+
+function idle_state.update(this, context)
+    if (context:getCurrentTimestamp() < idle_state.empty + 1800) then
+        context:setAnimationProgress(context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK), 0.9 - context:getAmmoCount()/10, false)
+    else
+        if (idle_state.empty ~= -1) then
+            context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK))
+        end
+        idle_state.empty = -1
+    end
+end
+
+function normal.update(this, context)
+    if (context:getAmmoCount() <= 0) then
+        context:trigger(this.INPUT_BOLT_CAUGHT)
+    end
+end
+
+function normal.entry(this, context)
+    this.bolt_caught_states.normal.update(this, context)
+end
+
+function normal.transition(this, context, input)
+    if (input == this.INPUT_BOLT_CAUGHT) then
+        return this.bolt_caught_states.bolt_caught
+    end
+end
+
+function bolt_caught.entry(this, context)
+    if (bolt_caught.mode == 1) then
+        context:setAnimationProgress(context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK), 1, false)
+    else
+        bolt_caught.mode = 1
+    end
+end
+
+function bolt_caught.update(this, context)
+    if (context:getAmmoCount() > 0) then
+        context:trigger(default.INPUT_BOLT_NORMAL)
+    end
+end
+
+function bolt_caught.transition(this, context, input)
+    if (input == default.INPUT_BOLT_NORMAL) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK))
+        bolt_caught.mode = -1
+        return this.bolt_caught_states.normal
+    end
+end
+
+local M = setmetatable({
+    main_track_states = setmetatable({
+        idle = idle_state
+    }, {__index = main_track_states}),
+    bolt_caught_states = setmetatable({
+        normal = normal,
+        bolt_caught = bolt_caught,
+    }, {__index = bolt_caught_states}),
+    gun_kick_state = gun_kick_state
+}, {__index = default})
+
+function M:initialize(context)
+    default.initialize(self, context)
+end
+
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/m249x_state_machine.lua

@@ -0,0 +1,506 @@
+-- 这些栈顶指针在分配新的轨道行和轨道时起作用
+-- 轨道行 栈顶指针
+local track_line_top = {value = 0}
+-- 主轨道行 的 轨道 栈顶指针
+local static_track_top = {value = 0}
+-- 混合轨道行 的 轨道 栈顶指针
+local blending_track_top = {value = 0}
+-- 栈顶指针自增函数，用于分配新的轨道行或者轨道 
+local function increment(obj)
+    obj.value = obj.value + 1
+    return obj.value - 1
+end
+
+-- 主轨道行 和 其中的五条轨道
+local STATIC_TRACK_LINE = increment(track_line_top)
+local BASE_TRACK = increment(static_track_top)
+local BOLT_CAUGHT_TRACK = increment(static_track_top)
+local SAFETY_TRACK = increment(static_track_top) -- 待实现
+local ADS_TRACK = increment(static_track_top) -- 待实现
+local MAIN_TRACK = increment(static_track_top)
+
+-- 开火的轨道行
+local GUN_KICK_TRACK_LINE = increment(track_line_top)
+
+-- 混合轨道行 和 其中的两条轨道,用于叠加动画,如跑步走路跳跃, LOOP_TRACK 只有定义却尚未启用,因此作用尚不得知
+local BLENDING_TRACK_LINE = increment(track_line_top)
+local MOVEMENT_TRACK = increment(blending_track_top)
+local LOOP_TRACK = increment(blending_track_top)
+
+-- 播放丢枪动画的方法
+local function runPutAwayAnimation(context)
+    local put_away_time = context:getPutAwayTime()
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    -- 播放 put_away 动画,并且将其过渡时长设为从上下文里传入的 put_away_time * 0.75
+    context:runAnimation("put_away", track, false, PLAY_ONCE_HOLD, put_away_time * 0.75)
+    -- 设定动画进度为最后一帧
+    context:setAnimationProgress(track, 1, true)
+    -- 将动画进度向前拨动 {put_away_time}
+    context:adjustAnimationProgress(track, -put_away_time, false)
+end
+
+-- 检查当前是否还有弹药
+local function isNoAmmo(context)
+    -- 这里同时检查了枪管和弹匣
+    return (not context:hasBulletInBarrel()) and (context:getAmmoCount() <= 0)
+end
+
+-- 播放换弹动画的方法
+local function runReloadAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    -- 根据当前整枪内是否还有弹药决定是播放战术换弹还是空枪换弹
+    if (isNoAmmo(context)) then
+        context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+    else
+        context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+    end
+end
+
+-- 播放检视动画的方法
+local function runInspectAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    -- 根据当前整枪内是否还有弹药决定是播放普通检视还是空枪检视
+    if (isNoAmmo(context)) then
+        context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+    else
+        context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+    end
+end
+
+-- 基础轨道上的状态,这个状态用于循环播放 static_idle 动画。
+local base_track_state = {}
+
+-- 进入基础状态,直接播放 static_idle
+function base_track_state.entry(this, context)
+    -- 在 主轨道行 的 基础轨道 上循环播放 static_idle
+    context:runAnimation("static_idle", context:getTrack(STATIC_TRACK_LINE, BASE_TRACK), false, LOOP, 0)
+end
+
+-- 空挂部分,该部分到 147 行结束
+-- 由于空挂分为"空挂"和"不空挂"两类,因此这里面需要两个状态来调控当前武器
+-- 空挂的两个状态之间是会来回切换的,因此每个子状态都需要以下三个方法来操作
+-- entry 方法是进入该状态时发生的事,只在进入状态时执行一次
+-- update 方法是在该状态时每一渲染帧都会调用的事,注意这里是每一渲染帧,并不是游戏的 tick ,因此这个方法的执行频率远远大于 tick (除非你电脑玩游戏连 20 帧都不到)
+-- transition 方法是该状态的转出,只在转换为别的状态时执行一次
+-- 
+-- 这部分的一般实现逻辑是
+-- entry 负责在进入 update 前播放相关动画并进入 update
+-- update 负责实时检测是否需要转出状态,如有需要则触发 transition
+-- transition 负责接收 update 传来的信息,在被触发后需要停止相关动画并转去其他状态
+-- 这套逻辑在之后的主状态里一样生效
+local bolt_caught_states = {
+    -- normal 是不空挂的正常状态
+    normal = {},
+    -- bolt_caught 是空挂时的状态
+    bolt_caught = {}
+}
+
+-- 更新"不空挂"状态
+function bolt_caught_states.normal.update(this, context)
+    -- 如果弹药数量是 0 了,那么立刻手动触发一次转到"空挂"状态的输入
+    if (isNoAmmo(context)) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK))
+        context:trigger(this.INPUT_BOLT_CAUGHT)
+    else
+        local a = context:getAmmoCount()
+        if (a < 9) then
+            context:setAnimationProgress(context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK),0.1+(8-a)*0.5,false)
+        else
+            context:setAnimationProgress(context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK),0.1,false)
+        end
+    end
+end
+
+-- 进入"不空挂"状态
+function bolt_caught_states.normal.entry(this, context)
+    context:runAnimation("static_ammo_display", context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK), false, PLAY_ONCE_STOP, 0)
+    this.bolt_caught_states.normal.update(this, context)
+end
+
+-- 转出"不空挂"状态
+function bolt_caught_states.normal.transition(this, context, input)
+    -- 如果收到了"空挂"的输入,那么直接转到"空挂"状态,"'空挂'的输入"是在上文 update 方法中出现的
+    if (input == this.INPUT_BOLT_CAUGHT) then
+        return this.bolt_caught_states.bolt_caught
+    end
+end
+
+-- 进入"空挂"状态
+function bolt_caught_states.bolt_caught.entry(this, context)
+    -- 进入空挂时在主轨道行的空挂轨道播放空挂的动画
+    context:runAnimation("static_bolt_caught", context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK), false, LOOP, 0)
+end
+
+-- 更新"空挂"状态
+function bolt_caught_states.bolt_caught.update(this, context)
+    -- 如果检测到子弹数不为 0 了(此时是换弹了),那么手动触发一次转到"不空挂"状态的输入
+    if (not isNoAmmo(context)) then
+        context:trigger(this.INPUT_BOLT_NORMAL)
+    end
+end
+
+-- 转出"空挂"状态
+function bolt_caught_states.bolt_caught.transition(this, context, input)
+    -- 如果收到了来自上文 update 方法的输入,则转到"不空挂"状态
+    if (input == this.INPUT_BOLT_NORMAL) then
+        -- 由于并没有一个"不空挂"的动画,因此必须在这里把空挂动画停止了才能转到"不空挂"状态,否则你会在换完弹之后发现依旧处于空挂状态
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, BOLT_CAUGHT_TRACK))
+        return this.bolt_caught_states.normal
+    end
+end
+-- 结束空挂部分
+
+-- 主轨道状态,该部分到 256 行结束
+-- 主轨道控制的是武器的基本动作,包括换弹,检视,刺刀攻击,掏枪,丢枪
+-- 除了检视，其他动作不需要单独的状态控制。
+-- 检视状态需要被射击输入打断，此外，进入检视时，需要隐藏准心，退出检视时恢复准心。
+-- 除了上文的那三个方法，检视还需要 exit 方法，用于恢复准心渲染
+local main_track_states = {
+    -- 起始
+    start = {},
+    -- 闲置,当玩家把枪拿在手里站定并什么也不做的时候就是这种情况
+    idle = {},
+    -- 检视
+    inspect = {},
+    -- 结束
+    final = {},
+    -- 刺刀攻击的计数器
+    bayonet_counter = 0
+}
+
+-- 转出 start (其实就是掏枪)
+function main_track_states.start.transition(this, context, input)
+    -- 玩家手里拿到枪的那一瞬间会自动输入一个 draw 的信号,不用手动触发
+    if (input == INPUT_DRAW) then
+        -- 收到 draw 信号后在主轨道行的主轨道上播放掏枪动画,然后转到闲置态
+        context:runAnimation("draw", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0)
+        return this.main_track_states.idle
+    end
+end
+
+-- 转出闲置态
+function main_track_states.idle.transition(this, context, input)
+    -- 玩家从枪切到其他物品的时候会自动输入丢枪的信号,不用手动触发,只要检测就好了
+    if (input == INPUT_PUT_AWAY) then
+        runPutAwayAnimation(context)
+        -- 丢枪后转到最终态
+        return this.main_track_states.final
+    end
+    -- 玩家拿着枪按下 R (或者别的什么自己绑定的换弹键)时会自动输入换弹信号
+    if (input == INPUT_RELOAD) then
+        runReloadAnimation(context)
+        -- 换弹动画播放完后返回闲置态(也就是返回自己)
+        return this.main_track_states.idle
+    end
+    -- 玩家在射击时会自动输入 shoot 信号
+    if (input == INPUT_SHOOT) then
+        context:popShellFrom(0) -- 默认射击抛壳
+        -- 返回闲置态(也就是返回自己),这里不播放射击动画是因为射击动画应该在 gun_kick 状态里播
+        return this.main_track_states.idle
+    end
+    -- 玩家在使用栓动武器射击完成后拉栓会自动输入 bolt 信号
+    if (input == INPUT_BOLT) then
+        context:runAnimation("bolt", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        -- 拉栓动画播放完后返回闲置态
+        return this.main_track_states.idle
+    end
+    -- 玩家按下检视键后会输入检视信号
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        -- 检视需要转到检视态,因为检视过程中屏幕中央准星是隐藏的,因此需要一个检视态来调控准星
+        return this.main_track_states.inspect
+    end
+    -- 玩家使用近战武器时输入的近战信号,分为近战配件、枪托、推击这三种情况
+    -- 近战配件可以使用多种近战动画,而枪托和推击则是在枪配置文件里写的"无近战配件时的近战攻击",只能使用一个动画
+    if (input == INPUT_BAYONET_MUZZLE) then
+        -- 这里是一个顺序播放动画的方法,通过存储在状态里的 counter 决定当前播放的是第几个近战动画, animationName 是一个组合起来的字符串
+        -- 这样写法会使依次运行 "melee_bayonet_1" "melee_bayonet_2" "melee_bayonet_3" 这三个动画, 3 运行完后再近战则会返回 1
+        local counter = this.main_track_states.bayonet_counter
+        local animationName = "melee_bayonet_" .. tostring(counter + 1)
+        this.main_track_states.bayonet_counter = (counter + 1) % 3
+        context:runAnimation(animationName, context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        return this.main_track_states.idle
+    end
+    -- 枪托肘完之后返回闲置态
+    if (input == INPUT_BAYONET_STOCK) then
+        context:runAnimation("melee_stock", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        return this.main_track_states.idle
+    end
+    -- 推击完之后返回闲置态
+    if (input == INPUT_BAYONET_PUSH) then
+        context:runAnimation("melee_push", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        return this.main_track_states.idle
+    end
+end
+
+-- 进入检视态
+function main_track_states.inspect.entry(this, context)
+    -- 检视是需要隐藏屏幕中央准星
+    context:setShouldHideCrossHair(true)
+end
+
+-- 退出检视态
+function main_track_states.inspect.exit(this, context)
+    -- 退出后恢复屏幕中央准星
+    context:setShouldHideCrossHair(false)
+end
+
+-- 更新检视态
+function main_track_states.inspect.update(this, context)
+    -- 当检测到动画停止了(播完了)时手动触发一次退出信号
+    if (context:isStopped(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))) then
+        context:trigger(this.INPUT_INSPECT_RETREAT)
+    end
+end
+
+-- 转出检视态
+function main_track_states.inspect.transition(this, context, input)
+    -- 当收到来自 update 的退出信号时返回到闲置态,此时不需要停止动画是因为在 update 里是动画已经停止了才发出的退出信号
+    if (input == this.INPUT_INSPECT_RETREAT) then
+        return this.main_track_states.idle
+    end
+    -- 特殊地,射击应当打断检视,当检测到射击输入时应该直接停止动画并返回闲置态
+    if (input == INPUT_SHOOT) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))
+        return this.main_track_states.idle
+    end
+    return this.main_track_states.idle.transition(this, context, input)
+end
+-- 结束主状态部分
+
+-- 射击态,没什么需要调控的
+local gun_kick_state = {}
+
+function gun_kick_state.transition(this, context, input)
+    -- 玩家按下开火键时需要在射击轨道行里寻找空闲轨道去播放射击动画(如果没有空闲会分配新的),需要注意的是射击动画要向下混合
+    if (input == INPUT_SHOOT) then
+        local track = context:findIdleTrack(GUN_KICK_TRACK_LINE, false)
+        -- 这里是混合动画，一般是可叠加的 gun kick
+        context:runAnimation("shoot", track, true, PLAY_ONCE_STOP, 0)
+    end
+    return nil
+end
+
+-- 移动轨道的状态,这部分到 435 行结束
+local movement_track_states = {
+    -- 静止不动(或者在天上)
+    idle = {},
+    -- 奔跑, -1 是没有奔跑, 0 是在奔跑中
+    run = {
+        mode = -1
+    },
+    -- 行走, -1 是没有行走, 0 是在空中, 1 是正在瞄准, 2 是在向前走, 3 是向后退, 4 是向侧面走
+    walk = {
+        mode = -1
+    }
+}
+
+-- 更新静止态
+function movement_track_states.idle.update(this, context)
+    -- 此处获取的是混合轨道行的移动轨道
+    local track = context:getTrack(BLENDING_TRACK_LINE, MOVEMENT_TRACK)
+    -- 如果轨道空闲，则播放 idle 动画
+    -- 注意此处没有写成是在 entry 播放 idle 动画是因为要实时检测轨道是否空闲
+    if (context:isStopped(track) or context:isHolding(track)) then
+        context:runAnimation("idle", track, true, LOOP, 0)
+    end
+end
+
+-- 转出静止态
+function movement_track_states.idle.transition(this, context, input)
+    -- 如果玩家在奔跑则转去奔跑态
+    if (input == INPUT_RUN) then
+        return this.movement_track_states.run
+    -- 如果玩家在行走则转去行走态
+    elseif (input == INPUT_WALK) then
+        return this.movement_track_states.walk
+    end
+end
+
+-- 进入奔跑态
+function movement_track_states.run.entry(this, context)
+    this.movement_track_states.run.mode = -1
+    -- 此处播放的轨道是混合轨道行的移动轨道,播放的动画是奔跑的起手式,播放结束后是挂起动画而不是停止
+    context:runAnimation("run_start", context:getTrack(BLENDING_TRACK_LINE, MOVEMENT_TRACK), true, PLAY_ONCE_HOLD, 0.2)
+end
+
+-- 退出奔跑态
+function movement_track_states.run.exit(this, context)
+    -- 此时播放的动画是奔跑结束回到 idle 的动画,同理播放完后挂起
+    context:runAnimation("run_end", context:getTrack(BLENDING_TRACK_LINE, MOVEMENT_TRACK), true, PLAY_ONCE_HOLD, 0.3)
+end
+
+-- 更新奔跑态
+function movement_track_states.run.update(this, context)
+    local track = context:getTrack(BLENDING_TRACK_LINE, MOVEMENT_TRACK)
+    local state = this.movement_track_states.run;
+    -- 等待 run_start 结束,然后循环播放 run ,此处的判断准则是轨道是否挂起,也就是为什么 entry 里播放动画要选 PLAY_ONCE_HOLD 模式
+    if (context:isHolding(track)) then
+        context:runAnimation("run", track, true, LOOP, 0.2)
+        -- 检测是否奔跑的标志位 0
+        state.mode = 0
+        context:anchorWalkDist() -- 打 walkDist 锚点，确保 run 动画的起点一致
+    end
+    if (state.mode ~= -1) then
+        if (not context:isOnGround()) then
+            -- 如果玩家在空中，则播放 run_hold 动画以稳定枪身
+            if (state.mode ~= 1) then
+                state.mode = 1
+                context:runAnimation("run_hold", track, true, LOOP, 0.6)
+            end
+        else
+            -- 如果玩家在地面，则切换回 run 动画
+            if (state.mode ~= 0) then
+                state.mode = 0
+                context:runAnimation("run", track, true, LOOP, 0.2)
+            end
+            -- 根据 walkDist 设置 run 动画的进度
+            context:setAnimationProgress(track, (context:getWalkDist() % 2.0) / 2.0, true)
+        end
+    end
+end
+
+-- 转出奔跑态
+function movement_track_states.run.transition(this, context, input)
+    -- 收到闲置输入则转去闲置态
+    if (input == INPUT_IDLE) then
+        return this.movement_track_states.idle
+    -- 收到行走输入则转去行走态
+    elseif (input == INPUT_WALK) then
+        return this.movement_track_states.walk
+    end
+end
+
+-- 进入行走态
+function movement_track_states.walk.entry(this, context)
+    -- 此时给标志位置为 -1 相当于一个初始化
+    this.movement_track_states.walk.mode = -1
+end
+
+-- 退出行走态
+function movement_track_states.walk.exit(this, context)
+    -- 手动播放一次 idle 动画以打断 walk 动画的循环
+    context:runAnimation("idle", context:getTrack(BLENDING_TRACK_LINE, MOVEMENT_TRACK), true, PLAY_ONCE_HOLD, 0.4)
+end
+
+-- 更新行走态
+function movement_track_states.walk.update(this, context)
+    -- 此处获取的是混合轨道行的移动轨道
+    local track = context:getTrack(BLENDING_TRACK_LINE, MOVEMENT_TRACK)
+    -- 这里的 state 代指自身,相当于一个简化写法
+    local state = this.movement_track_states.walk
+    if (context:getShootCoolDown() > 0) then
+        -- 如果刚刚开火，则播放 idle 动画以稳定枪身
+        if (state.mode ~= 0) then
+            state.mode = 0
+            context:runAnimation("idle", track, true, LOOP, 0.3)
+        end
+    elseif (not context:isOnGround()) then
+        -- 如果玩家在空中，则播放 idle 动画以稳定枪身
+        if (state.mode ~= 0) then
+            state.mode = 0
+            context:runAnimation("idle", track, true, LOOP, 0.6)
+        end
+    elseif (context:getAimingProgress() > 0.5) then
+        -- 如果正在喵准，则需要播放 walk_aiming 动画
+        if (state.mode ~= 1) then
+            state.mode = 1
+            context:runAnimation("walk_aiming", track, true, LOOP, 0.3)
+        end
+    elseif (context:isInputUp()) then
+        -- 如果正在向前走，则需要播放 walk_forward 动画
+        if (state.mode ~= 2) then
+            state.mode = 2
+            context:runAnimation("walk_forward", track, true, LOOP, 0.4)
+            context:anchorWalkDist() -- 打 walkDist 锚点，确保行走动画的起点一致
+        end
+    elseif (context:isInputDown()) then
+        -- 如果正在向后退，则需要播放 walk_backward 动画
+        if (state.mode ~= 3) then
+            state.mode = 3
+            context:runAnimation("walk_backward", track, true, LOOP, 0.4)
+            context:anchorWalkDist() -- 打 walkDist 锚点，确保行走动画的起点一致
+        end
+    elseif (context:isInputLeft() or context:isInputRight()) then
+        -- 如果正在向侧面，则需要播放 walk_sideway 动画
+        if (state.mode ~= 4) then
+            state.mode = 4
+            context:runAnimation("walk_sideway", track, true, LOOP, 0.4)
+            context:anchorWalkDist() -- 打 walkDist 锚点，确保行走动画的起点一致
+        end
+    end
+    -- 根据 walkDist 设置行走动画的进度
+    if (state.mode >= 1 and state.mode <= 4) then
+        context:setAnimationProgress(track, (context:getWalkDist() % 2.0) / 2.0, true)
+    end
+end
+
+-- 转出行走态,这部分和转出奔跑态是一样的
+function movement_track_states.walk.transition(this, context, input)
+    -- 收到闲置信号则转到闲置态
+    if (input == INPUT_IDLE) then
+        return this.movement_track_states.idle
+    -- 收到奔跑信号则转到奔跑态
+    elseif (input == INPUT_RUN) then
+        return this.movement_track_states.run
+    end
+end
+-- 结束移动轨道的状态
+
+local M = {
+    -- 轨道行
+    track_line_top = track_line_top,
+    STATIC_TRACK_LINE = STATIC_TRACK_LINE,
+    GUN_KICK_TRACK_LINE = GUN_KICK_TRACK_LINE,
+    BLENDING_TRACK_LINE = BLENDING_TRACK_LINE,
+    -- 静态轨道
+    static_track_top = static_track_top,
+    BASE_TRACK = BASE_TRACK,
+    BOLT_CAUGHT_TRACK = BOLT_CAUGHT_TRACK,
+    SAFETY_TRACK = SAFETY_TRACK,
+    ADS_TRACK = ADS_TRACK,
+    MAIN_TRACK = MAIN_TRACK,
+    -- 混合轨道
+    blending_track_top = blending_track_top,
+    MOVEMENT_TRACK = MOVEMENT_TRACK,
+    LOOP_TRACK = LOOP_TRACK,
+    -- 状态
+    base_track_state = base_track_state,
+    bolt_caught_states = bolt_caught_states,
+    main_track_states = main_track_states,
+    gun_kick_state = gun_kick_state,
+    movement_track_states = movement_track_states,
+    -- 输入
+    INPUT_BOLT_CAUGHT = "bolt_caught",
+    INPUT_BOLT_NORMAL = "bolt_normal",
+    INPUT_INSPECT_RETREAT = "inspect_retreat"
+}
+
+-- 状态机初始化函数，在切枪的时候调用
+function M:initialize(context)
+    context:ensureTrackLineSize(track_line_top.value)
+    context:ensureTracksAmount(STATIC_TRACK_LINE, static_track_top.value)
+    context:ensureTracksAmount(BLENDING_TRACK_LINE, blending_track_top.value)
+    self.movement_track_states.run.mode = -1
+    self.movement_track_states.walk.mode = -1
+end
+
+-- 状态机退出函数，在收枪的时候调用
+function M:exit(context)
+    -- do some cleaning up things
+end
+
+function M:states()
+    return {
+        self.base_track_state,
+        self.bolt_caught_states.normal,
+        self.main_track_states.start,
+        self.gun_kick_state,
+        self.movement_track_states.idle
+    }
+end
+
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/m4a1_sopmod_state_machine.lua

@@ -0,0 +1,273 @@
+-- 脚本的位置是 "{命名空间}:{路径}"，那么 require 的格式为 "{命名空间}_{路径}"
+-- 注意！require 取得的内容不应该被修改，应仅调用
+local default = require("tacz_default_state_machine")
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local MAIN_TRACK = default.MAIN_TRACK
+local main_track_states = default.main_track_states
+local static_track_top = default.static_track_top
+
+local inspect_state = setmetatable({}, {__index = main_track_states.inspect})
+local idle_state = setmetatable({}, {__index = main_track_states.idle})
+
+
+-- 相当于 obj.value++
+local function increment(obj)
+    obj.value = obj.value + 1
+    return obj.value - 1
+end
+
+local FIRE_MODE_TRACK = increment(static_track_top)
+local SWITCH_MODE_TRACK = increment(static_track_top)
+
+-- 检查当前是否还有弹药
+local function isNoAmmo(context)
+    -- 这里同时检查了枪管和弹匣
+    return (not context:hasBulletInBarrel()) and (context:getAmmoCount() <= 0)
+end
+
+local function runReloadAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+    -- 根据当前整枪内是否还有弹药决定是播放战术换弹还是空枪换弹
+    if (isNoAmmo(context)) then
+        -- "ext"表示扩容插件等级,"0"代表不装扩容插件
+        if (ext == 0) then
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_extended_empty_1", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2) then
+            context:runAnimation("reload_extended_empty_2", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 3) then
+            context:runAnimation("reload_extended_empty_3", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_extended_1", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2) then
+            context:runAnimation("reload_extended_2", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 3) then
+            context:runAnimation("reload_extended_3", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+local function runInspectAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+    -- 根据当前整枪内是否还有弹药决定是播放普通检视还是空枪检视
+    if (isNoAmmo(context)) then
+        -- "ext"表示扩容插件等级,"0"代表不装扩容插件
+        if (ext == 0) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect_empty_ext_1", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2) then
+            context:runAnimation("inspect_empty_ext_2", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 3) then
+            context:runAnimation("inspect_empty_ext_3", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect_ext_1", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2) then
+            context:runAnimation("inspect_ext_2", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 3) then
+            context:runAnimation("inspect_ext_3", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+function idle_state.transition(this, context, input)
+    if (input == INPUT_RELOAD) then
+        runReloadAnimation(context)
+        return this.main_track_states.idle
+    end
+    if (input == INPUT_PUT_AWAY) then
+        local put_away_time = context:getPutAwayTime()
+        -- 此处获取的轨道是位于主轨道行上的主轨道
+        local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+        -- 停下切换模式动画
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+        -- 播放 put_away 动画,并且将其过渡时长设为从上下文里传入的 put_away_time * 0.75
+        context:runAnimation("put_away", track, false, PLAY_ONCE_HOLD, put_away_time * 0.75)
+        -- 设定动画进度为最后一帧
+        context:setAnimationProgress(track, 1, true)
+        -- 将动画进度向前拨动 {put_away_time}
+        context:adjustAnimationProgress(track, -put_away_time, false)
+        return this.main_track_states.final
+    end
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        return inspect_state
+    end
+    return main_track_states.idle.transition(this, context, input)
+end
+
+-- 此处为开火模式轨道的状态,专门为快慢机动画服务,兼容其他动作,可按需求添加三种射击模式(semi、burst、auto)
+local fire_mode_state = {
+    -- 半自动状态
+    semi = {},
+    -- 连射状态
+    burst = {},
+    -- 全自动状态
+    auto = {},
+    -- 掏枪状态
+    draw = {}
+}
+-- 这一块专门用来检测枪械在掏枪(播放draw)时枪械处于什么射击模式,并切换到对应模式的idle
+function fire_mode_state.draw.update(this, context)
+    context:trigger(this.INPUT_MODE_DRAW)
+end
+
+function fire_mode_state.draw.transition(this, context,input)
+    if (input == this.INPUT_MODE_DRAW) then
+        if (context:getFireMode() == SEMI) then
+            context:runAnimation("static_semi", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.semi
+        elseif (context:getFireMode() == BURST) then
+            context:runAnimation("static_burst", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.burst
+        elseif (context:getFireMode() == AUTO) then
+            context:runAnimation("static_auto", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.auto
+        end
+    end
+end
+-- 注意!后面关于每个开火模式对应状态之间的切换,需要按照data里填写的顺序进行转换
+function fire_mode_state.semi.update(this, context)
+    -- 当进入特定开火模式的状态时,挂起动画
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_semi", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    -- 为特定开火模式定义输入状态
+    if (context:getFireMode() == AUTO) then
+        context:trigger(this.INPUT_MODE_AUTO)
+    end
+end
+-- 当检测到对应输入状态时播放对应快慢机动画
+function fire_mode_state.semi.transition(this, context,input)
+    if(input == this.INPUT_MODE_AUTO)then
+        context:runAnimation("switch_auto", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.auto
+    end
+-- 检测到开火输入,换弹输入,检视输入时后停止播放动画,不然会出现两个动画在不同的轨道播放,从而出现动画衔接问题
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+-- 和上面同理
+function fire_mode_state.auto.update(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_auto", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    if (context:getFireMode() == BURST) then
+        context:trigger(this.INPUT_MODE_BURST)
+    end
+end
+
+function fire_mode_state.auto.transition(this, context,input)
+    if(input == this.INPUT_MODE_BURST)then
+        context:runAnimation("switch_burst", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.burst
+    end
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT )then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+
+function fire_mode_state.burst.update(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_burst", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    if (context:getFireMode() == SEMI) then
+        context:trigger(this.INPUT_MODE_SEMI)
+    end
+end
+
+function fire_mode_state.burst.transition(this, context,input)
+    if(input == this.INPUT_MODE_SEMI)then
+        context:runAnimation("switch_semi", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.semi
+    end
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT )then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+
+-- 当检测到开火模式切换输入时应该直接停止动画并返回闲置态
+function inspect_state.transition(this, context, input)
+    if (input == INPUT_FIRE_SELECT) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))
+        return this.main_track_states.idle
+    end
+    return main_track_states.inspect.transition(this, context, input)
+end
+
+
+-- 用元表的方式继承默认状态机的属性
+local M = setmetatable({
+    main_track_states = setmetatable({
+        idle = idle_state,
+        inspect = inspect_state
+    }, {__index = main_track_states}),
+    FIRE_MODE_TRACK = FIRE_MODE_TRACK,
+    SWITCH_MODE_TRACK = SWITCH_MODE_TRACK,
+    INPUT_MODE_SEMI = "input_mode_semi",
+    INPUT_MODE_BURST = "input_mode_burst",
+    INPUT_MODE_AUTO = "input_mode_auto",
+    INPUT_MODE_DRAW = "input_mode_draw",
+    fire_mode_state = fire_mode_state
+}, {__index = default})
+function M:initialize(context)
+    default.initialize(self, context)
+end
+-- 继承默认状态机需要重新初始化状态
+function M:states()
+    return {
+        self.base_track_state,
+        self.bolt_caught_states.normal,
+        self.main_track_states.start,
+        self.gun_kick_state,
+        self.movement_track_states.idle,
+        self.ADS_states.normal,
+        self.slide_states.normal,
+        self.fire_mode_state.draw
+    }
+end
+-- 导出状态机
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/mcs_spear_state_machine.lua

@@ -0,0 +1,233 @@
+-- 脚本的位置是 "{命名空间}:{路径}"，那么 require 的格式为 "{命名空间}_{路径}"
+-- 注意！require 取得的内容不应该被修改，应仅调用
+local default = require("tacz_default_state_machine")
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local MAIN_TRACK = default.MAIN_TRACK
+local main_track_states = default.main_track_states
+local static_track_top = default.static_track_top
+
+local inspect_state = setmetatable({}, {__index = main_track_states.inspect})
+local idle_state = setmetatable({}, {__index = main_track_states.idle})
+
+
+-- 相当于 obj.value++
+local function increment(obj)
+    obj.value = obj.value + 1
+    return obj.value - 1
+end
+
+local FIRE_MODE_TRACK = increment(static_track_top)
+local SWITCH_MODE_TRACK = increment(static_track_top)
+
+-- 检查当前是否还有弹药
+local function isNoAmmo(context)
+    -- 这里同时检查了枪管和弹匣
+    return (not context:hasBulletInBarrel()) and (context:getAmmoCount() <= 0)
+end
+
+local function runReloadAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+    -- 根据当前整枪内是否还有弹药决定是播放战术换弹还是空枪换弹
+    if (isNoAmmo(context)) then
+        -- "ext"表示扩容插件等级,"0"代表不装扩容插件
+        if (ext == 0) then
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_empty_ext_1", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("reload_empty_ext_2", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_ext_1", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("reload_ext_2", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+local function runInspectAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+    -- 根据当前整枪内是否还有弹药决定是播放普通检视还是空枪检视
+    if (isNoAmmo(context)) then
+        -- "ext"表示扩容插件等级,"0"代表不装扩容插件
+        if (ext == 0) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+function idle_state.transition(this, context, input)
+    if (input == INPUT_RELOAD) then
+        runReloadAnimation(context)
+        return this.main_track_states.idle
+    end
+    if (input == INPUT_PUT_AWAY) then
+        local put_away_time = context:getPutAwayTime()
+        -- 此处获取的轨道是位于主轨道行上的主轨道
+        local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+        -- 停下切换模式动画
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+        -- 播放 put_away 动画,并且将其过渡时长设为从上下文里传入的 put_away_time * 0.75
+        context:runAnimation("put_away", track, false, PLAY_ONCE_HOLD, put_away_time * 0.75)
+        -- 设定动画进度为最后一帧
+        context:setAnimationProgress(track, 1, true)
+        -- 将动画进度向前拨动 {put_away_time}
+        context:adjustAnimationProgress(track, -put_away_time, false)
+        return this.main_track_states.final
+    end
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        return inspect_state
+    end
+    return main_track_states.idle.transition(this, context, input)
+end
+
+-- 此处为开火模式轨道的状态,专门为快慢机动画服务,兼容其他动作,可按需求添加三种射击模式(semi、burst、auto)
+local fire_mode_state = {
+    -- 半自动状态
+    semi = {},
+    -- 全自动状态
+    auto = {},
+    -- 掏枪状态
+    draw = {}
+}
+-- 这一块专门用来检测枪械在掏枪(播放draw)时枪械处于什么射击模式,并切换到对应模式的idle
+function fire_mode_state.draw.update(this, context)
+    context:trigger(this.INPUT_MODE_DRAW)
+end
+
+function fire_mode_state.draw.transition(this, context,input)
+    if (input == this.INPUT_MODE_DRAW) then
+        if (context:getFireMode() == SEMI) then
+            context:runAnimation("static_semi", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.semi
+        elseif (context:getFireMode() == AUTO) then
+            context:runAnimation("static_auto", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.auto
+        end
+    end
+end
+-- 注意!后面关于每个开火模式对应状态之间的切换,需要按照data里填写的顺序进行转换
+function fire_mode_state.semi.update(this, context)
+    -- 当进入特定开火模式的状态时,挂起动画
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_semi", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    -- 为特定开火模式定义输入状态
+    if (context:getFireMode() == AUTO) then
+        context:trigger(this.INPUT_MODE_AUTO)
+    end
+end
+-- 当检测到对应输入状态时播放对应快慢机动画
+function fire_mode_state.semi.transition(this, context,input)
+    if(input == this.INPUT_MODE_AUTO)then
+        context:runAnimation("switch_auto", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.auto
+    end
+-- 检测到开火输入,换弹输入,检视输入时后停止播放动画,不然会出现两个动画在不同的轨道播放,从而出现动画衔接问题
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+-- 和上面同理
+function fire_mode_state.auto.update(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_auto", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    if (context:getFireMode() == SEMI) then
+        context:trigger(this.INPUT_MODE_SEMI)
+    end
+end
+
+function fire_mode_state.auto.transition(this, context,input)
+    if(input == this.INPUT_MODE_SEMI)then
+        context:runAnimation("switch_semi", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.semi
+    end
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT )then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+
+-- 当检测到开火模式切换输入时应该直接停止动画并返回闲置态
+function inspect_state.transition(this, context, input)
+    if (input == INPUT_FIRE_SELECT) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))
+        return this.main_track_states.idle
+    end
+    return main_track_states.inspect.transition(this, context, input)
+end
+
+
+-- 用元表的方式继承默认状态机的属性
+local M = setmetatable({
+    main_track_states = setmetatable({
+        idle = idle_state,
+        inspect = inspect_state
+    }, {__index = main_track_states}),
+    FIRE_MODE_TRACK = FIRE_MODE_TRACK,
+    SWITCH_MODE_TRACK = SWITCH_MODE_TRACK,
+    INPUT_MODE_SEMI = "input_mode_semi",
+    INPUT_MODE_AUTO = "input_mode_auto",
+    INPUT_MODE_DRAW = "input_mode_draw",
+    fire_mode_state = fire_mode_state
+}, {__index = default})
+function M:initialize(context)
+    default.initialize(self, context)
+end
+-- 继承默认状态机需要重新初始化状态
+function M:states()
+    return {
+        self.base_track_state,
+        self.bolt_caught_states.normal,
+        self.main_track_states.start,
+        self.gun_kick_state,
+        self.movement_track_states.idle,
+        self.ADS_states.normal,
+        self.slide_states.normal,
+        self.fire_mode_state.draw
+    }
+end
+-- 导出状态机
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/mp5_classic_state_machine.lua

@@ -0,0 +1,273 @@
+-- 脚本的位置是 "{命名空间}:{路径}"，那么 require 的格式为 "{命名空间}_{路径}"
+-- 注意！require 取得的内容不应该被修改，应仅调用
+local default = require("tacz_default_state_machine")
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local MAIN_TRACK = default.MAIN_TRACK
+local main_track_states = default.main_track_states
+local static_track_top = default.static_track_top
+
+local inspect_state = setmetatable({}, {__index = main_track_states.inspect})
+local idle_state = setmetatable({}, {__index = main_track_states.idle})
+
+
+-- 相当于 obj.value++
+local function increment(obj)
+    obj.value = obj.value + 1
+    return obj.value - 1
+end
+
+local FIRE_MODE_TRACK = increment(static_track_top)
+local SWITCH_MODE_TRACK = increment(static_track_top)
+
+-- 检查当前是否还有弹药
+local function isNoAmmo(context)
+    -- 这里同时检查了枪管和弹匣
+    return (not context:hasBulletInBarrel()) and (context:getAmmoCount() <= 0)
+end
+
+local function runReloadAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+    -- 根据当前整枪内是否还有弹药决定是播放战术换弹还是空枪换弹
+    if (isNoAmmo(context)) then
+        -- "ext"表示扩容插件等级,"0"代表不装扩容插件
+        if (ext == 0) then
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_extended_mag_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2) then
+            context:runAnimation("reload_extended_mag_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 3) then
+            context:runAnimation("reload_extended_mag_2_empty", track, false, PLAY_ONCE_STOP, 0.2)
+
+        else
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_extended_mag", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2) then
+           context:runAnimation("reload_extended_mag", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 3) then
+           context:runAnimation("reload_extended_mag_2_normal", track, false, PLAY_ONCE_STOP, 0.2)
+
+
+        else
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+local function runInspectAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+    -- 根据当前整枪内是否还有弹药决定是播放普通检视还是空枪检视
+    if (isNoAmmo(context)) then
+        -- "ext"表示扩容插件等级,"0"代表不装扩容插件
+        if (ext == 0) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+function idle_state.transition(this, context, input)
+    if (input == INPUT_RELOAD) then
+        runReloadAnimation(context)
+        return this.main_track_states.idle
+    end
+    if (input == INPUT_PUT_AWAY) then
+        local put_away_time = context:getPutAwayTime()
+        -- 此处获取的轨道是位于主轨道行上的主轨道
+        local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+        -- 停下切换模式动画
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+        -- 播放 put_away 动画,并且将其过渡时长设为从上下文里传入的 put_away_time * 0.75
+        context:runAnimation("put_away", track, false, PLAY_ONCE_HOLD, put_away_time * 0.75)
+        -- 设定动画进度为最后一帧
+        context:setAnimationProgress(track, 1, true)
+        -- 将动画进度向前拨动 {put_away_time}
+        context:adjustAnimationProgress(track, -put_away_time, false)
+        return this.main_track_states.final
+    end
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        return inspect_state
+    end
+    return main_track_states.idle.transition(this, context, input)
+end
+
+-- 此处为开火模式轨道的状态,专门为快慢机动画服务,兼容其他动作,可按需求添加三种射击模式(semi、burst、auto)
+local fire_mode_state = {
+    -- 半自动状态
+    semi = {},
+    -- 连射状态
+    burst = {},
+    -- 全自动状态
+    auto = {},
+    -- 掏枪状态
+    draw = {}
+}
+-- 这一块专门用来检测枪械在掏枪(播放draw)时枪械处于什么射击模式,并切换到对应模式的idle
+function fire_mode_state.draw.update(this, context)
+    context:trigger(this.INPUT_MODE_DRAW)
+end
+
+function fire_mode_state.draw.transition(this, context,input)
+    if (input == this.INPUT_MODE_DRAW) then
+        if (context:getFireMode() == SEMI) then
+            context:runAnimation("static_semi", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.semi
+        elseif (context:getFireMode() == BURST) then
+            context:runAnimation("static_burst", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.burst
+        elseif (context:getFireMode() == AUTO) then
+            context:runAnimation("static_auto", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.auto
+        end
+    end
+end
+-- 注意!后面关于每个开火模式对应状态之间的切换,需要按照data里填写的顺序进行转换
+function fire_mode_state.semi.update(this, context)
+    -- 当进入特定开火模式的状态时,挂起动画
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_semi", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    -- 为特定开火模式定义输入状态
+    if (context:getFireMode() == AUTO) then
+        context:trigger(this.INPUT_MODE_AUTO)
+    end
+end
+-- 当检测到对应输入状态时播放对应快慢机动画
+function fire_mode_state.semi.transition(this, context,input)
+    if(input == this.INPUT_MODE_AUTO)then
+        context:runAnimation("switch_auto", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.auto
+    end
+-- 检测到开火输入,换弹输入,检视输入时后停止播放动画,不然会出现两个动画在不同的轨道播放,从而出现动画衔接问题
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+-- 和上面同理
+function fire_mode_state.burst.update(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_burst", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    if (context:getFireMode() == SEMI) then
+        context:trigger(this.INPUT_MODE_SEMI)
+    end
+end
+
+function fire_mode_state.burst.transition(this, context,input)
+    if(input == this.INPUT_MODE_SEMI)then
+        context:runAnimation("switch_semi", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.semi
+    end
+
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+
+function fire_mode_state.auto.update(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_auto", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    if (context:getFireMode() == BURST) then
+        context:trigger(this.INPUT_MODE_BURST)
+    end
+end
+
+function fire_mode_state.auto.transition(this, context,input)
+    if(input == this.INPUT_MODE_BURST)then
+        context:runAnimation("switch_burst", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.burst
+    end
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT )then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+
+-- 当检测到开火模式切换输入时应该直接停止动画并返回闲置态
+function inspect_state.transition(this, context, input)
+    if (input == INPUT_FIRE_SELECT) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))
+        return main_track_states.idle
+    end
+    return main_track_states.inspect.transition(this, context, input)
+end
+
+
+-- 用元表的方式继承默认状态机的属性
+local M = setmetatable({
+    main_track_states = setmetatable({
+        idle = idle_state,
+        inspect = inspect_state
+    }, {__index = main_track_states}),
+    FIRE_MODE_TRACK = FIRE_MODE_TRACK,
+    SWITCH_MODE_TRACK = SWITCH_MODE_TRACK,
+    INPUT_MODE_SEMI = "input_mode_semi",
+    INPUT_MODE_BURST = "input_mode_burst",
+    INPUT_MODE_AUTO = "input_mode_auto",
+    INPUT_MODE_DRAW = "input_mode_draw",
+    fire_mode_state = fire_mode_state
+}, {__index = default})
+function M:initialize(context)
+    default.initialize(self, context)
+end
+-- 继承默认状态机需要重新初始化状态
+function M:states()
+    return {
+        self.base_track_state,
+        self.bolt_caught_states.normal,
+        self.main_track_states.start,
+        self.gun_kick_state,
+        self.movement_track_states.idle,
+        self.ADS_states.normal,
+        self.slide_states.normal,
+        self.fire_mode_state.draw
+    }
+end
+-- 导出状态机
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/mp7_state_machine.lua

@@ -0,0 +1,233 @@
+-- 脚本的位置是 "{命名空间}:{路径}"，那么 require 的格式为 "{命名空间}_{路径}"
+-- 注意！require 取得的内容不应该被修改，应仅调用
+local default = require("tacz_default_state_machine")
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local MAIN_TRACK = default.MAIN_TRACK
+local main_track_states = default.main_track_states
+local static_track_top = default.static_track_top
+
+local inspect_state = setmetatable({}, {__index = main_track_states.inspect})
+local idle_state = setmetatable({}, {__index = main_track_states.idle})
+
+
+-- 相当于 obj.value++
+local function increment(obj)
+    obj.value = obj.value + 1
+    return obj.value - 1
+end
+
+local FIRE_MODE_TRACK = increment(static_track_top)
+local SWITCH_MODE_TRACK = increment(static_track_top)
+
+-- 检查当前是否还有弹药
+local function isNoAmmo(context)
+    -- 这里同时检查了枪管和弹匣
+    return (not context:hasBulletInBarrel()) and (context:getAmmoCount() <= 0)
+end
+
+local function runReloadAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+    -- 根据当前整枪内是否还有弹药决定是播放战术换弹还是空枪换弹
+    if (isNoAmmo(context)) then
+        -- "ext"表示扩容插件等级,"0"代表不装扩容插件
+        if (ext == 0) then
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_extended_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("reload_extended_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_extended", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("reload_extended", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+local function runInspectAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+    -- 根据当前整枪内是否还有弹药决定是播放普通检视还是空枪检视
+    if (isNoAmmo(context)) then
+        -- "ext"表示扩容插件等级,"0"代表不装扩容插件
+        if (ext == 0) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect_empty_ext", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect_empty_ext", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect_ext", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect_ext", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+function idle_state.transition(this, context, input)
+    if (input == INPUT_RELOAD) then
+        runReloadAnimation(context)
+        return this.main_track_states.idle
+    end
+    if (input == INPUT_PUT_AWAY) then
+        local put_away_time = context:getPutAwayTime()
+        -- 此处获取的轨道是位于主轨道行上的主轨道
+        local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+        -- 停下切换模式动画
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+        -- 播放 put_away 动画,并且将其过渡时长设为从上下文里传入的 put_away_time * 0.75
+        context:runAnimation("put_away", track, false, PLAY_ONCE_HOLD, put_away_time * 0.75)
+        -- 设定动画进度为最后一帧
+        context:setAnimationProgress(track, 1, true)
+        -- 将动画进度向前拨动 {put_away_time}
+        context:adjustAnimationProgress(track, -put_away_time, false)
+        return this.main_track_states.final
+    end
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        return inspect_state
+    end
+    return main_track_states.idle.transition(this, context, input)
+end
+
+-- 此处为开火模式轨道的状态,专门为快慢机动画服务,兼容其他动作,可按需求添加三种射击模式(semi、burst、auto)
+local fire_mode_state = {
+    -- 半自动状态
+    semi = {},
+    -- 全自动状态
+    auto = {},
+    -- 掏枪状态
+    draw = {}
+}
+-- 这一块专门用来检测枪械在掏枪(播放draw)时枪械处于什么射击模式,并切换到对应模式的idle
+function fire_mode_state.draw.update(this, context)
+    context:trigger(this.INPUT_MODE_DRAW)
+end
+
+function fire_mode_state.draw.transition(this, context,input)
+    if (input == this.INPUT_MODE_DRAW) then
+        if (context:getFireMode() == SEMI) then
+            context:runAnimation("static_semi", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.semi
+        elseif (context:getFireMode() == AUTO) then
+            context:runAnimation("static_auto", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.auto
+        end
+    end
+end
+-- 注意!后面关于每个开火模式对应状态之间的切换,需要按照data里填写的顺序进行转换
+function fire_mode_state.semi.update(this, context)
+    -- 当进入特定开火模式的状态时,挂起动画
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_semi", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    -- 为特定开火模式定义输入状态
+    if (context:getFireMode() == AUTO) then
+        context:trigger(this.INPUT_MODE_AUTO)
+    end
+end
+-- 当检测到对应输入状态时播放对应快慢机动画
+function fire_mode_state.semi.transition(this, context,input)
+    if(input == this.INPUT_MODE_AUTO)then
+        context:runAnimation("switch_auto", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.auto
+    end
+-- 检测到开火输入,换弹输入,检视输入时后停止播放动画,不然会出现两个动画在不同的轨道播放,从而出现动画衔接问题
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+-- 和上面同理
+function fire_mode_state.auto.update(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_auto", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    if (context:getFireMode() == SEMI) then
+        context:trigger(this.INPUT_MODE_SEMI)
+    end
+end
+
+function fire_mode_state.auto.transition(this, context,input)
+    if(input == this.INPUT_MODE_SEMI)then
+        context:runAnimation("switch_semi", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.semi
+    end
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT )then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+
+-- 当检测到开火模式切换输入时应该直接停止动画并返回闲置态
+function inspect_state.transition(this, context, input)
+    if (input == INPUT_FIRE_SELECT) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))
+        return this.main_track_states.idle
+    end
+    return main_track_states.inspect.transition(this, context, input)
+end
+
+
+-- 用元表的方式继承默认状态机的属性
+local M = setmetatable({
+    main_track_states = setmetatable({
+        idle = idle_state,
+        inspect = inspect_state
+    }, {__index = main_track_states}),
+    FIRE_MODE_TRACK = FIRE_MODE_TRACK,
+    SWITCH_MODE_TRACK = SWITCH_MODE_TRACK,
+    INPUT_MODE_SEMI = "input_mode_semi",
+    INPUT_MODE_AUTO = "input_mode_auto",
+    INPUT_MODE_DRAW = "input_mode_draw",
+    fire_mode_state = fire_mode_state
+}, {__index = default})
+function M:initialize(context)
+    default.initialize(self, context)
+end
+-- 继承默认状态机需要重新初始化状态
+function M:states()
+    return {
+        self.base_track_state,
+        self.bolt_caught_states.normal,
+        self.main_track_states.start,
+        self.gun_kick_state,
+        self.movement_track_states.idle,
+        self.ADS_states.normal,
+        self.slide_states.normal,
+        self.fire_mode_state.draw
+    }
+end
+-- 导出状态机
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/pump_action_state_machine.lua

@@ -0,0 +1,111 @@
+-- 脚本的位置是 "{命名空间}:{路径}"，那么 require 的格式为 "{命名空间}_{路径}"
+-- 注意！require 取得的内容不应该被修改，应仅调用
+local default = require("tacz_manual_action_state_machine")
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local MAIN_TRACK = default.MAIN_TRACK
+local main_track_states = default.main_track_states
+-- main_track_states.idle 是我们要重写的状态。
+local idle_state = setmetatable({}, {__index = main_track_states.idle})
+-- reload_state、bolt_state 是定义的新状态，用于执行单发装填
+local reload_state = {
+    need_ammo = 0,
+    loaded_ammo = 0
+}
+local function get_ejection_time(context)
+    local ejection_time = context:getStateMachineParams().intro_shell_ejecting_time
+    if (ejection_time) then
+        ejection_time = ejection_time * 1000
+    else
+        ejection_time = 0
+    end
+    return ejection_time
+end
+
+local function runInspectAnimation(context)
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    if (not context:hasBulletInBarrel() and context:getAmmoCount() <= 0) then
+
+        context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+    elseif (context:getAmmoCount() <= 0) then
+        context:runAnimation("inspect_01", track, false, PLAY_ONCE_STOP, 0.2)
+    else
+        context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+    end
+end
+
+-- 重写 idle 状态的 transition 函数，将输入 INPUT_RELOAD 重定向到新定义的 reload_state 状态
+function idle_state.transition(this, context, input)
+    if (input == INPUT_RELOAD) then
+        return this.main_track_states.reload
+    end
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        return this.main_track_states.inspect
+    end
+    return main_track_states.idle.transition(this, context, input)
+end
+-- 在 entry 函数里，我们根据情况选择播放 'reload_intro_empty' 或 'reload_intro' 动画，
+-- 并初始化 需要的弹药数、已装填的弹药数。这决定了后续的 'loop' 动画进行几次循环。
+function reload_state.entry(this, context)
+    local state = this.main_track_states.reload
+    local isNoAmmo = not context:hasBulletInBarrel()
+    if (isNoAmmo) then
+        -- 记录开始换弹的时间戳，用于抛出 reload_intro_empty 中的弹壳
+        state.timestamp = context:getCurrentTimestamp()
+        state.ejection_time = get_ejection_time(context)
+        context:runAnimation("reload_intro_empty", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_HOLD, 0.2)
+    else
+        state.timestamp = -1
+        state.ejection_time = 0
+        context:runAnimation("reload_intro", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_HOLD, 0.2)
+    end
+    state.need_ammo = context:getMaxAmmoCount() - context:getAmmoCount()
+    state.loaded_ammo = 0
+end
+
+-- 在 update 函数里，循环播放 loop，让 loaded_ammo 变量自增。
+function reload_state.update(this, context)
+    local state = this.main_track_states.reload
+    -- 处理 reload_intro_empty 的抛壳
+    if (state.timestamp ~= -1 and context:getCurrentTimestamp() - state.timestamp > state.ejection_time) then
+        context:popShellFrom(0)
+        state.timestamp = -1
+    end
+    if (state.loaded_ammo > state.need_ammo or not context:hasAmmoToConsume()) then
+        context:trigger(this.INPUT_RELOAD_RETREAT)
+    else
+        local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+        if (context:isHolding(track)) then
+            context:runAnimation("reload_loop", track, false, PLAY_ONCE_HOLD, 0)
+            state.loaded_ammo = state.loaded_ammo + 1
+        end
+    end
+end
+
+
+
+-- 如果 loop 循环结束或者换弹被打断，退出到 idle 状态。否则由 idle 的 transition 函数决定下一个状态。
+function reload_state.transition(this, context, input)
+    if (input == this.INPUT_RELOAD_RETREAT or input == INPUT_CANCEL_RELOAD) then
+        context:runAnimation("reload_end", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        return this.main_track_states.idle
+    end
+    return this.main_track_states.idle.transition(this, context, input)
+end
+-- 用元表的方式继承默认状态机的属性
+local M = setmetatable({
+    main_track_states = setmetatable({
+        -- 自定义的 idle 状态需要覆盖掉父级状态机的对应状态，新建的 reload 状态也要加进来
+        idle = idle_state,
+        reload = reload_state
+    }, {__index = main_track_states}),
+    INPUT_RELOAD_RETREAT = "reload_retreat",
+}, {__index = default})
+-- 先调用父级状态机的初始化函数，然后进行自己的初始化
+function M:initialize(context)
+    default.initialize(self, context)
+    self.main_track_states.reload.need_ammo = 0
+    self.main_track_states.reload.loaded_ammo = 0
+end
+-- 导出状态机
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/revolver_state_machine.lua

@@ -0,0 +1,271 @@
+-- 脚本的位置是 "{命名空间}:{路径}"，那么 require 的格式为 "{命名空间}_{路径}"
+-- 注意！require 取得的内容不应该被修改，应仅调用
+local default = require("tacz_default_state_machine")
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local MAIN_TRACK = default.MAIN_TRACK
+local main_track_states = default.main_track_states
+local static_track_top = default.static_track_top
+
+local inspect_state = setmetatable({}, {__index = main_track_states.inspect})
+local idle_state = setmetatable({}, {__index = main_track_states.idle})
+
+
+-- 相当于 obj.value++
+local function increment(obj)
+    obj.value = obj.value + 1
+    return obj.value - 1
+end
+
+local FIRE_MODE_TRACK = increment(static_track_top)
+local SWITCH_MODE_TRACK = increment(static_track_top)
+
+-- 检查当前是否还有弹药
+local function isNoAmmo(context)
+    -- 这里同时检查了枪管和弹匣
+    return (not context:hasBulletInBarrel()) and (context:getAmmoCount() <= 0)
+end
+
+local function runReloadAnimation(context)
+
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+
+    if (isNoAmmo(context)) then
+
+        if (ext == 0) then
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_extended_empty_1", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2) then
+            context:runAnimation("reload_extended_empty_2", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 3) then
+            context:runAnimation("reload_extended_empty_3", track, false, PLAY_ONCE_STOP, 0.2)
+
+        else
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_extended_1", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2) then
+            context:runAnimation("reload_extended_2", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 3) then
+            context:runAnimation("reload_extended_3", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+local function runInspectAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+    -- 根据当前整枪内是否还有弹药决定是播放普通检视还是空枪检视
+    if (isNoAmmo(context)) then
+        -- "ext"表示扩容插件等级,"0"代表不装扩容插件
+        if (ext == 0) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+function idle_state.transition(this, context, input)
+    if (input == INPUT_RELOAD) then
+        runReloadAnimation(context)
+        return this.main_track_states.idle
+    end
+    if (input == INPUT_PUT_AWAY) then
+        local put_away_time = context:getPutAwayTime()
+        -- 此处获取的轨道是位于主轨道行上的主轨道
+        local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+        -- 停下切换模式动画
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+        -- 播放 put_away 动画,并且将其过渡时长设为从上下文里传入的 put_away_time * 0.75
+        context:runAnimation("put_away", track, false, PLAY_ONCE_HOLD, put_away_time * 0.75)
+        -- 设定动画进度为最后一帧
+        context:setAnimationProgress(track, 1, true)
+        -- 将动画进度向前拨动 {put_away_time}
+        context:adjustAnimationProgress(track, -put_away_time, false)
+        return this.main_track_states.final
+    end
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        return inspect_state
+    end
+    return main_track_states.idle.transition(this, context, input)
+end
+
+-- 此处为开火模式轨道的状态,专门为快慢机动画服务,兼容其他动作,可按需求添加三种射击模式(semi、burst、auto)
+local fire_mode_state = {
+    -- 半自动状态
+    semi = {},
+    -- 连射状态
+    burst = {},
+    -- 全自动状态
+    auto = {},
+    -- 掏枪状态
+    draw = {}
+}
+-- 这一块专门用来检测枪械在掏枪(播放draw)时枪械处于什么射击模式,并切换到对应模式的idle
+function fire_mode_state.draw.update(this, context)
+    context:trigger(this.INPUT_MODE_DRAW)
+end
+
+function fire_mode_state.draw.transition(this, context,input)
+    if (input == this.INPUT_MODE_DRAW) then
+        if (context:getFireMode() == SEMI) then
+            context:runAnimation("static_semi", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.semi
+        elseif (context:getFireMode() == BURST) then
+            context:runAnimation("static_burst", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.burst
+        elseif (context:getFireMode() == AUTO) then
+            context:runAnimation("static_auto", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.auto
+        end
+    end
+end
+-- 注意!后面关于每个开火模式对应状态之间的切换,需要按照data里填写的顺序进行转换
+function fire_mode_state.semi.update(this, context)
+    -- 当进入特定开火模式的状态时,挂起动画
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_semi", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    -- 为特定开火模式定义输入状态
+    if (context:getFireMode() == AUTO) then
+        context:trigger(this.INPUT_MODE_AUTO)
+    end
+end
+-- 当检测到对应输入状态时播放对应快慢机动画
+function fire_mode_state.semi.transition(this, context,input)
+    if(input == this.INPUT_MODE_AUTO)then
+        context:runAnimation("switch_auto", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.auto
+    end
+    -- 检测到开火输入,换弹输入,检视输入时后停止播放动画,不然会出现两个动画在不同的轨道播放,从而出现动画衔接问题
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+-- 和上面同理
+function fire_mode_state.burst.update(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_burst", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    if (context:getFireMode() == SEMI) then
+        context:trigger(this.INPUT_MODE_SEMI)
+    end
+end
+
+function fire_mode_state.burst.transition(this, context,input)
+    if(input == this.INPUT_MODE_SEMI)then
+        context:runAnimation("switch_semi", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.semi
+    end
+
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+
+function fire_mode_state.auto.update(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_auto", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    if (context:getFireMode() == BURST) then
+        context:trigger(this.INPUT_MODE_BURST)
+    end
+end
+
+function fire_mode_state.auto.transition(this, context,input)
+    if(input == this.INPUT_MODE_BURST)then
+        context:runAnimation("switch_burst", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.burst
+    end
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT )then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+
+-- 当检测到开火模式切换输入时应该直接停止动画并返回闲置态
+function inspect_state.transition(this, context, input)
+    if (input == INPUT_FIRE_SELECT) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))
+        return main_track_states.idle
+    end
+    return main_track_states.inspect.transition(this, context, input)
+end
+
+
+-- 用元表的方式继承默认状态机的属性
+local M = setmetatable({
+    main_track_states = setmetatable({
+        idle = idle_state,
+        inspect = inspect_state
+    }, {__index = main_track_states}),
+    FIRE_MODE_TRACK = FIRE_MODE_TRACK,
+    SWITCH_MODE_TRACK = SWITCH_MODE_TRACK,
+    INPUT_MODE_SEMI = "input_mode_semi",
+    INPUT_MODE_BURST = "input_mode_burst",
+    INPUT_MODE_AUTO = "input_mode_auto",
+    INPUT_MODE_DRAW = "input_mode_draw",
+    fire_mode_state = fire_mode_state
+}, {__index = default})
+function M:initialize(context)
+    default.initialize(self, context)
+end
+-- 继承默认状态机需要重新初始化状态
+function M:states()
+    return {
+        self.base_track_state,
+        self.bolt_caught_states.normal,
+        self.main_track_states.start,
+        self.gun_kick_state,
+        self.movement_track_states.idle,
+        self.ADS_states.normal,
+        self.slide_states.normal,
+        self.fire_mode_state.draw
+    }
+end
+-- 导出状态机
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/scar_state_machine.lua

@@ -0,0 +1,271 @@
+-- 脚本的位置是 "{命名空间}:{路径}"，那么 require 的格式为 "{命名空间}_{路径}"
+-- 注意！require 取得的内容不应该被修改，应仅调用
+local default = require("tacz_default_state_machine")
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local MAIN_TRACK = default.MAIN_TRACK
+local main_track_states = default.main_track_states
+local static_track_top = default.static_track_top
+
+local inspect_state = setmetatable({}, {__index = main_track_states.inspect})
+local idle_state = setmetatable({}, {__index = main_track_states.idle})
+
+
+-- 相当于 obj.value++
+local function increment(obj)
+    obj.value = obj.value + 1
+    return obj.value - 1
+end
+
+local FIRE_MODE_TRACK = increment(static_track_top)
+local SWITCH_MODE_TRACK = increment(static_track_top)
+
+-- 检查当前是否还有弹药
+local function isNoAmmo(context)
+    -- 这里同时检查了枪管和弹匣
+    return (not context:hasBulletInBarrel()) and (context:getAmmoCount() <= 0)
+end
+
+local function runReloadAnimation(context)
+
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+
+    if (isNoAmmo(context)) then
+
+        if (ext == 0) then
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_extended_empty_1", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2) then
+            context:runAnimation("reload_extended_empty_2", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 3) then
+            context:runAnimation("reload_extended_empty_3", track, false, PLAY_ONCE_STOP, 0.2)
+
+        else
+            context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("reload_extended_1", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2) then
+           context:runAnimation("reload_extended_2", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 3) then
+           context:runAnimation("reload_extended_3", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("reload_tactical", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+local function runInspectAnimation(context)
+    -- 此处获取的轨道是位于主轨道行上的主轨道
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    local ext = context:getMagExtentLevel()
+    -- 根据当前整枪内是否还有弹药决定是播放普通检视还是空枪检视
+    if (isNoAmmo(context)) then
+        -- "ext"表示扩容插件等级,"0"代表不装扩容插件
+        if (ext == 0) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    else
+        if (ext == 0) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 1) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        elseif (ext == 2 or ext == 3) then
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        else
+            context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+        end
+    end
+end
+
+function idle_state.transition(this, context, input)
+    if (input == INPUT_RELOAD) then
+        runReloadAnimation(context)
+        return this.main_track_states.idle
+    end
+    if (input == INPUT_PUT_AWAY) then
+        local put_away_time = context:getPutAwayTime()
+        -- 此处获取的轨道是位于主轨道行上的主轨道
+        local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+        -- 停下切换模式动画
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+        -- 播放 put_away 动画,并且将其过渡时长设为从上下文里传入的 put_away_time * 0.75
+        context:runAnimation("put_away", track, false, PLAY_ONCE_HOLD, put_away_time * 0.75)
+        -- 设定动画进度为最后一帧
+        context:setAnimationProgress(track, 1, true)
+        -- 将动画进度向前拨动 {put_away_time}
+        context:adjustAnimationProgress(track, -put_away_time, false)
+        return this.main_track_states.final
+    end
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        return inspect_state
+    end
+    return main_track_states.idle.transition(this, context, input)
+end
+
+-- 此处为开火模式轨道的状态,专门为快慢机动画服务,兼容其他动作,可按需求添加三种射击模式(semi、burst、auto)
+local fire_mode_state = {
+    -- 半自动状态
+    semi = {},
+    -- 连射状态
+    burst = {},
+    -- 全自动状态
+    auto = {},
+    -- 掏枪状态
+    draw = {}
+}
+-- 这一块专门用来检测枪械在掏枪(播放draw)时枪械处于什么射击模式,并切换到对应模式的idle
+function fire_mode_state.draw.update(this, context)
+    context:trigger(this.INPUT_MODE_DRAW)
+end
+
+function fire_mode_state.draw.transition(this, context,input)
+    if (input == this.INPUT_MODE_DRAW) then
+        if (context:getFireMode() == SEMI) then
+            context:runAnimation("static_semi", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.semi
+        elseif (context:getFireMode() == BURST) then
+            context:runAnimation("static_burst", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.burst
+        elseif (context:getFireMode() == AUTO) then
+            context:runAnimation("static_auto", context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK), true, PLAY_ONCE_HOLD, 0)
+            return fire_mode_state.auto
+        end
+    end
+end
+-- 注意!后面关于每个开火模式对应状态之间的切换,需要按照data里填写的顺序进行转换
+function fire_mode_state.semi.update(this, context)
+    -- 当进入特定开火模式的状态时,挂起动画
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_semi", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    -- 为特定开火模式定义输入状态
+    if (context:getFireMode() == AUTO) then
+        context:trigger(this.INPUT_MODE_AUTO)
+    end
+end
+-- 当检测到对应输入状态时播放对应快慢机动画
+function fire_mode_state.semi.transition(this, context,input)
+    if(input == this.INPUT_MODE_AUTO)then
+        context:runAnimation("switch_auto", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.auto
+    end
+-- 检测到开火输入,换弹输入,检视输入时后停止播放动画,不然会出现两个动画在不同的轨道播放,从而出现动画衔接问题
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+-- 和上面同理
+function fire_mode_state.burst.update(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_burst", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    if (context:getFireMode() == SEMI) then
+        context:trigger(this.INPUT_MODE_SEMI)
+    end
+end
+
+function fire_mode_state.burst.transition(this, context,input)
+    if(input == this.INPUT_MODE_SEMI)then
+        context:runAnimation("switch_semi", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.semi
+    end
+
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+
+function fire_mode_state.auto.update(this, context)
+    local track = context:getTrack(STATIC_TRACK_LINE, FIRE_MODE_TRACK)
+    if (context:isHolding(track)) then
+        context:runAnimation("static_auto", track, true, PLAY_ONCE_HOLD, 0)
+    end
+    if (context:getFireMode() == BURST) then
+        context:trigger(this.INPUT_MODE_BURST)
+    end
+end
+
+function fire_mode_state.auto.transition(this, context,input)
+    if(input == this.INPUT_MODE_BURST)then
+        context:runAnimation("switch_burst", context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK), false, PLAY_ONCE_STOP, 0)
+        return fire_mode_state.burst
+    end
+    if(input == INPUT_SHOOT)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_RELOAD)then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+    if(input == INPUT_INSPECT )then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+    end
+end
+
+-- 当检测到开火模式切换输入时应该直接停止动画并返回闲置态
+function inspect_state.transition(this, context, input)
+    if (input == INPUT_FIRE_SELECT) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))
+        return main_track_states.idle
+    end
+    return main_track_states.inspect.transition(this, context, input)
+end
+
+
+-- 用元表的方式继承默认状态机的属性
+local M = setmetatable({
+    main_track_states = setmetatable({
+        idle = idle_state,
+        inspect = inspect_state
+    }, {__index = main_track_states}),
+    FIRE_MODE_TRACK = FIRE_MODE_TRACK,
+    SWITCH_MODE_TRACK = SWITCH_MODE_TRACK,
+    INPUT_MODE_SEMI = "input_mode_semi",
+    INPUT_MODE_BURST = "input_mode_burst",
+    INPUT_MODE_AUTO = "input_mode_auto",
+    INPUT_MODE_DRAW = "input_mode_draw",
+    fire_mode_state = fire_mode_state
+}, {__index = default})
+function M:initialize(context)
+    default.initialize(self, context)
+end
+-- 继承默认状态机需要重新初始化状态
+function M:states()
+    return {
+        self.base_track_state,
+        self.bolt_caught_states.normal,
+        self.main_track_states.start,
+        self.gun_kick_state,
+        self.movement_track_states.idle,
+        self.ADS_states.normal,
+        self.slide_states.normal,
+        self.fire_mode_state.draw
+    }
+end
+-- 导出状态机
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/sp_m1903_state_machine.lua

@@ -0,0 +1,145 @@
+local default = require("tacz_default_state_machine")
+
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local MAIN_TRACK = default.MAIN_TRACK
+local GUN_KICK_TRACK_LINE = default.GUN_KICK_TRACK_LINE
+
+local main_track_states = default.main_track_states
+local static_track_top = default.static_track_top
+
+local inspect_state = setmetatable({}, {__index = main_track_states.inspect})
+local idle_state = setmetatable({}, {__index = main_track_states.idle})
+
+-- 🔥 GUN KICK STATE (FIXED SHOOT SYSTEM)
+local gun_kick_state = setmetatable({}, { __index = default.gun_kick_state })
+
+function gun_kick_state.transition(this, context, input)
+    if input == INPUT_SHOOT then
+        local track = context:findIdleTrack(GUN_KICK_TRACK_LINE, false)
+
+        local ammo = context:getAmmoCount()
+        local hasBullet = context:hasBulletInBarrel()
+        local totalAmmo = ammo + (hasBullet and 1 or 0)
+
+        if totalAmmo == 1 then
+            context:runAnimation("shoot_last", track, true, PLAY_ONCE_STOP, 0)
+        elseif totalAmmo > 1 then
+            context:runAnimation("shoot", track, true, PLAY_ONCE_STOP, 0)
+        end
+    end
+
+    return nil
+end
+
+-- helper
+local function increment(obj)
+    obj.value = obj.value + 1
+    return obj.value - 1
+end
+
+local FIRE_MODE_TRACK = increment(static_track_top)
+local SWITCH_MODE_TRACK = increment(static_track_top)
+
+-- 🔥 RELOAD LOGIC (AMMO BASED)
+local function runReloadAnimation(context)
+
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+
+    local ammo = context:getAmmoCount()
+    local hasBullet = context:hasBulletInBarrel()
+    local totalAmmo = ammo + (hasBullet and 1 or 0)
+
+    if totalAmmo >= 5 then
+        context:runAnimation("gun_check", track, false, PLAY_ONCE_STOP, 0.2)
+        return
+    end
+
+    if totalAmmo == 0 then
+        context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+    elseif totalAmmo == 1 then
+        context:runAnimation("reload_4", track, false, PLAY_ONCE_STOP, 0.2)
+    elseif totalAmmo == 2 then
+        context:runAnimation("reload_3", track, false, PLAY_ONCE_STOP, 0.2)
+    elseif totalAmmo == 3 then
+        context:runAnimation("reload_2", track, false, PLAY_ONCE_STOP, 0.2)
+    elseif totalAmmo == 4 then
+        context:runAnimation("reload_1", track, false, PLAY_ONCE_STOP, 0.2)
+    end
+end
+
+-- 🔍 INSPECT
+local function runInspectAnimation(context)
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+
+    if (not context:hasBulletInBarrel() and context:getAmmoCount() <= 0) then
+        context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+    else
+        context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+    end
+end
+
+-- 💤 IDLE
+function idle_state.transition(this, context, input)
+
+    if (input == INPUT_RELOAD) then
+        runReloadAnimation(context)
+        return this.main_track_states.idle
+    end
+
+    if (input == INPUT_PUT_AWAY) then
+        local put_away_time = context:getPutAwayTime()
+        local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+        context:runAnimation("put_away", track, false, PLAY_ONCE_HOLD, put_away_time * 0.75)
+        context:setAnimationProgress(track, 1, true)
+        context:adjustAnimationProgress(track, -put_away_time, false)
+
+        return this.main_track_states.final
+    end
+
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        return inspect_state
+    end
+
+    return main_track_states.idle.transition(this, context, input)
+end
+
+-- 🔍 INSPECT STATE
+function inspect_state.transition(this, context, input)
+    if (input == INPUT_FIRE_SELECT) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))
+        return main_track_states.idle
+    end
+    return main_track_states.inspect.transition(this, context, input)
+end
+
+-- 🧠 EXPORT
+local M = setmetatable({
+    main_track_states = setmetatable({
+        idle = idle_state,
+        inspect = inspect_state
+    }, {__index = main_track_states}),
+    gun_kick_state = gun_kick_state,
+    FIRE_MODE_TRACK = FIRE_MODE_TRACK,
+    SWITCH_MODE_TRACK = SWITCH_MODE_TRACK
+}, {__index = default})
+
+function M:initialize(context)
+    default.initialize(self, context)
+end
+
+function M:states()
+    return {
+        self.base_track_state,
+        self.bolt_caught_states.normal,
+        self.main_track_states.start,
+        self.gun_kick_state,
+        self.movement_track_states.idle,
+        self.ADS_states.normal,
+        self.slide_states.normal
+    }
+end
+
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/spaz12_state_machine.lua

@@ -0,0 +1,126 @@
+-- 脚本的位置是 "{命名空间}:{路径}"，那么 require 的格式为 "{命名空间}_{路径}"
+-- 注意！require 取得的内容不应该被修改，应仅调用
+local default = require("tacz_manual_action_state_machine")
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local MAIN_TRACK = default.MAIN_TRACK
+local GUN_KICK_TRACK_LINE = default.GUN_KICK_TRACK_LINE
+local main_track_states = default.main_track_states
+local gun_kick_state = default.gun_kick_state
+-- main_track_states.idle 是我们要重写的状态。
+local shoot_state = setmetatable({},{__index = gun_kick_state})
+local idle_state = setmetatable({}, {__index = main_track_states.idle})
+-- reload_state、bolt_state 是定义的新状态，用于执行单发装填
+
+function shoot_state.transition(this, context, input)
+    if (input == INPUT_SHOOT) then
+        local track = context:findIdleTrack(GUN_KICK_TRACK_LINE, false)
+        if (context:getFireMode() == SEMI) then
+            context:runAnimation("shoot", track, true, PLAY_ONCE_STOP, 0)
+        elseif (context:getFireMode() == BURST) then
+            context:runAnimation("shoot", track, true, PLAY_ONCE_STOP, 0)
+            if (not (context:getAmmoCount() == 0)) then
+                context:popShellFrom(0)
+            end
+        end
+    end
+    return nil
+end
+
+local reload_state = {
+    need_ammo = 0,
+    loaded_ammo = 0
+}
+local function get_ejection_time(context)
+    local ejection_time = context:getStateMachineParams().intro_shell_ejecting_time
+    if (ejection_time) then
+        ejection_time = ejection_time * 1000
+    else
+        ejection_time = 0
+    end
+    return ejection_time
+end
+
+local function runInspectAnimation(context)
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+    if (not context:hasBulletInBarrel() and context:getAmmoCount() <= 0) then
+        context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+    elseif (context:getAmmoCount() <= 0) then
+        context:runAnimation("inspect_01", track, false, PLAY_ONCE_STOP, 0.2)
+    else
+        context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+    end
+end
+
+-- 重写 idle 状态的 transition 函数，将输入 INPUT_RELOAD 重定向到新定义的 reload_state 状态
+function idle_state.transition(this, context, input)
+    if (input == INPUT_RELOAD) then
+        return this.main_track_states.reload
+    end
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        return this.main_track_states.inspect
+    end
+    return main_track_states.idle.transition(this, context, input)
+end
+-- 在 entry 函数里，我们根据情况选择播放 'reload_intro_empty' 或 'reload_intro' 动画，
+-- 并初始化 需要的弹药数、已装填的弹药数。这决定了后续的 'loop' 动画进行几次循环。
+function reload_state.entry(this, context)
+    local state = this.main_track_states.reload
+    local isNoAmmo = not context:hasBulletInBarrel()
+    if (isNoAmmo) then
+        -- 记录开始换弹的时间戳，用于抛出 reload_intro_empty 中的弹壳
+        state.timestamp = context:getCurrentTimestamp()
+        state.ejection_time = get_ejection_time(context)
+        context:runAnimation("reload_start_empty", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_HOLD, 0.2)
+    else
+        state.timestamp = -1
+        state.ejection_time = 0
+        context:runAnimation("reload_start", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_HOLD, 0.2)
+    end
+    state.need_ammo = context:getMaxAmmoCount() - context:getAmmoCount()
+    state.loaded_ammo = 0
+end
+-- 在 update 函数里，循环播放 loop，让 loaded_ammo 变量自增。
+function reload_state.update(this, context)
+    local state = this.main_track_states.reload
+    -- 处理 reload_intro_empty 的抛壳
+    if (state.timestamp ~= -1 and context:getCurrentTimestamp() - state.timestamp > state.ejection_time) then
+        context:popShellFrom(0)
+        state.timestamp = -1
+    end
+    if (state.loaded_ammo > state.need_ammo or not context:hasAmmoToConsume()) then
+        context:trigger(this.INPUT_RELOAD_RETREAT)
+    else
+        local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+        if (context:isHolding(track)) then
+            context:runAnimation("reload_loop", track, false, PLAY_ONCE_HOLD, 0)
+            state.loaded_ammo = state.loaded_ammo + 1
+        end
+    end
+end
+-- 如果 loop 循环结束或者换弹被打断，退出到 idle 状态。否则由 idle 的 transition 函数决定下一个状态。
+function reload_state.transition(this, context, input)
+    if (input == this.INPUT_RELOAD_RETREAT or input == INPUT_CANCEL_RELOAD) then
+        context:runAnimation("reload_finish", context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK), false, PLAY_ONCE_STOP, 0.2)
+        return this.main_track_states.idle
+    end
+    return this.main_track_states.idle.transition(this, context, input)
+end
+-- 用元表的方式继承默认状态机的属性
+local M = setmetatable({
+    main_track_states = setmetatable({
+        -- 自定义的 idle 状态需要覆盖掉父级状态机的对应状态，新建的 reload 状态也要加进来
+        idle = idle_state,
+        reload = reload_state
+    }, {__index = main_track_states}),
+    INPUT_RELOAD_RETREAT = "reload_retreat",
+    gun_kick_state = setmetatable({},{__index = shoot_state})
+}, {__index = default})
+-- 先调用父级状态机的初始化函数，然后进行自己的初始化
+function M:initialize(context)
+    default.initialize(self, context)
+    self.main_track_states.reload.need_ammo = 0
+    self.main_track_states.reload.loaded_ammo = 0
+end
+-- 导出状态机
+return M

tacz/elitex_quality_guns/assets/elitex/scripts/trs_bull_state_machine.lua

@@ -0,0 +1,145 @@
+local default = require("tacz_default_state_machine")
+
+local STATIC_TRACK_LINE = default.STATIC_TRACK_LINE
+local MAIN_TRACK = default.MAIN_TRACK
+local GUN_KICK_TRACK_LINE = default.GUN_KICK_TRACK_LINE
+
+local main_track_states = default.main_track_states
+local static_track_top = default.static_track_top
+
+local inspect_state = setmetatable({}, {__index = main_track_states.inspect})
+local idle_state = setmetatable({}, {__index = main_track_states.idle})
+
+-- 🔥 GUN KICK STATE (FIXED SHOOT SYSTEM)
+local gun_kick_state = setmetatable({}, { __index = default.gun_kick_state })
+
+function gun_kick_state.transition(this, context, input)
+    if input == INPUT_SHOOT then
+        local track = context:findIdleTrack(GUN_KICK_TRACK_LINE, false)
+
+        local ammo = context:getAmmoCount()
+        local hasBullet = context:hasBulletInBarrel()
+        local totalAmmo = ammo + (hasBullet and 1 or 0)
+
+        if totalAmmo == 1 then
+            context:runAnimation("shoot_last", track, true, PLAY_ONCE_STOP, 0)
+        elseif totalAmmo > 1 then
+            context:runAnimation("shoot", track, true, PLAY_ONCE_STOP, 0)
+        end
+    end
+
+    return nil
+end
+
+-- helper
+local function increment(obj)
+    obj.value = obj.value + 1
+    return obj.value - 1
+end
+
+local FIRE_MODE_TRACK = increment(static_track_top)
+local SWITCH_MODE_TRACK = increment(static_track_top)
+
+-- 🔥 RELOAD LOGIC (AMMO BASED)
+local function runReloadAnimation(context)
+
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+
+    local ammo = context:getAmmoCount()
+    local hasBullet = context:hasBulletInBarrel()
+    local totalAmmo = ammo + (hasBullet and 1 or 0)
+
+    if totalAmmo >= 5 then
+        context:runAnimation("gun_check", track, false, PLAY_ONCE_STOP, 0.2)
+        return
+    end
+
+    if totalAmmo == 0 then
+        context:runAnimation("reload_empty", track, false, PLAY_ONCE_STOP, 0.2)
+    elseif totalAmmo == 1 then
+        context:runAnimation("reload_4", track, false, PLAY_ONCE_STOP, 0.2)
+    elseif totalAmmo == 2 then
+        context:runAnimation("reload_3", track, false, PLAY_ONCE_STOP, 0.2)
+    elseif totalAmmo == 3 then
+        context:runAnimation("reload_2", track, false, PLAY_ONCE_STOP, 0.2)
+    elseif totalAmmo == 4 then
+        context:runAnimation("reload_1", track, false, PLAY_ONCE_STOP, 0.2)
+    end
+end
+
+-- 🔍 INSPECT
+local function runInspectAnimation(context)
+    local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+
+    if (not context:hasBulletInBarrel() and context:getAmmoCount() <= 0) then
+        context:runAnimation("inspect_empty", track, false, PLAY_ONCE_STOP, 0.2)
+    else
+        context:runAnimation("inspect", track, false, PLAY_ONCE_STOP, 0.2)
+    end
+end
+
+-- 💤 IDLE
+function idle_state.transition(this, context, input)
+
+    if (input == INPUT_RELOAD) then
+        runReloadAnimation(context)
+        return this.main_track_states.idle
+    end
+
+    if (input == INPUT_PUT_AWAY) then
+        local put_away_time = context:getPutAwayTime()
+        local track = context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK)
+
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, SWITCH_MODE_TRACK))
+        context:runAnimation("put_away", track, false, PLAY_ONCE_HOLD, put_away_time * 0.75)
+        context:setAnimationProgress(track, 1, true)
+        context:adjustAnimationProgress(track, -put_away_time, false)
+
+        return this.main_track_states.final
+    end
+
+    if (input == INPUT_INSPECT) then
+        runInspectAnimation(context)
+        return inspect_state
+    end
+
+    return main_track_states.idle.transition(this, context, input)
+end
+
+-- 🔍 INSPECT STATE
+function inspect_state.transition(this, context, input)
+    if (input == INPUT_FIRE_SELECT) then
+        context:stopAnimation(context:getTrack(STATIC_TRACK_LINE, MAIN_TRACK))
+        return main_track_states.idle
+    end
+    return main_track_states.inspect.transition(this, context, input)
+end
+
+-- 🧠 EXPORT
+local M = setmetatable({
+    main_track_states = setmetatable({
+        idle = idle_state,
+        inspect = inspect_state
+    }, {__index = main_track_states}),
+    gun_kick_state = gun_kick_state,
+    FIRE_MODE_TRACK = FIRE_MODE_TRACK,
+    SWITCH_MODE_TRACK = SWITCH_MODE_TRACK
+}, {__index = default})
+
+function M:initialize(context)
+    default.initialize(self, context)
+end
+
+function M:states()
+    return {
+        self.base_track_state,
+        self.bolt_caught_states.normal,
+        self.main_track_states.start,
+        self.gun_kick_state,
+        self.movement_track_states.idle,
+        self.ADS_states.normal,
+        self.slide_states.normal
+    }
+end
+
+return M