宝可梦小游戏_Java_控制端——总结
宝可梦&伏魔录 小游戏_Java_控制端：小总结
文章目录
- 宝可梦&伏魔录 小游戏_Java_控制端：小总结
- 前言
- 一、简述
- 二、宝可梦项目
-
- 1.设计思想
- 2.宝可梦项目总结
-
-
- 1. 前期开发设计
- 2. 编程设计
- 3. 测试
-
- 三、伏魔录小游戏项目
-
- 1、编程思想
- 2、所悟知识
- 四、最终总结
前言
此文档主要是作为Java初学者的第一次小项目，虽然项目还不够完善，但是想在这里做一下总结。也顺便梳理以下最近的学习，对自己整个的学习自我认知一下。
可能现在作者水平有限，但是确实初学者当下比较真实的想法与认知，期望各位创客能多加以指点。
一、简述
宝可梦项目是在还不是特别了解面向对象思想的时候，编写的项目。
但是，在此次项目之后，又通过面向对象的思想学习编写了伏魔录小游戏。
本文主要是通过开发两次项目的总结与经验做对比。比对出相应的问题与应该改进的地方。
二、宝可梦项目
1.设计思想
玩家首先获得一个宝可梦，有一定自身的属性和金钱；之后通过去不同地图从而进行商品的交易和打怪升级（其中也包含捕捉新的宝可梦等基本技能）。
总而言之，就是一个类似于宝可梦的超简化版小游戏 （控制台输入输出）。
尽管宝可梦版本还有很多不完善的地方，但是基本的功能运行是没有问题的。
整个项目的代码较为冗余，因此，只选择了Player类中的主要方法来展示，如下代码。
//遭遇野怪
public void encounter(String monster) {
int l = 0;
if (monster.equals("boss")) {
pokemons = boss;
System.out.println("你嚣张的向道馆馆主发起了挑战。你大叫一声：呔！ 你敢应战么？");
System.out.println("道馆馆主抬起眼眸，轻蔑的瞟了你一眼：GO first!");
System.out.println("你巴拉巴拉精灵袋：");
showAll();//打印精灵
System.out.println("————— @ ————");
System.out.println(" || @@@@@ ||");
System.out.println(" || @@@@@ ||");
System.out.println(" ||_______||");
System.out.println("你从袋子里选出来了一个小精灵：");
int chioce = scanner.nextInt() - 1;
show(chioce);//展示选择的宝可梦
System.out.println("就是你了，宝可梦！||");
pokemons.show();
while (l == 0) {
l = interfaces(monster, chioce);
}
} else if (monster.equals("monster")) {
pokemons = createmonster();//调用
System.out.println("野怪突然闪现，吓你一跳！");
System.out.println("哎嘿？前面那是什么？难道是..." + pokemons.pokemonName + "?!!");
System.out.println("这下可太好了，这种小怪小力的，用来训练最好了！@_@，去吧！宝可梦！");
int chioce = scanner.nextInt() - 1;
while (chioce < 0 || chioce > 3 || this.pokemon[chioce].pokemonName == null) {
System.out.println("【NPC】你有吗?不，你没有!");
chioce = scanner.nextInt() - 1;
}
while (!this.pokemon[chioce].pokemonStatus) {
System.out.println("【NPC】你的宝可梦真实太菜了！竟然打不过？！你还有其他的宝可梦么？有就快上！别怂！");
chioce = scanner.nextInt() - 1;
}
show(chioce);//我拥有的宝可梦
pokemons.show();//小怪 宝可梦
while (l == 0) {
l = interfaces(monster, chioce);
}
}
}
public int interfaces(String monster, int chioces) {
System.out.println("+--------------+");
System.out.println("|1.战斗 2.物品|");
System.out.println("|3.捕获 4.逃跑|");
System.out.println("+--------------+");
System.out.print("请选择你要进行的操作：");
int choice = scanner.nextInt();
while (choice > 4 || choice < 1) {
System.out.println("不会吧，这么简单的操作都不会?重来重来！");
choice = scanner.nextInt();
}
switch (choice) {
//战斗
case 1:
return battle(chioces);
//物品
case 2:
openpackage(monster);
break;
//捕获
case 3:
switch (capture()) {
//捕获失败直接结束
case -1:
return -1;
//精灵球不足或放弃捕捉
case 0:
interfaces(monster, choice);
break;
//捕捉成功
case 1:
for (int i = 0; i < 4; i++) {
if (this.pokemon[i] == null) {
this.pokemon[i] = pokemons;
break;
} else if (i == 3) {
System.out.println("你这瘦弱的身板只能携带四只，你要放弃你原有的宝可梦吗?（y/n）");
String z = scanner.next();
if (z.equals("y")) {
//放弃
System.out.println("好吧，你这个喜新厌旧的家伙");
System.out.println("你要放弃哪一只?");
System.out.println("1." + pokemon[0].pokemonName);
System.out.println("2." + pokemon[1].pokemonName);
System.out.println("3." + pokemon[2].pokemonName);
System.out.println("4." + pokemon[3].pokemonName);
int v = scanner.nextInt() - 1;
pokemon[v] = pokemons;
} else {
//不放弃
System.out.println("看来你还是喜欢原来的,好吧那就这样吧");
}
}
}
return 2;
}
break;
//逃跑
case 4:
System.out.println("你个s货，竟然跑了！");
return -1;
}
return 0;
}
//战斗
public int battle(int chioces) {
int attack = 0;
if (pokemons.pokemonStatus && pokemon[chioces].pokemonStatus) {
System.out.println("+——宝可梦技能——+");
System.out.println("+-------------------------------+");
System.out.println("1." + this.pokemon[chioces].attackSkill1 + " 2." + this.pokemon[chioces].attackSkill2);
System.out.println("3." + this.pokemon[chioces].attackSkill3 + " 4." + this.pokemon[chioces].specSkill);
System.out.println("+-------------------------------+");
System.out.print("【Select】选择你要进行的操作：");
int choice1 = scanner.nextInt();
switch (choice1) {
case 1:
System.out.println("你使用了" + this.pokemon[chioces].attackSkill1);
attack = this.pokemon[chioces].attackSkill1Value + this.pokemon[chioces].pokemonAttack - pokemons.pokemonDefend;
if (attack > 0) {
pokemons.pokemonhp -= attack;
}
this.pokemon[chioces].attackSkill1Value++;
break;
case 2:
System.out.println("你使用了" + this.pokemon[chioces].attackSkill2);
attack = this.pokemon[chioces].attackSkill2Value + this.pokemon[chioces].pokemonAttack - pokemons.pokemonDefend;
if (attack > 0) {
pokemons.pokemonhp -= attack;
}
this.pokemon[chioces].attackSkill2Value++;
break;
case 3:
System.out.println("你使用了" + this.pokemon[chioces].attackSkill3);
attack = this.pokemon[chioces].attackSkill3Value + this.pokemon[chioces].pokemonAttack - pokemons.pokemonDefend;
if (attack > 0) {
pokemons.pokemonhp -= attack;
}
this.pokemon[chioces].attackSkill3Value++;
break;
case 4:
System.out.println("你使用了" + this.pokemon[chioces].specSkill);
attack = this.pokemon[chioces].specSkillValue + this.pokemon[chioces].pokemonAttack - pokemons.pokemonDefend;
if (attack > 0) {
pokemons.pokemonhp -= attack;
}
this.pokemon[chioces].attackSkill1Value++;
break;
}
//敌对生物随机技能
int monsterSkill = 0;
switch (random.nextInt(4)) {
case 0:
monsterSkill = pokemons.attackSkill1Value;
break;
case 1:
monsterSkill = pokemons.attackSkill2Value;
break;
case 2:
monsterSkill = pokemons.attackSkill3Value;
break;
case 3:
monsterSkill = pokemons.specSkillValue;
break;
}
int a = monsterSkill + pokemons.pokemonAttack - this.pokemon[chioces].pokemonDefend;
if (a > 0) {
this.pokemon[chioces].pokemonhp -= a;
}
System.out.println("【Tips】您目前的生命值还有：" + this.pokemon[chioces].pokemonhp);
if (this.pokemon[chioces].pokemonhp <= 0) {
this.pokemon[chioces].pokemonStatus = false;
} else if (pokemons.pokemonhp <= 0) {
pokemons.pokemonStatus = false;
}
}
if (pokemons.pokemonStatus == false) {
pokemons.pokemonStatus = true;
pokemons.pokemonhp = pokemons.pokemonHp;
System.out.println("你打到了对手");
this.money += 100;
return 1;
} else if (pokemon[chioces].pokemonStatus == false) {
System.out.println("【NPC】虽然你还有可以出战的宝可梦，但你已经输了,真可惜，我的勇士！你还需要历练吖！！！");
return -1;
}
return 0;
}
//打开物品
public void openpackage(String monster) {
//非战斗状态无法使用
System.out.println("1.精灵球.......x" + this.pokeBall);
System.out.println("2.疗伤药.......x" + this.medicine);
//战斗状态无法使用
System.out.println("3.返回");
System.out.print("【Tips】请选择你要进行的操作：");
int choice = scanner.nextInt();
while (choice > 3 || choice < 1) {
System.out.println("【Tips】输入错误");
choice = scanner.nextInt();
}
switch (choice) {
//精灵球
case 1:
System.out.println("【Tips】当前页面无法操作");
break;
//疗伤药
case 2:
if (this.medicine > 0) {
System.out.println("【NPC】选择你要治疗的宝可梦");
showAll();//打印精灵
int a = scanner.nextInt() - 1;
if (this.pokemon[a] != null) {
System.out.println("【NPC】你治疗了你的宝可梦");
this.medicine--;
this.pokemon[a].pokemonhp += 20;
} else {
System.out.println("【NPC】你没有这只宝可梦，就想使用它？！你怕是在做梦。");
}
} else {
System.out.println("【NPC】你的药品不足吖！");
}
break;
//返回
case 3:
encounter(monster);
}
}
//捕获宝可梦
public int capture() {
if (pokeBall > 0) {
this.pokeBall--;
for (int i = 0; i < 5; i++) {
// int a = 1;
if ((int) Math.random() * 5 == 1) {
System.out.println("【NPC】运气不错，被你捉到了@");
return 1;
} else {
System.out.println("【NPC】你这手气有点黑");
return 0;
}
}
System.out.println("【NPC】我可以确认你是非洲来的，遇到好捕捉的精灵你都捉不到...我的勇士，你不行吖");
return -1;
} else {
System.out.println("【NPC】不是吧不是吧，这就用完啦?随身带着几十个精灵球这不是常识吗?");
return 0;
}
}
//随机生成野怪
public Pokemon createmonster() {
int a = random.nextInt(9);
switch (a) {
case 0:
Hitokage hitokage = new Hitokage();
pokemons = hitokage;
break;
case 1:
Zenigame zenigame = new Zenigame();
pokemons = zenigame;
break;
case 2:
Fushigidane fushigidane = new Fushigidane();
pokemons = fushigidane;
break;
case 3:
Butterfree butterfree = new Butterfree();
pokemons = butterfree;
break;
case 4:
Dagutorio dagutorio = new Dagutorio();
pokemons = dagutorio;
break;
case 5:
Fudin fudin = new Fudin();
pokemons = fudin;
break;
case 6:
Isitsubute isitsubute = new Isitsubute();
pokemons = isitsubute;
break;
case 7:
Pikachuu pikachuu = new Pikachuu();
pokemons = pikachuu;
break;
case 8:
Rokon rokon = new Rokon();
pokemons = rokon;
break;
}
return pokemons;
}
2.宝可梦项目总结
代码如下（示例）：
本次项目的开发问题与总结 需要分为以下几点：
1. 前期开发设计
整个项目的策划与前期设计是很重要的。
首先，有关宝可梦项目的整个设计在前期主要是有一个大概的流程，某些对象和属性。虽然小组内也有一定的规范与参考文档，但可能是因为第一次做，因此，后续很大的问题就出现了。（例如，开法过程中的规范不统一，合并很有难度；开发过程功能想到就加，增大了开发的难度等等。）
所以，前期小组合作开发的规范性、功能等文档，一定要定好。若有修改需要标明。总之，文档是很有必要的。
2. 编程设计
本次编程设计主要是面向过程的思想。
由于小组对于整个面向对象的思想均不太熟悉，造成在面向对象后的思想中穿插着面向过程的思想。所以整个看下来逻辑会稍微有点乱。
所以，面向对象的设计思想是需要多实践、多练、多体会的。项目成员的分工也是有不妥的地方。
因此，小组明确的分工与相应的合作还是需要再体会以及磨练一下。
3. 测试
整个测试的过程主要是由测试人员完成。
但是测试的过程中发现很多代码不够可读。也有一些已知的BUG需要进行修复。
三、伏魔录小游戏项目
此项目主要是包含简单的功能的实现。最终的目的不是为了写出一个完整的小游戏。主要是通过运用面向对象的思想学习并编写一个小游戏。
此项目的分析可能更多的是在宝可梦项目的基础上，侧重于面向对象的思想的学习。
1、编程思想
首先，项目的小组分工比较重要。项目成员清晰、明确的分工会让整个项目的开发周期达到最优。
其次，开发前期的设计很重要。主要包括：需求设计、可行性分析、功能模块是否符合逻辑、规整文档、项目工程与接口等的定义规范等等。
之后，目前对于初学者，最重要的可能就是代码的编写了。可能对于开发熟练的人员，这个不成问题。但是对于初学者来说，一是开发的思想意识还不足以达到相应要求。二是对于整个java的运用还不够熟练。可能很多人说练练就可以了。确实是这样的，但是从不熟练到熟练的过程不是仅仅依靠练习，我目前觉得初学者需要练习+反思+练习+总结。
最后，测试也是一项很重要的工作。（本次主要参与的测试不足以令我悟出新的感悟，在此，就不多说了。）
下次，一定会好好参与一下测试工作。
2、所悟知识
（1）开发中，首先先创建一些需要的对象的类。该类需要什么属性、方法（方法的具体逻辑可以先不实现、做好注释，后续需要再填充）等。（其中很重要的就是要做好注释！）。
（2） 什么时候可以进行封装，什么时候不需要封装。根据设计的类，该封装的属性使用get、set方法进行获取及设置相应的私有属性的值。
（3） 设计时需要判断哪些类是需要被继承的。一般来说，子类无拓展功能，尽量不使用继承的方式。 还有需要注意的一点是：子类不能缩小父类方法的访问权限。如果父类是private的话， 子类是不可以直接使用的，必须通过get方法去获取。
（4） 可能目前比较难编写的是一个类中包含有其他类的对象。目前笔者对于这个了解的还不算清晰，因此，先不在这里写一些总结。
（5） 多态的运用。就例如伏魔录这个小项目。可能中途会遇到很多不同身份的NPC。这时，写一个父类NPC，包含有say()的方法，但是say()的语句不一样时，此时在子类中的方法传入的参数声明的对象的类型可以声明为父类NPC的类型，传入的对象为子类的特定NPC。如下代码。
//玩家类
public void visit(Npc villiagerA) {
villiagerA.say();
}
//村民类
public class Villiager extends Npc {
public void say(){
System.out.println("你好，我是村民");
}
}
多态就是同一个接口，使用不同的实例而执行不同操作。
例如：
（1）多态成员变量：编译运行看左边
Npc villiager=new Villiager();
System.out.println(villiager.name);//只能取到父类中的值
（2）多态成员方法：编译看左边，运行看右边
Npc villiager=new Villiager();
System.out.println(villiager.say());
//villiager的门面类型是NPC,但实际类型是Villiager,所以调用的是重写后的方法。
四、最终总结
其实，整个来说。这次的总结比较零散。有一种学到了很多，但是记录下来又是另一回事。
所以，在总结这方面，还是需要多写多练。最主要的还是记录一下本次小项目完成后的整个感受以及一些比较触动我的收获。
如果有创客希望看一下项目的代码，共同学习进步。可以私信我留言吖~
最后贴一小部分，我认为比较好的代码。
package com.dell.Professions;
/*技能类*/
public class Skill {
// 技能名称
private String skillName;
// 技能伤害
private int skillDamage;
// 耗蓝量
private int manaCost;
//学习成本
private int goldCost;
public Skill(String skillName,int skillDamage, int manaCost,int goldCost){
this.skillName = skillName;
this.skillDamage = skillDamage;
this.manaCost = manaCost;
this.goldCost = goldCost;
}
public Skill(String skillName,int skillDamage, int manaCost){
this.skillName = skillName;
this.skillDamage = skillDamage;
this.manaCost = manaCost;
}
public String getSkillName() {
return skillName;
}
public Skill setSkillName(String skillName) {
this.skillName = skillName;
return this;
}
public int getSkillDamage() {
return skillDamage;
}
public Skill setSkillDamage(int skillDamage) {
this.skillDamage = skillDamage;
return this;
}
public int getManaCost() {
return manaCost;
}
public Skill setManaCost(int manaCost) {
this.manaCost = manaCost;
return this;
}
public int getGoldCost() {
return goldCost;
}
public Skill setGoldCost(int goldCost) {
this.goldCost = goldCost;
return this;
}
}
package com.dell.characters;
import com.dell.Items.Item;
import com.dell.Items.Potion;
import com.dell.locations.Field;
import com.dell.locations.Nowhere;
import com.dell.locations.PrimiaryVilliage;
import com.dell.Professions.Magician;
import com.dell.Professions.Profession;
import com.dell.Professions.Skill;
import com.dell.Professions.Warrior;
import java.util.Scanner;
/*
* 该类是游戏玩家类
* 对象
*
* */
public class Player {
//名字， 封装
private String name="张三";
//攻击力
private int attack = 10;
//当前血量
private int health = 50;
//最大血量
private int maxHealth = 50;
//当前蓝量
private int mana = 100;
//最大蓝量
private int maxMana = 100;
//当前经验值
private int exp = 0;
//最大经验值
private int maxExp = 10;
// 最大经验值的增长
private int maxExpGrowth = 10;
//防御力
private int defense = 10;
//当前金钱
private int gold = 100;
//等级
private int level = 1;
// 物品栏
private Item[] items = new Item[10];
// 技能栏
private Skill[] skills = new Skill[5];
// 职业
private Profession profession;
// 设计方法
// 打怪
public boolean attack(Enemy enemy,Scanner scanner){
boolean flag = true;
System.out.println(enemy.enemyName +" "+ enemy.health + " "+enemy.mana);
while(enemy.health >0 && this.health > 0){
System.out.println("请选择操作：");
System.out.println("1、攻击");
System.out.println("2、施法");
// System.out.println("3、查看对方状态");
int choice = scanner.nextInt();
if(choice >0 && choice <3){
if(choice == 1){
if(this.defense < enemy.attack){
this.health = this.health - enemy.attack + this.defense;
}
if(enemy.defense < this.attack){
enemy.health = enemy.health - this.attack + enemy.defense;
}
}else if(choice == 2){
System.out.println("请选择技能:");
int i = 0;
for(; i < this.skills.length;i++){
if(this.skills[i] != null){
System.out.println((i+1)+"、"+this.skills[i].getSkillName());
}else {
break;
}
}
int skillChoice = scanner.nextInt();
if(skillChoice >0 && skillChoice < i+2){
int skillManaCost = this.skills[skillChoice-1].getManaCost();
if(this.mana > skillManaCost){
enemy.health = enemy.health - this.skills[skillChoice-1].getSkillDamage();
this.mana = this.mana - skillManaCost;
}else{
System.out.println("魔法不足，进行普通攻击");
if(enemy.defense < this.attack){
enemy.health = enemy.health - this.attack + enemy.defense;
}
}
if( enemy.mana > enemy.skills[0].getManaCost()){
this.health = this.health - enemy.skills[0].getSkillDamage();
enemy.mana = enemy.mana - enemy.skills[0].getManaCost();
}else {
if(this.defense < enemy.attack){
this.health = this.health - enemy.attack + this.defense;
}
}
}
}
}
}
//打印 自己的信息
System.out.println(this.name + "剩余血量为" + this.health + "剩余蓝量为" + this.mana);
System.out.println(enemy.enemyName +"剩余血量为" + enemy.health + "剩余蓝量为" + enemy.mana);
// 打印 怪物的信息
if(this.health > 0){
return flag;
}else {
return false;
}
}
// 升级
public void upgrade(){
this.level++;
this.maxHealth += this.profession.healthGrowth;
this.maxMana += this.profession.manaGrowth;
this.maxExp += this.level*this.maxExpGrowth;
this.defense += this.profession.defenseGrowth;
this.attack += this.profession.attackGrowth;
this.health = this.maxHealth;
this.mana = this.maxMana;
System.out.println("恭喜升级");
}
// 买东西
public void shop(PrimiaryVilliage primiaryVilliage, Scanner scanner){
BusinessMan businessMan = primiaryVilliage.getBusinessman();
int i = businessMan.showItems();
System.out.println("请选择购买的物品");
int choice = scanner.nextInt();
if(choice > 0 && choice < i ){
// 第一步，玩家的金币会减少
this.setGold(this.getGold() - businessMan.getItemByIndex(choice).itemGold);
// 第二步，玩家的物品会增加
this.addItem(businessMan.getItemByIndex(choice));
// 第三步，商人的物品会减少
businessMan.removeItem(choice);
}
//显示物品
for(int j = 0 ; j <this.items.length ;j++){
if(items[j] != null){
System.out.println(items[j].itemName);
}
}
System.out.println("******************");
for(int j = 0 ; j < businessMan.items.length; j++){
if(businessMan.items[j] != null){
System.out.println(businessMan.items[j].itemName);
}
}
}
public void addItem(Item item){
int index = 0;
boolean flag = false;
for(int i = 0 ; i < this.items.length ; i++){
if(items[i] == null){
flag = true;
index = i;
break;
}
}
if(flag) {
this.items[index] = item;
}else {
System.out.println("物品栏已满");
}
}
// 使用物品
public void use(){
}
// 学技能
public void learnSkill(Scanner scanner){
if(this.profession == null){
System.out.println("请先选择职业");
return;
}else {
// 展示可以学习哪些技能
Skill[] skills = this.profession.skillSet;
for(int i = 0 ; i < skills.length;i++){
if(skills[i] != null) {
System.out.println((i + 1) + "、" + skills[i].getSkillName() + " " + skills[i].getGoldCost());
}else {
break;
}
}
System.out.println("请选择需要学习的技能");
int choice = scanner.nextInt();
if(choice >= 0 && choice<=skills.length&&skills[choice-1] != null ){
// 判断选择的技能是否已经拥有
boolean flag = true;
for(int i = 0 ; i<this.skills.length;i++){
if(skills[choice-1]!=null && this.skills[i] != null && skills[choice-1].getSkillName() == this.skills[i].getSkillName()){
System.out.println("该技能已掌握");
flag = false;
break;
}
}
if(flag){
this.getNewSkill(skills[choice-1],scanner);
}
}
}
}
public void getNewSkill(Skill skill,Scanner scanner){
int index = 0;
boolean flag = false;
for(int i = 0 ; i< this.skills.length;i++){
if(this.skills[i] == null){
flag = true;
index = i;
break;
}
}
if(flag) {
System.out.println("确定要学习吗？价格是:" + skill.getGoldCost());
String s = scanner.next();
if(s.equalsIgnoreCase("y")) {
int skillGold = skill.getGoldCost();
if (this.getGold() > skillGold) {
this.setGold(this.getGold() - skillGold);
this.skills[index] = skill;
} else {
System.out.println("穷鬼，没钱学什么技能");
}
}
}else{
System.out.println("技能槽已满");
}
}
public Player(){
}
// 构造器
public Player(String name){
this.name = name;
// 给角色初始物品
this.items[0] = new Potion("恢复药剂",10);
// 给角色初始技能
this.skills[0] = new Skill("撞击",10,2,0);
}
public int getAttack() {
return attack;
}
public Player setAttack(int attack) {
this.attack = attack;
return this;
}
public Item[] getItems() {
return items;
}
public Player setItems(Item[] items) {
this.items = items;
return this;
}
public Skill[] getSkills() {
return skills;
}
public Player setSkills(Skill[] skills) {
this.skills = skills;
return this;
}
public Profession getProfession() {
return profession;
}
public Player setProfession(Profession profession) {
this.profession = profession;
return this;
}
public int getLevel() {
return level;
}
public Player setLevel(int level) {
this.level = level;
return this;
}
public String getName() {
return name;
}
// public Player setName(String name) {
// this.name = name;
// return this;
// }
public void setName(String name){
this.name = name;
}
public int getHealth() {
return health;
}
public Player setHealth(int health) {
this.health = health;
return this;
}
public int getMaxHealth() {
return maxHealth;
}
public Player setMaxHealth(int maxHealth) {
this.maxHealth = maxHealth;
return this;
}
public int getMana() {
return mana;
}
public Player setMana(int mana) {
this.mana = mana;
return this;
}
public int getMaxMana() {
return maxMana;
}
public Player setMaxMana(int maxMana) {
this.maxMana = maxMana;
return this;
}
public int getExp() {
return exp;
}
public Player setExp(int exp) {
this.exp = exp;
return this;
}
public int getMaxExp() {
return maxExp;
}
public Player setMaxExp(int maxExp) {
this.maxExp = maxExp;
return this;
}
public int getDefense() {
return defense;
}
public Player setDefense(int defense) {
this.defense = defense;
return this;
}
public int getGold() {
return gold;
}
public Player setGold(int gold) {
this.gold = gold;
return this;
}
public void visit(Older older) {
older.say();
older.offerItems(this);
}
public void visit(Npc villiagerA) {
villiagerA.say();
}
// 选择职业
public void chooseProfession(int professionChoice) {
if(professionChoice == 1){
this.profession = new Warrior();
}else if(professionChoice == 2){
this.profession = new Magician();
}
}
public void heal() {
this.health = this.maxHealth;
this.mana = this.maxMana;
}
/**
* 多态的运用，玩家可以在多个地图闲逛。
* 此时，若传入的是子类的对象，就需要每个子类都写一遍方法。
* 但若是声明的是父类的类型，传入的是子类的对象，那么就可以传入不同的子类对象。
* 此时，虽然声明的是父类，但却可以传入父类下的所有子类的对象。
*/
public boolean wander(Field nowhere, Scanner scanner) {
int i = (int)Math.floor(Math.random()*9);
System.out.println("遇到怪物 " + nowhere.enemies[i].enemyName);
boolean flag = this.attack(nowhere.enemies[i],scanner);
if(flag){
System.out.println("胜利");
this.addExp(nowhere.enemies[i].exp);
this.addGold(nowhere.enemies[i].gold);
return true;
}else {
System.out.println("失败");
return false;
}
}
// 获得经验
public void addExp(int exp){
this.exp += exp;
if(this.exp >= this.maxExp){
this.exp = this.exp - this.maxExp;
this.upgrade();
}
}
// 获得金钱
public void addGold(int gold){
this.gold += gold;
}
}