设计模式之游戏--状态模式

最新推荐文章于 2023-10-11 15:06:56 发布
最新推荐文章于 2023-10-11 15:06:56 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： 设计模式之游戏 文章标签： 状态模式 c# unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/a15970673567/article/details/122285514
版权
状态模式是一种设计模式，用于解决对象在不同状态下的行为管理。通过将状态相关的行为封装到各自的状态类中，可以简化复杂的逻辑判断，提高代码的可读性和可扩展性。在示例中，通过StateManager管理人物的IdleState、ChaseState和AttackState，根据条件触发状态转换，实现了游戏人物在不同状态下的行为切换，遵循了单一职责原则，减少了对象间的依赖，同时也便于添加新的状态和转换。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一.引入问题

在软件开发过程中，应用程序可能会根据不同的情况作出不同的处理。最直接的解决方案是将这些所有可能发生的情况全都考虑到。然后使用判断语句来做状态判断来进行不同情况的处理。但是对复杂状态的判断就显得“力不从心了”。随着增加新的状态或者修改一个状态导致判断语句的增多或者修改可能会引起很大的修改，而且程序的可读性，扩展性也会变得很弱。维护也会很麻烦。此时我们的状态模式就孕育而生了。

而状态模式的作用就是：解决当控制一个对象状态转换的条件表达式过于复杂时，把状态的判断逻辑转移到表示不同的一系列类当中，把复杂的逻辑判断简单化，其意图是让一个对象在其内部状态改变的时候其行为也随之改变，是一种对象行为型模式

定义

当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。这个有点晦涩的定义后面总结的时候再细讲。

UML图

在这里插入图片描述
StateManager:状态管理者，它的作用是维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。
State：抽象状态，用于封装状态的行为和属性，简单来说就是提取各状态的共同行为和属性。
StateA:具体状态，实现抽象状态的具体行为。

具体示例：

下面我们以游戏中人物的人物为例，实现人物的状态机。
StateManager(状态管理者):

using System;
using System.Collections.Generic;
using UnityEngine;

//人物行为枚举
public enum Actions
{
    NullAction = 0,
    SeeEnemy,//看到敌人
    NoEnemy,//失去敌人
    CanAttack//攻击敌人

}
//人物状态ID
public enum StateID
{
    NullState,
    Idle,//站立
    Chase,//追赶（奔跑）
    Attack,//攻击
}

public class StateManager
{
    private List<State> states = new List<State>();
    private State mCurrent;

    public State CurrentState
    {
        get
        {
            return mCurrent;
        }
       
    }

    public void AddState(State state)
    {
        if (state==null)
        {
            Debug.LogError("state 不能为空null");
            return;
        }
        else
        {
            if (states.Count==0)
            {
                states.Add(state);
                mCurrent = state;
                mCurrent.Enter();
                return;
            }
            foreach (State item in states)
            {
                if (item == state)
                {
                    Debug.LogError("states 已经存在state");
                    return;
                }
            }
            states.Add(state);
        }   
    }
    public void AddState(params State[] states)
    {
        foreach (State item in states)
        {
            AddState(item);
        }
    }
    public void DeleteState(StateID stateID)
    {
        if (states.Count==0)
        {
            Debug.LogError("states为空");
        }
        foreach (State item in states)
        {
            if (item.StateID== stateID)
            {
                states.Remove(item);
                return;
            }
        }
        Debug.LogError("states 不存在" + stateID.ToString());
    }

    public void ChangeState(Actions action)
    {
        if (action== Actions.NullAction)
        {
            Debug.LogError("action 不能为空");
        }
        StateID nextstate = mCurrent.GetNextState(action);
        if (nextstate == StateID.NullState)
        {
            Debug.LogError("nextstate为空");
            return ;
        }
        foreach (State item in states)
        {
            if (item.StateID== nextstate)
            {
                mCurrent.Leave();
                mCurrent = item;
                item.Enter();
                return;
            }
        }
        Debug.LogError(mCurrent+"没有"+ action);

    }

    
    public void print(string riZhi)
    {
        Debug.Log(riZhi);
    }

}

