设计模式简单RPG游戏设计

爱读书的歌者

 关注

阅读 72

2022-02-26

/*factory（工厂）
*/
/*MageRoleFactory*/

package finalexam.factory;

import finalexam.role.*;

/**
 * @Author PoX21s
 * @Date: 2021/12/4 11:57
 * @Version 1.0
 */

/*
* 法师工厂，返回一个具体的法师实例
* */
public class MageRoleFactory implements RoleFactory{
    //持有一个法师
    private MageRole mageRole;
    //根据用户传入的创建类别，创建法师和设置角色名字
    public Role getRole(String type, String name){
        if (type.equals("火球法师")){
            mageRole = new MageRole(name,new FireballMagic());
        }else if (type.equals("雷电法师")){
            mageRole = new MageRole(name,new ThunderMagic());
        }else if (type.equals("治疗法师")){
            mageRole = new MageRole(name,new RecoveryMagic());
        }else if (type.equals("强力法师")){
            mageRole = new MageRole(name,new AssaultMagic());
        }

        return mageRole;
    }
}

/*RoleFactory*/

package finalexam.factory;

import finalexam.role.Role;

/*
* 定义工厂接口
* */
public interface RoleFactory {
    // 基本方法，返回一个指定的角色
    Role getRole(String type, String name);
}

/*WarriorRoleFactory*/

package finalexam.factory;

import finalexam.role.*;

/**
 * @Author PoX21s
 * @Date: 2021/12/4 12:06
 * @Version 1.0
 */

public class WarriorRoleFactory implements RoleFactory{
    private WarriorRole warriorRole;

    public Role getRole(String type, String name){
        if (type.equals("冲锋战士")){
            warriorRole = new WarriorRole(name,new Axe());
        } else if (type.equals("独立战士")){
            warriorRole = new WarriorRole(name,new Stick());
        } else if (type.equals("快枪战士")){
            warriorRole = new WarriorRole(name,new Spear());
        } else if (type.equals("无畏战士")){
            warriorRole = new WarriorRole(name,new Sword());
        }

        return warriorRole;
    }
}

/*role*/

package finalexam.role;

/**
 * @Author PoX21s
 * @Date: 2021/11/26 19:07
 * @Version 1.0
 */

/*
* 加强攻击魔法
* - 使攻击效果加强
* */
public class AssaultMagic extends MagicBehavior {
    public AssaultMagic() {
        setName("攻击加强");
        setEffect(30.0);
        setMp(10.0);
    }

    public void attackByMagic() {
        System.out.println("使用"+getName()+"魔法，造成"+ getEffect()+"点伤害;扣除"+getMp()+"点魔法值。");
    }
}

package finalexam.role;

/**
 * @Author PoX21s
 * @Date: 2021/11/26 19:06
 * @Version 1.0
 */

/*
* 武器
* - 斧头
* */
public class Axe extends WeaponBehavior{
    public Axe() {
        setAtk(30);
    }

    public void attackByWeapon() {
        System.out.println("使用武器-斧头攻击,造成"+getAtk()+"伤害");
    }
}

package finalexam.role;

/**
 * @Author PoX21s
 * @Date: 2021/11/26 19:03
 * @Version 1.0
 */

/*
* 具体魔法攻击 -- 火球术
* */
public class FireballMagic extends MagicBehavior {
    /*
    * 初始赋值，技能的名字、影响和蓝量消耗
    * */
    public FireballMagic() {
        setName("火球");
        setEffect(50.0);
        setMp(20.0);
    }
    /*
    * 重写相关方法，实现不同技能的不同效果
    * */
    @Override
    public void attackByMagic() {
        System.out.println("使用"+getName()+"魔法，造成"+ getEffect()+"点伤害;扣除"+getMp()+"点魔法值。");
    }
}

package finalexam.role;

/**
 * @Author PoX21s
 * @Date: 2021/12/4 11:34
 * @Version 1.0
 */

/*
* 法师
* - 法师可以使用魔法攻击
* - 魔法比基本角色多50点
* - 血量比基本角色少10点
* */
public class MageRole extends Role{
    //持有魔法攻击
    private MagicBehavior magicBehavior;

    /*
    * 初始赋值，基本属性
    * */
    public MageRole(String name, MagicBehavior magicBehavior) {
        super(name);
        setHp(90.0);
        setMp(150.0);
        this.magicBehavior = magicBehavior;
    }

    //重写相关方法实现技能使用
    @Override
    public void skillAttack() {
        //使用技能
        magicBehavior.attackByMagic();
        //技能使用后扣取相应的蓝量
        this.setMp(getMp() - magicBehavior.getMp());
    }

    public MagicBehavior getMagicBehavior() {
        return magicBehavior;
    }

    @Override
    public String toString() {
        return "角色属性：" +
                "名字为：'" + getName() + '\''+
                ", 生命值为：" + getHp() +
                ", 魔法值为：" + getMp() +
                ", 攻击力为：" + getAtk() +
                ", 防御力为：" + getDef() + ", 拥有技能为：" +
                getMagicBehavior().getName();
    }
}


package finalexam.role;

/**
 * @Author PoX21s
 * @Date: 2021/11/26 19:02
 * @Version 1.0
 */

/*
* 魔法攻击抽象类，定义魔法攻击的基础属性和基本方法。
* */
public abstract class MagicBehavior{
    /*
    * 基础属性
    * */
    private double mp; // 技能所需要的消耗蓝量
    private double effect; // 使用技能造成的影响
    private String name; // 魔法技能的名字
    /*
    * 基本方法
    * */
    // 使用魔法技能
    abstract void attackByMagic();

    public double getMp() {
        return mp;
    }

    public void setMp(double mp) {
        this.mp = mp;
    }

    public double getEffect() {
        return effect;
    }