人物抽象状态：


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;

  public abstract class State
{
    private Dictionary<Actions, StateID> actionDic = new Dictionary<Actions, StateID>();
    private StateID mstateID;
    protected StateManager stateFSM;
    public State(StateManager stateManager,StateID currentState)
    {
        stateFSM = stateManager;
        mstateID = currentState;
    }
    public StateID StateID
    {
        get
        {
            return mstateID;
        }
    }
    public StateID GetNextState(Actions action)
    {
        if (action==Actions.NullAction)
        {
            Debug.LogError("action不能为空");
            return StateID.NullState;
        }
        if (actionDic.ContainsKey(action)==false)
        {
            Debug.LogError(mstateID+"不包含：" + action);
            return StateID.NullState;
        }

        return actionDic[action];
    }

    public abstract void Enter();
    public abstract void Leave();


    public abstract void UpdateState();

    public void AddState(Actions action,StateID stateID)
    {
        if (action == Actions.NullAction)
        {
            Debug.LogError("action不能为空");
            return ;
        }
        if (actionDic.ContainsKey(action) == true)
        {
            Debug.LogError("actionDic已包含：" + action);
            return ;
        }
        actionDic.Add(action, stateID);
    }

    public void DeleteState(Actions action)
    {
        if (action == Actions.NullAction)
        {
            Debug.LogError("action不能为空");
            return;
        }
        if (actionDic.ContainsKey(action) == false)
        {
            Debug.LogError("actionDic没有包含：" + action);
            return;
        }
        actionDic.Remove(action);
    }
}

人物站立状态：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

public class IdleState:State
{
    public IdleState(StateManager stateManager, StateID currentState) : base(stateManager, currentState)
    {
     
    }

    public override void Enter()
    {
        stateFSM.print("进入IdleState");
    }

    public override void Leave()
    {
        stateFSM.print("离开IdleState");
    }

    public override void UpdateState()
    {
        
        if (StartClient.command=="触发从Idle状态转换为Chase状态的条件")
        {
            stateFSM.print("触发从Idle状态转换为Chase状态的条件");
            stateFSM.ChangeState(Actions.SeeEnemy);
        }
    }
}

人物追赶状态：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


 public   class ChaseState:State
    {
    public ChaseState(StateManager stateManager, StateID currentState) : base(stateManager, currentState)
    {

    }

    public override void Enter()
    {
        stateFSM.print("进入ChaseState");
    }

    public override void Leave()
    {
        stateFSM.print("离开ChaseState");
    }

    public override void UpdateState()
    {
        if (StartClient.command == "触发从Chase状态转换为Attack状态的条件")
        {
            stateFSM.print("触发从Chase状态转换为Attack状态的条件");
            stateFSM.ChangeState(Actions.CanAttack);
        }
        if (StartClient.command == "触发从Chase状态转换为Idle状态的条件")
        {
            stateFSM.print("触发从Chase状态转换为Idle状态的条件");
            stateFSM.ChangeState(Actions.NoEnemy);
        }
    }

}

人物攻击状态：


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;



   public class AttackState:State
   {
     public AttackState(StateManager stateManager, StateID currentState):base(stateManager,currentState)
    {
  
    }

    public override void Enter()
    {
        stateFSM.print("进入AttackState");
    }

    public override void Leave()
    {
        stateFSM.print("离开AttackState");
    }

    public override void UpdateState()
    {
        if (StartClient.command == "触发从Attack状态转换为Chase状态的条件")
        {
            stateFSM.print("触发从Attack状态转换为Chase状态的条件");
            stateFSM.ChangeState(Actions.SeeEnemy);
        }

        if (StartClient.command == "触发从Attack状态转换为Idle状态的条件")
        {
            stateFSM.print("触发从Attack状态转换为Idle状态的条件");
            stateFSM.ChangeState(Actions.NoEnemy);
        }
    }
}