    public void setEffect(double effect) {
        this.effect = effect;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package finalexam.role;

/**
 * @Author PoX21s
 * @Date: 2021/11/26 19:04
 * @Version 1.0
 */

/*
* 恢复魔法
* - 恢复血量
* */
public class RecoveryMagic extends MagicBehavior {
    public RecoveryMagic() {
        setName("恢复");
        setEffect(60.0);
        setMp(30.0);
    }

    public void attackByMagic() {
        System.out.println("使用"+getName()+"魔法，恢复"+ getEffect()+"点生命值;扣除"+getMp()+"点魔法值。");
    }
}

package finalexam.role;

import finalexam.state.*;

/**
 * @Author PoX21s
 * @Date: 2021/12/4 11:17
 * @Version 1.0
 */

/*
* 定义一个角色抽象类，其他角色从中扩展。
* - 默认初始化属性
* */
public class Role {
    private String name; // 人物名字
    private double hp = 100.0; // 血量
    private double mp = 100.0; // 蓝量
    private double atk = 10; // 基础攻击力
    private double def = 10; // 防御力

    // 状态管理
    InitState initState = new InitState(this);
    DeadState deadState = new DeadState(this);
    DieRightState dieRightState = new DieRightState(this);
    FightState fightState = new FightState(this);
    MoveState moveState = new MoveState(this);

    // 初始状态
    private State state = initState; // 初始状态

    // 玩家在游戏中的坐标
    private int x = 1; // 默认初始化在起点
    private int y = 1;

    // 人物有参构造器
    public Role(String name) {
        this.name = name;
    }

    // 普通攻击
    public void Attack(){
        System.out.println("进行普通攻击，造成"+getAtk()+"点伤害。");
    }

    // 技能攻击
    /*
    * 基本人物是不能使用技能攻击的，默认会抛出一个异常
    * 后续的扩展人物，重写方法，实现不同人物效果
    * */
    public void skillAttack(){
        throw new RuntimeException();
    }

    /*
    * 玩家基本功能，移动和攻击
    * 调用具体状态下的具体方法
    * */
    public boolean move(){
        return state.move();
    }

    public int fight(){
        return state.fight();
    }

    // 防御
    public void Defense(){
        System.out.println("基本防御");
    }

    // 状态设置
    public void setDeadState() {
        this.state = deadState;
    }

    public void setDieRightState() {
        this.state = dieRightState;
    }

    public void setFightState() {
        this.state = fightState;
    }

    public void setMoveState() {
        this.state = moveState;
    }

    @Override
    public String toString() {
        return "角色属性：" +
                "名字为：'" + name + '\''+
                ", 生命值为：" + hp +
                ", 魔法值为：" + mp +
                ", 攻击力为：" + atk +
                ", 防御力为：" + def;
    }

    // 人物属性的get/set方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getHp() {
        return hp;
    }

    public void setHp(double hp) {
        this.hp = hp;
    }

    public double getMp() {
        return mp;
    }

    public void setMp(double mp) {
        this.mp = mp;
    }

    public double getAtk() {
        return atk;
    }

    public void setAtk(double atk) {
        this.atk = atk;
    }

    public double getDef() {
        return def;
    }

    public void setDef(double def) {
        this.def = def;
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

package finalexam.role;

/**
 * @Author PoX21s
 * @Date: 2021/11/26 19:06
 * @Version 1.0
 */
/*
* 武器 - 枪
* */
public class Spear extends WeaponBehavior{
    public Spear() {
        setAtk(25.0);
    }

    public void attackByWeapon() {
        System.out.println("使用武器-枪攻击,造成"+getAtk()+"伤害");
    }
}

package finalexam.role;

/**
 * @Author PoX21s
 * @Date: 2021/11/26 19:05
 * @Version 1.0
 */

/*
* 武器
* - 权杖
* */
public class Stick extends WeaponBehavior{
    public Stick() {
        setAtk(40);
    }

    public void attackByWeapon() {
        System.out.println("使用武器-权杖攻击,造成"+getAtk()+"伤害");
    }
}

package finalexam.role;

/**
 * @Author PoX21s
 * @Date: 2021/11/26 19:05
 * @Version 1.0
 */

/*
* 武器
* - 剑
* */
public class Sword extends WeaponBehavior{
    public Sword() {
        setAtk(27);
    }

    public void attackByWeapon() {
        System.out.println("使用武器-剑攻击,造成"+getAtk()+"伤害");
    }
}

package finalexam.role;

/**
 * @Author PoX21s
 * @Date: 2021/11/26 19:04
 * @Version 1.0
 */

public class ThunderMagic extends MagicBehavior {
    public ThunderMagic() {
        setName("雷电");
        setEffect(60.0);
        setMp(25.0);
    }

    public void attackByMagic() {
        System.out.println("使用"+getName()+"魔法，造成"+ getEffect()+"点伤害;扣除"+getMp()+"点魔法值。");
    }
}

package finalexam.role;

/**
 * @Author PoX21s
 * @Date: 2021/12/4 11:43
 * @Version 1.0
 */

/*
* 战士
* - 使用武器攻击
* - 血量比基本角色初始多10点
* - 魔法比基本角色少40点
* */
public class WarriorRole extends Role{
    private WeaponBehavior weaponBehavior;

    public WarriorRole(String name, WeaponBehavior weaponBehavior) {
        super(name);
        setHp(110);
        setMp(60);
        this.weaponBehavior = weaponBehavior;
    }

    @Override
    public void Attack() {
        weaponBehavior.attackByWeapon();
    }

    public WeaponBehavior getWeaponBehavior() {
        return weaponBehavior;
    }
}

package finalexam.role;

public abstract class WeaponBehavior {
    private double atk; // 攻击力值

    abstract void attackByWeapon();

    public double getAtk() {
        return atk;
    }

    public void setAtk(double atk) {
        this.atk = atk;
    }
}

/*state*/

package finalexam.state;

import finalexam.role.Role;

/**
 * @Author PoX21s
 * @Date: 2021/12/4 13:01
 * @Version 1.0
 */

public class DeadState implements State{
    private Role role;

    public DeadState(Role role) {
        this.role = role;
    }

    @Override
    public boolean move() {
        System.out.println("您已死亡，不能移动，请重新开始游戏...");
        return false;
    }

    @Override
    public int fight() {
        System.out.println("您已死亡，不能战斗，请重新开始游戏...");
        return 0;
    }

    @Override
    public void fightState(String s) {

    }

    @Override
    public void Result() {
        System.out.println("您已死亡，请重新开始游戏...");
    }
}

package finalexam.state;

import finalexam.role.Role;

/**
 * @Author PoX21s
 * @Date: 2021/12/4 13:01
 * @Version 1.0
 */

/*
* 濒死状态
* - 生命值小于10%
* */
public class DieRightState implements State{
    private Role role;

    public DieRightState(Role role) {
        this.role = role;
    }

    @Override
    public boolean move() {
        System.out.println("当前为濒死状态，不能移动，请恢复到健康血量以后再尝试移动...");
        return false;
    }

    @Override
    public int fight() {
        System.out.println("当前为濒死状态，不能战斗，请恢复到健康血量以后再尝试战斗...");
        return 0;
    }

    @Override
    public void fightState(String s) {

    }

    @Override
    public void Result() {
        if (role.getHp() >=0 && role.getHp() <= 20){
            role.setDieRightState();
        } else if(role.getHp() > 20 && role.getHp() <= 90){
            role.setMoveState();
        } else {
            role.setDeadState();
        }
    }
}

package finalexam.state;

import finalexam.role.MageRole;
import finalexam.role.Role;
import finalexam.role.WarriorRole;

import java.util.Scanner;

/**
 * @Author PoX21s
 * @Date: 2021/12/4 13:00
 * @Version 1.0
 */

/*
* 战斗状态
* */
public class FightState implements State{
    private Role role;

    public FightState(Role role) {
        this.role = role;
    }

    @Override
    public boolean move() {
        System.out.println("当前为战斗状态不能移动...");
        return false;
    }

    @Override
    public int fight() {
        if (role instanceof MageRole){
            System.out.println("攻击类型：-普通攻击- -魔法攻击-");
            Scanner scanner = new Scanner(System.in);
            String fight = scanner.nextLine();

            if (fight.equals("普通攻击")){
                role.Attack();

                return (int) role.getAtk();
            } else if (fight.equals("魔法攻击")){
                role.skillAttack();
                role.setMp(role.getMp()-((MageRole) role).getMagicBehavior().getMp());

                return (int) ((MageRole) role).getMagicBehavior().getEffect();
            }
        } else if (role instanceof WarriorRole){
            System.out.println("-普通攻击- -武器攻击-");
            Scanner scannerW = new Scanner(System.in);
            String fight = scannerW.nextLine();
            role.Attack();

            return (int) ((WarriorRole) role).getWeaponBehavior().getAtk();
        }

        return 0;
    }

    @Override
    public void fightState(String s) {

    }

    @Override
    public void Result() {
        if (role.getHp() >=0 && role.getHp() <= 20){
            System.out.println("战斗胜利");
            role.setDieRightState();
        } else if(role.getHp() > 20 && role.getHp() <= 90){
            System.out.println("战斗胜利");
            role.setMoveState();
        } else {
            System.out.println("战斗失败");
            role.setDeadState();
        }
    }
}

//        if (role.getState() instanceof FightState){
//
//        }
package finalexam.state;

import finalexam.role.Role;

import java.util.Scanner;

/**
 * @Author PoX21s
 * @Date: 2021/12/4 12:28
 * @Version 1.0
 */

public class InitState implements State{
    private Role role;

    public InitState(Role role) {
        this.role = role;
    }

    @Override
    public boolean move() {
        Scanner moveSc = new Scanner(System.in);

        System.out.println("W - 向上移动");
        System.out.println("S - 向下移动");
        System.out.println("A - 向左移动");
        System.out.println("D - 向右移动");

        String move = moveSc.nextLine();
        switch (move) {
            case "A":
                role.setY(role.getY() - 1);
                break;
            case "D":
                role.setY(role.getY() + 1);
                break;
            case "W":
                role.setX(role.getX() - 1);
                break;
            case "S":
                role.setX(role.getX() + 1);
                break;
        }
        return true;
    }

    @Override
    public int fight() {
        return 0;
    }

    @Override
    public void fightState(String s) {
        if(s.equals("y")){
            role.setFightState();
        }
    }

    @Override
    public void Result() {
        if (role.getHp() >=0 && role.getHp() <= 20){
            role.setDieRightState();
        } else if(role.getHp() > 20 && role.getHp() <= 90){
            role.setMoveState();
        } else {
            role.setDeadState();
        }
    }
}
package finalexam.state;

import finalexam.role.Role;

import java.util.Scanner;

/**
 * @Author PoX21s
 * @Date: 2021/12/4 13:00
 * @Version 1.0
 */

public class MoveState implements State{
    private Role role;

    public MoveState(Role role) {
        this.role = role;
    }


    @Override
    public boolean move() {
        Scanner moveSc = new Scanner(System.in);

        System.out.println("W - 向上移动");
        System.out.println("S - 向下移动");
        System.out.println("A - 向左移动");
        System.out.println("D - 向右移动");

        String move = moveSc.nextLine();
        switch (move) {
            case "A":
                role.setY(role.getY() - 1);
                break;
            case "D":
                role.setY(role.getY() + 1);
                break;
            case "W":
                role.setX(role.getX() - 1);
                break;
            case "S":
                role.setX(role.getX() + 1);
                break;
        }
        return true;
    }

    @Override
    public int fight() {
        System.out.println("当前为移动状态，不能进入战斗...");
        return 0;
    }

    @Override
    public void fightState(String s) {

    }

    @Override
    public void Result() {
        if (role.getHp() >=0 && role.getHp() <= 20){
            role.setDieRightState();
        } else if(role.getHp() > 20 && role.getHp() <= 90){
            role.setMoveState();
        } else {
            role.setDeadState();
        }
    }
}
package finalexam.state;

/**
 * @Author PoX21s
 * @Date: 2021/12/4 12:27
 * @Version 1.0
 */
/*
* 状态接口，定义基本的方法和状态切换
* */
public interface State {
    // 玩家移动，根据移动到地图的位置进行状态模式的切换
    boolean move();
    // 玩家进行战斗
    int fight();
    // 切换为战斗状态
    void fightState(String s);
    // 状态切换为濒死、死亡、初始化或移动状态
    void Result();
}

/*Client*/

package finalexam;

import finalexam.factory.MageRoleFactory;
import finalexam.factory.RoleFactory;
import finalexam.factory.WarriorRoleFactory;
import finalexam.role.Role;
import java.util.Scanner;

/**
 * @Author PoX21s
 * @Date: 2021/12/4 11:45
 * @Version 1.0
 */

public class Client {
    private static Role role; // 每局游戏的角色
    private static RoleFactory rf; // 角色工厂
    static String[][] map = new String[3][3]; // 游戏地图
    static boolean flag = true; // 游戏结束/进行判断标志位

    // 游戏初始化
    static {
        try {
            initGame();
            creatMap();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 主程序
    public static void main(String[] args) throws Exception {
        Client client = new Client();
        /*
        * 开始游戏，直到玩家选择退出。
        * */
        while (flag){
            client.action();
        }
    }

    // 初始化游戏加载
    public static void initGame() throws Exception {
        System.out.println("======欢迎来到 - xxxxxx======");
        System.out.println("游戏分为法师和战士，当前游戏角色列表为：");
        System.out.println("====法师===");
        System.out.println("法师 - 火球法师");
        System.out.println("法师 - 雷电法师");
        System.out.println("法师 - 治疗法师");
        System.out.println("法师 - 强力法师");
        System.out.println();
        System.out.println("====战士====");
        System.out.println("战士 - 冲锋战士");
        System.out.println("战士 - 独立战士");
        System.out.println("战士 - 快枪战士");
        System.out.println("战士 - 无畏战士");
        System.out.println();
        System.out.println("请输入您创建的角色类别：");
        Scanner sc = new Scanner(System.in);
        String roleType = sc.nextLine();
        /*
        * 根据类型选择相应的工厂，然后进行角色创建返回。
        * */
        if (roleType.equals("法师")){
            rf = new MageRoleFactory();
        }else if (roleType.equals("战士")){
            rf = new WarriorRoleFactory();
        }

        System.out.println("请输入您想扮演角色类别的名称：");
        String roleTypeName = sc.nextLine();
        System.out.println("请输入您在游戏中的名字：");
        String roleName = sc.nextLine();
        System.out.println("请稍后，正在为您生成角色....");

        role = rf.getRole(roleTypeName, roleName);

        System.out.println("角色生成成功...");
        System.out.println();
        System.out.println(role.toString());
    }

    // 创建地图
    public static void creatMap(){
        map[0][0] = "商家";
        map[0][1] = "空地";
        map[0][2] = "家 ";
        map[1][0] = "怪一";
        map[1][1] = "起点";
        map[1][2] = "怪二";
        map[2][0] = "城市";
        map[2][1] = "怪三";
        map[2][2] = "空地";
    }

    // 输出地图
    public static void printMap(){
        for (String[] chars : map) {
            for (String aChar : chars) {
                System.out.printf("%5s",aChar);
            }
            System.out.println();
        }
    }

    // 玩家操作
    public void action(){
        System.out.println();
        Scanner sc = new Scanner(System.in);
        System.out.println("操作：-移动- -查看人物信息- -查看地图- -恢复- -退出游戏-");

        String action = sc.nextLine();

        switch (action){
            case "移动":
                roleMove();
                break;
            case "查看人物信息":
                System.out.println("人物当前位置为： "+map[role.getX()][role.getY()]);
                System.out.println();
                System.out.println(role.toString());
                break;
            case "退出游戏":
                flag = false;
                System.out.println("再见~~");
                break;
            case "查看地图":
                printMap();
                break;
            case "恢复":
                seeState();
                role.getState().Result();
                break;
            default:
                System.out.println("无法识别，请输入正确操作。");
                break;
        }
    }

    // 血量恢复
    public void seeState(){
        if (role.getHp() >= 10){
            role.setHp(role.getHp()+50);
            System.out.println("已恢复50点生命值，当前生命值为： "+role.getHp());
        } else if (role.getHp() <= 0){
            System.out.println("您已死亡，无法恢复状态，请重新开始游戏");
        }
        role.getState().Result();
    }

    // 玩家移动
    public void roleMove(){
        if (role.move())
            select();
    }

    // 进一步选择
    public void select(){
        System.out.println("当前位置为： "+map[role.getX()][role.getY()]);
        switch (map[role.getX()][role.getY()]) {
            case "怪一": {
                System.out.println("是否进入战斗？（y/n)");
                Scanner scanner = new Scanner(System.in);
                String s = scanner.nextLine();

                if (s.equals("y")) {
                    role.getState().fightState(s);
                    fightGA();
                } else {
                    role.getState().fightState(s);
                    action();
                }
                break;
            }
            case "怪二": {
                System.out.println("是否进入战斗？（y/n)");
                Scanner scanner = new Scanner(System.in);
                String s = scanner.nextLine();

                if (s.equals("y")) {
                    role.getState().fightState(s);
                    fightGB();
                } else {
                    role.getState().fightState(s);
                    action();
                }
                break;
            }
            case "怪三": {
                System.out.println("是否进入战斗？（y/n)");
                Scanner scanner = new Scanner(System.in);
                String s = scanner.nextLine();

                if (s.equals("y")) {
                    role.getState().fightState(s);
                    fightGC();
                } else {
                    role.getState().fightState(s);
                    action();
                }
                break;
            }
            default:
                action();
                break;
        }
    }

    // 玩家战斗
    public int fight(){
       return role.fight();
    }

    // 怪物
    public void fightGA(){
        int hp = 30;
        System.out.println("进入战斗~");
        while (hp > 0 && role.getHp() > 0){
            System.out.println("怪一生命值："+hp);
            System.out.println("怪一发动攻击，造成10点伤害");
            role.setHp(role.getHp() - 10);
            System.out.println("轮到您发动攻击，请选择：");
            //玩家战斗，发动攻击
            int fight = fight();
            hp -= fight;
        }
        role.getState().Result();
    }

    public void fightGB(){
        System.out.println();
        int hp = 1000;
        System.out.println("进入战斗~");
        while (hp > 0 && role.getHp() > 0){
            System.out.println();
            System.out.println("怪二当前生命值："+hp);
            System.out.println("怪二发动攻击，造成50点伤害");
            role.setHp(role.getHp() - 50);
            System.out.println();
            System.out.println("轮到您发动攻击，请选择：");
            int fight = fight();
            hp -= fight;
        }
        role.getState().Result();
    }

    public void fightGC(){
        System.out.println();
        int hp = 120;
        System.out.println("进入战斗~");
        while (hp > 0 && role.getHp() > 0){
            System.out.println();
            System.out.println("怪三当前生命值："+hp);
            System.out.println("怪三发动攻击，对您造成40点伤害");
            role.setHp(role.getHp() - 40);
            System.out.println();
            System.out.println("轮到您发动攻击，请选择：");
            int fight = fight();
            hp -= fight;
        }
        role.getState().Result();
    }
}

/*        if (role.getState() instanceof FightState){
            if (role instanceof MageRole){
                System.out.println("攻击类型：-普通攻击- -魔法攻击-");
                Scanner = new Scanner(System.in);
                String fight = scanner.nextLine();

                if (fight.equals("普通攻击")){
                    role.Attack();

                    return (int) role.getAtk();
                } else if (fight.equals("魔法攻击")){
                    role.skillAttack();
                    role.setMp(role.getMp()-((MageRole) role).getMagicBehavior().getMp());
                    return (int) ((MageRole) role).getMagicBehavior().getEffect();
                }
            } else if (role instanceof WarriorRole){
                System.out.println("-普通攻击- -武器攻击-");
                Scanner scannerW = new Scanner(System.in);
                String fight = scannerW.nextLine();
                role.Attack();

                return (int) ((WarriorRole) role).getWeaponBehavior().getAtk();
            }
        } else {
            State state = role.getState();
            state.fight();
        }

        return 0;*/
//        role.move();
//        if (role.getState() instanceof MoveState || role.getState() instanceof InitState)
//            select();
/*// 战斗结果
public void fightResult(){
    if (role.getHp() > 0){
        System.out.println("赢得战斗！");
    }else {
        System.out.println("战斗失败。");
        System.out.println("您已死亡请重新开始游戏。");
    }
    role.getState().fightResult();
}*/
/*    // 状态判定
 *//*    public void stateIf(){
        if (role.getHp() >=0 && role.getHp() <= 20){
            role.setDieRightState();
        } else if(role.getHp() > 20 && role.getHp() <= 90){
            role.setMoveState();
        } else {
            role.setDeadState();
        }
    }*/

/*Test*/

package finalexam;

import finalexam.factory.MageRoleFactory;
import finalexam.role.FireballMagic;
import finalexam.role.MageRole;
import finalexam.role.Role;
import finalexam.state.FightState;

/**
 * @Author PoX21s
 * @Date: 2021/12/15 15:19
 * @Version 1.0
 */

public class Test {
    public static void main(String[] args) {
//        FightState = new FightState();
//        fightState.fight();
    }
}

相关推荐

设计模式——简单工厂模式

草原小黄河 191 0 0

【设计模式】简单工厂模式

静守幸福 214 0 0

设计模式_简单工厂模式

Java旺 181 0 0

设计模式-简单工厂模式

橙子好吃吗 99 0 0

设计模式~简单工厂模式

googlefrank 73 0 0

设计模式：简单工厂模式

生态人 20 0 0

游戏开发设计模式 桥模式

b91bff6ffdb5 41 0 0

设计模式简单分类

北邮郭大宝 73 0 0

简单工厂设计模式

尤克乔乔 37 0 0

【设计模式系列】简单工厂模式

殇感故事 11 0 0

精彩评论（0）

0 0 举报