客户端示例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;

public  class StartClient:MonoBehaviour
{
    public static string command;
    public StateManager playerStateFSM;
    void Start()
    {
         playerStateFSM = new StateManager();

        IdleState idlestate = new IdleState(playerStateFSM, StateID.Idle);
        idlestate.AddState(Actions.SeeEnemy, StateID.Chase);

        ChaseState chaseState = new ChaseState(playerStateFSM, StateID.Chase);
        chaseState.AddState(Actions.NoEnemy, StateID.Idle);
        chaseState.AddState(Actions.CanAttack, StateID.Attack);

        AttackState attackState = new AttackState(playerStateFSM, StateID.Attack);
        attackState.AddState(Actions.NoEnemy, StateID.Idle);
        attackState.AddState(Actions.SeeEnemy, StateID.Chase);

        playerStateFSM.AddState(idlestate, chaseState, attackState);


     
        Invoke("SendCommand1", 1);
        Invoke("SendCommand2", 2);
        Invoke("SendCommand3",3);
        Invoke("SendCommand4",4);
    }
  
        

    public void SendCommand1()
    {
      
        command = "触发从Idle状态转换为Chase状态的条件";

      
    }
    public void SendCommand2()
    {
       
        command = "触发从Chase状态转换为Attack状态的条件";

       
    }
    public void SendCommand3()
    {
      

        command = "触发从Attack状态转换为Chase状态的条件";

     
    }
    public void SendCommand4()
    {
     

        command = "触发从Chase状态转换为Idle状态的条件";
    }

    private void Update()
    {
        playerStateFSM.CurrentState.UpdateState();
    }

}

请添加图片描述

总结：

优点：
1.状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。就像上面的这个例子一样，人物有很多不同的行为–站立，追赶，攻击…,并且这些行为内部是复杂的，而状态模式把这些行为对应到特定的相关状态，也就是我们上面代码所写的IdleState，ChaseState，AttackState等具体状态，把这些行为的复杂逻辑放到对应的状态进行处理。当当前的状态满足切换条件时也就是UpdateState的判断逻辑成立，我们通过状态管理者StateManager改变当前状态，而在进入新状态时就可以执行相关的行为切换逻辑，通常在Enter()方法里面实现。这也是定义：“当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类”的具体表现。

2.它减少对象间的相互依赖。将不同的状态提取成独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖。观察上面的代码，我们可以很容易的发现IdleState，ChaseState，AttackState这些底层状态并不存在依赖关系，它们都依赖于抽象State,而我们的高层状态管理逻辑StateManager并不依赖于具体的状态，它也依赖与我们的抽象State，这样我们修改StateManager的几率就大大降低了，这其实就是我们的依赖倒置原则，具体的依赖倒置原则的内容可以看我写的这篇文章。

3.有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换，也就是我们的开闭原则。

缺点:
1.状态模式的使用必然会增加系统的类与对象的个数。
2.状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱。

如果本文有什么错误还望指出，如果您觉得写的不错，欢迎三连支持。

23种设计模式-状态(State)设计模式
片言可决讼，半纸能缚龙
11-18 1408
软考中级-软件设计师 状态设计模式
Unity客户端框架笔记（状态模式和策略模式在游戏中的应用）
langresser的专栏
05-17 3962
最近花了几天时间梳理了一下新游戏的客户端框架，虽然本身就有相对明确的方向，但是在一开始写的时候还是有些混乱，不过最终梳理完成后，个人感觉代码清爽很多。         这篇文章不是设计模式的教学，而是自己的一些想法和实践，我把代码梳理成自己喜欢的结构，保证逻辑和结构的清晰，但是这并不意味者它是符合所有人习惯的。         我之前有写过一两篇文章讨论客户端的结构，也吐槽过一些其他人的设计。
游戏开发设计模式（二）：状态模式(State Pattern)
klscer的博客
01-18 2768
在游戏中，游戏物体经常会因为玩家输入或者事件从一种状态转变为另一种状态，从而使其行为也发生变化。对于以上情况最简单的办法就是使用if-else或者switch-case语句，但这样做不利于程序的拓展和维护。 通过状态模式（State Pattern）可以很好的解决这个问题。在状态模式（State Pattern）中，物体的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。 我们使用状态模式来实现一个根据其内部状态改变而改变行为的系统。因此游戏环境...
游戏设计模式——状态模式（state）
BBoyLXiang的博客
07-24 1037
namespace Leon_State { //状态持有者（持有目前的状态，并将有关的讯息传给状态） public class Context { State m_State = null; public void Request(int Value) { m_State.Handle(Value); } public void SetState(State theState)
[一天一个设计模式]-[状态模式]
A_yes的博客
11-20 336
状态模式(State Pattern) ：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。其别名为状态对象(Objects for States)，状态模式是一种对象行为型模式。 状态模式包含以下主要角色。 环境（Context）角色：也称为上下文，它定义了客户感兴趣的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。 抽象状态（State）角色：...
【设计模式游戏完美开发】状态模式
两水先木示的博客
06-17 401
Context (状态拥有者)：拥有一个IState状态对象，由外部调用SetState方法进行赋值；Update方法会调用IState对象的Update方法 IState（状态接口）：拥有一个Context状态拥有者对象，Update方法和ChangeState(IState)方法，其中，Update方法是执行状态逻辑的，ChangeState(IState)方法是转换当前状态为参数IS...
设计模式-状态模式.pdf
05-16
### 设计模式之状态模式详解 #### 一、概述 状态模式（State Pattern）是一种行为设计模式，它允许对象在其内部状态改变时改变其行为，从而使对象看起来像改变了其类。这种模式的主要目的是将对象的状态作为独立的...
C# 设计模式系列教程-状态模式
09-02
状态模式是一种行为设计模式，它使你能在运行时改变对象的行为。在C#中，状态模式主要用于处理对象根据其内部状态变化而改变其行为的情况。当控制对象状态转换的条件表达式变得过于复杂时，状态模式能将这些复杂的...
设计模式专题之（二十一）状态模式---设计模式状态模式示例代码(python--c++)
09-18
状态模式是一种行为设计模式，它允许对象在内部状态改变时改变其行为，对象看起来似乎修改了它的类。这种模式常用于处理对象的状态变化，使得对象的行为与其状态紧密相关，通过改变对象的状态，来改变对象的行为。 ...
《设计模式》实战---状态模式（State Pattern）
08-03
状态模式是一种行为设计模式，它使你能在运行时改变对象的行为。在状态模式中，一个对象的状态变化会导致其行为的变化。这种模式常用于处理具有多种状态的对象，且不同状态下对象的行为差异较大。通过将每种状态封装...
游戏设计模式-状态模式
成长ing中的w的专栏
06-11 258
using System.Collections; using System.Collections.Generic; using UnityEngine; namespace DesignPattern { /// <summary> /// 角色AI【状态拥有者】 /// 拥有当前的状态，并且可以切换当前的状态 /// </summary> public abstract class ICharacterAI {
游戏设计模式--状态模式
顽皮细雨的博客
04-17 805
/* 设计模式学习--状态模式 * 优点：在面向对象软件设计时，常常碰到某一个对象由于状态的不同而有不同的行为。 * 如果用if else或是switch case等方法处理，对象操作及对象的状态就耦合在一起， * 碰到复杂的情况就会造成代码结构的混乱。在这种情况下，就可以使用状态模式来解决问题。 * 定义：状态模式允许一个对象在其内...
游戏设计模式-单例模式
qq_38815038的博客
04-20 4667
当我刚进入游戏行业的时候，所编写的代码，使用了不少的单例，但随着后来的很多bug，我开始意识到单例模式的弊端。 1 什么是单例模式 “确保一个类只有一个实例，并为其提供一个全局访问入口。单例模式提供了在编译期就能确保某个类只有一个实例的方法。 单例的定义： （1）构造函数私有化，防止外界创建出对象； （2）使用一个唯一的变量指向该类的唯一实例； （3）提供一个开放接口供外部使用。 2 创建单例的几种方法 （1）Lazy Singleton（懒汉）：单例在第一次使用时才会被创建出来。
游戏设计模式
小磊的专栏
07-04 820
参考书籍：https://gpp.tkchu.me/acknowledgements.html
状态模式在游戏开发中的应用
热门推荐
Sun.ME的博客
01-18 1万+
状态模式 在状态模式中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为模式。 我们通过创建一个对象来随着状态的改变而进行不同的行为。 意图 允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。主要用来解决：对象的行为依赖于它的状态，并且可以根据它的状态改变而改变它的行为。 需求描述： 我们在游戏中控制一个角色，我们需要操作键盘，按下不同的键来改变当前角色的状态...
设计模式之状态模式（State）
m0_69395323的博客
10-11 397
状态模式（State）状态模式（State），在大多数的设计模式书籍中都会提及，它也是游戏程序设计中应用最频繁的一种模式。主要是因为“状态”经常被应用在游戏设计的诸多环节中，包含AI人工智能状态，账号登陆状态，角色状态等。提示：以下是本篇文章正文内容，下面案例可供参考状态模式（State），在GoF中的解释是：“让一个对象的行为随着内部状态的改变而变化而该对象也像是换了类一样”。
游戏编程模式之状态模式
ZhuSenlin的博客。
10-20 195
允许一个对象在其内部状态改变时改变自身的行为。对象看起来好像是在修改自身类。。 （摘自《游戏编程模式》） 我们熟悉的名词：有限状态机（finite state machines,fsm）就是状态模式的应用。正如Unity 的动画状态机。 状态机 根据上面给出Unity游戏引擎的Animator状态机可以看出，在状态机中，无论任何时刻，在状态中只有一种激活状态。这就是状态模式最鲜明的特点。如何构造自己的状态机呢？我们需要进行如下步骤： 枚举所有的状态，并且在这组状态之间可以相互转换。 确定在这种状态中.
设计模式 之 状态模式//用游戏中的例子解释设计模式
Ice_冰的博客
06-09 1564
个人笔记整理：此类型的博客的写作初衷在于，整理自己平时所学的知识，随时欢迎各路大神指正什么时候使用状态模式/状态模式有什么用？    官方的说法是，当对象有很明确的状态划分的时候；       如：地下城与勇士中，战斗法师的觉醒技能：变身贝亚娜斗神；如下情况通常会使用状态模式            当玩家变身为贝亚娜状态之前，战斗法师的前冲攻击（→→+X）是这样的——战斗法师使用手中的武器敲击敌方...
设计模式在游戏开发中的应用
Dugege007的博客
04-24 1721
本文简要记录关于“设计模式在游戏开发中如何应用”的学习心得，便于日后回顾时能有所启发。 在学习设计模式的过程中，笔者发现设计模式其实就是面向对象的数据结构。 一个由0和1组成的系统，通过各种各样的数据结构和算法，层层编织出能够模拟现实的游戏世界，这实在是太美妙了！
Java设计模式-状态模式
最新发布
03-22
<think>好的，我现在需要回答用户关于Java中状态模式的设计与实现的问题，并且根据提供的引用内容来支持回答。首先，我要确保理解状态模式的基本概念和应用场景。 用户提供的引用中，状态模式被定义为一种行为型设计模式，允许对象在内部状态改变时改变其行为，而无需修改其代码。引用[2]提到状态模式通过将行为封装到不同的状态类中，使对象在不同状态下有不同的行为。引用[4]也指出，状态模式在对象内部状态改变时改变其行为，并将行为封装在不同的状态对象中。这些信息帮助我确认状态模式的核心思想是状态与行为的分离。 接下来，用户需要具体的Java示例。引用[3]提到了订单状态的处理，这可能是一个典型的应用场景，比如电商系统中的订单状态机。结合引用[1]中的电子商务项目实例，我可以设计一个订单状态的例子，展示不同状态下的行为变化。 我需要构建一个结构清晰的示例，包括上下文类（Context）和具体的状态类。根据引用中的信息，状态模式的结构通常包含一个抽象状态接口或抽象类，具体状态类实现该接口，上下文类持有当前状态并委托行为给状态对象。 此外，要确保代码符合Java规范，使用合适的设计，比如将状态转换逻辑放在具体状态类中，或者由上下文类管理状态转换。根据引用[3]中的状态机业务实现，可能状态转换由状态类自身触发，比如处理完一个操作后切换到下一个状态。 在编写示例时，需要注意状态之间的转换条件和行为。例如，订单从“待支付”变为“已支付”，再变为“已发货”等。每个状态处理的操作（如支付、发货）会导致状态变更，这需要在具体状态类中实现。 最后，根据用户提供的引用内容，我需要正确标注引用来源。例如，在解释状态模式定义时引用[2]和[4]，在提到电商应用时引用[1]和[3]。 现在，我需要将这些思路整合成一个结构清晰的回答，包含定义、结构、实现步骤、示例代码和应用场景，并在适当位置添加引用标注。同时，生成相关问题以帮助用户进一步理解。</think>### Java 状态模式的设计与实现 #### 1. 定义与核心思想 状态模式（State Pattern）是一种行为型设计模式，允许对象在内部状态改变时改变其行为。其核心是将**对象的行为封装到不同的状态类**中，通过切换状态对象实现行为的动态调整，避免大量条件判断语句[^2][^4]。 #### 2. 模式结构 - **上下文类（Context）**：持有当前状态对象，定义客户端调用的接口。 - **抽象状态类（State）**：定义状态行为的接口。 - **具体状态类（ConcreteState）**：实现抽象状态类的行为逻辑，可能触发状态转换。 #### 3. 实现步骤（以电商订单状态为例） ##### 步骤1：定义状态接口 ```java public interface OrderState { void pay(OrderContext context); // 支付操作 void ship(OrderContext context); // 发货操作 } ``` ##### 步骤2：实现具体状态类 - **待支付状态** ```java public class UnpaidState implements OrderState { @Override public void pay(OrderContext context) { System.out.println("支付成功"); context.setState(new PaidState()); // 状态切换 } @Override public void ship(OrderContext context) { System.out.println("错误：尚未支付，无法发货"); } } ``` - **已支付状态** ```java public class PaidState implements OrderState { @Override public void pay(OrderContext context) { System.out.println("错误：订单已支付"); } @Override public void ship(OrderContext context) { System.out.println("发货成功"); context.setState(new ShippedState()); // 状态切换 } } ``` ##### 步骤3：定义上下文类 ```java public class OrderContext { private OrderState currentState; public OrderContext() { this.currentState = new UnpaidState(); // 初始状态 } public void setState(OrderState state) { this.currentState = state; } public void pay() { currentState.pay(this); // 委托给当前状态 } public void ship() { currentState.ship(this); } } ``` #### 4. 使用示例 ```java public class Client { public static void main(String[] args) { OrderContext order = new OrderContext(); order.ship(); // 输出：错误：尚未支付，无法发货 order.pay(); // 输出：支付成功 order.ship(); // 输出：发货成功 } } ``` #### 5. 应用场景 - **订单状态流转**：如电商系统中订单的“待支付→已支付→已发货”流程[^3]。 - **游戏角色状态**：角色“站立→移动→攻击”状态切换。 - **硬件设备控制**：打印机“空闲→打印→缺纸”状态管理。 #### 6. 优势与注意事项 - **优势**：消除复杂条件分支、符合开闭原则、状态转换逻辑集中管理[^1][^2]。 - **注意事项**：避免状态类膨胀（需合理拆分粒度）、上下文类与状态类的职责边界需清晰。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值