2.24日到2.29日学习记录
这个星期是学习c#的最后一个星期
内容有：继承 多态 抽象 静态类 接口 泛型 集合 委托 事件
最后的大作业是
我的代码是
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace aHomeWork
{
enum HeroState
{
Dizziness,
Silence,
Normal
}
class CountRountSkill
{
public int countRount;
public Skill skill;
public CountRountSkill(int countRount, Skill skill)
{
this.countRount = countRount;
this.skill = skill;
}
}
class Hero
{
public string name;
public int blood;
public int attack;
public int magic;
public int armor;
public int magicResist;
/// <summary>
/// 普通攻击伤害
/// </summary>
public int ordinaryInjury;
public int ordinaryInjuryMoney;
/// <summary>
/// 英雄拥有的钱
/// </summary>
public int money;
/// <summary>
/// 英雄状态
/// </summary>
public HeroState heroState;
/// <summary>
/// 在第几回合时，技能不能被使用了
/// </summary>
public List<CountRountSkill> skillUsed;
/// <summary>
/// 第几回合
/// </summary>
public int countRount;
/// <summary>
/// 可以使用的装备
/// </summary>
public List<Equipment> canUseEquipment;
/// <summary>
/// 可以学的技能
/// </summary>
public List<Skill> canLearnSkill;
/// <summary>
/// 学会可以使用的技能
/// </summary>
public List<Skill> canUseSkill;
/// <summary>
/// 学会的
/// </summary>
public List<Skill> learned;
/// <summary>
/// 可以升级的技能
/// </summary>
public List<Skill> canUpSkill;
/// <summary>
/// 是否学习或升级了技能
/// </summary>
public bool learnOrUpFlag = false;
public Hero(string name,int money, int ordinaryInjury, int ordinaryInjuryMoney)
{
this.name = name;
this.blood = 300;
this.money = money;
this.ordinaryInjury = ordinaryInjury;
this.ordinaryInjuryMoney = ordinaryInjuryMoney;
canLearnSkill = new List<Skill>();
canUseSkill = new List<Skill>();
canUpSkill = new List<Skill>();
learned = new List<Skill>();
canUseEquipment = new List<Equipment>();
skillUsed = new List<CountRountSkill>();
countRount = 0;
}
/// <summary>
/// 普通攻击
/// </summary>
public void CommonAttack(Hero heroS)
{
heroS.blood -= this.ordinaryInjury;
Console.WriteLine($"{heroS.name}受到{this.ordinaryInjury}点伤害");
this.money += this.ordinaryInjuryMoney;
Console.WriteLine($"{name}获得了{this.ordinaryInjuryMoney}的金钱");
}
/// <summary>
/// 技能攻击
/// </summary>
public void SkillAttack(Hero heroS)
{
//选择技能并使用
for (int i = 0; i < canUseSkill.Count; i++)
{
Console.WriteLine(canUseSkill[i]);
}
Console.WriteLine("请选择要使用的技能编号");
int skillNum = int.Parse(Console.ReadLine()) - 1;
canUseSkill[skillNum].skillAction(this, heroS);
}
/// <summary>
/// 买装备
/// </summary>
public void BuyEquipments()
{
bool tfBuy = false;
while (!tfBuy)
{
for (int i = 0; i < Equipment.equipments.Count; i++)
{
Console.WriteLine(Equipment.equipments[i]);
}
Console.WriteLine("请输入要购买的装备的编号");
int equipmentsNum = int.Parse(Console.ReadLine()) - 1;
if (money >= Equipment.equipments[equipmentsNum].speed)
{
Console.WriteLine($"购买了装备{Equipment.equipments[equipmentsNum].name}");
canUseEquipment.Add(Equipment.equipments[equipmentsNum]);
tfBuy = true;
if (Equipment.equipments[equipmentsNum].equipmentType == EquipmentType.disposableType)
{
canUseEquipment.Remove(Equipment.equipments[equipmentsNum]);
blood += Equipment.equipments[equipmentsNum].addLiveValue;
Console.WriteLine($"使用了{Equipment.equipments[equipmentsNum].name}," +
$"恢复了{Equipment.equipments[equipmentsNum].addLiveValue}生命值");
}
else
{
attack += Equipment.equipments[equipmentsNum].addAttack;
armor+= Equipment.equipments[equipmentsNum].addArmor;
magic += Equipment.equipments[equipmentsNum].addMagic;
magicResist += Equipment.equipments[equipmentsNum].addMagicResist;
}
}
else
{
Console.WriteLine("当前英雄的金钱不足以购买这件装备");
tfBuy = false;
}
}
}
/// <summary>
/// 学习新技能
/// </summary>
public void LearnNewSkill()
{
Console.WriteLine($"这是可以学习的技能");
for (int i = 0; i < canLearnSkill.Count; i++)
{
Console.WriteLine(canLearnSkill[i]);
}
Console.WriteLine("请选择要学习的技能编号");
int skillNum = int.Parse(Console.ReadLine())-1;
canUseSkill.Add(canLearnSkill[skillNum]);
learned.Add(canLearnSkill[skillNum]);
Console.WriteLine($"您学会了技能\n{canLearnSkill[skillNum]}");
canLearnSkill.Remove(canLearnSkill[skillNum]);
}
/// <summary>
/// 更新可升级技能
/// </summary>
public void UpdateCanUpLevel()
{
canUpSkill = new List<Skill>();
for (int i = 0; i < learned.Count; i++)
{
if (learned[i].level <= 3)
{
canUpSkill.Add(learned[i]);
}
}
}
/// <summary>
/// 升级技能
/// </summary>
public void UpSkillLevel()
{
Console.WriteLine($"这是可以升级的技能");
for (int i = 0; i < canUpSkill.Count; i++)
{
Console.WriteLine(canUpSkill[i]);
}
Console.WriteLine($"请输入要升级的技能");
int skillUpNum = int.Parse(Console.ReadLine())-1;
canUpSkill[skillUpNum].UpLevel();//升级技能
for (int i = 0; i < canUseSkill.Count; i++)
{
if(canUseSkill[i]== canUpSkill[skillUpNum])
{
canUseSkill[i].UpLevel();
}
}
Console.WriteLine($"技能{ canUpSkill[skillUpNum].name}升级了，现在为{canUpSkill[skillUpNum].level}级");
}
/// <summary>
/// 从禁用的技能中找到恢复使用的技能并添加
/// </summary>
public void FindBackSkill()
{
for (int i = 0; i < skillUsed.Count; i++)
{
if (skillUsed[i].countRount + skillUsed[i].skill.frequency == countRount)
{
canUpSkill.Add(skillUsed[i].skill);
}
}
}
/// <summary>
/// 开始回合
/// </summary>
/// <param name="heroS">被攻击英雄</param>
public void startRound(Hero heroS)
{
Console.WriteLine("------------");
countRount++;
FindBackSkill();//从禁用的技能中找到恢复使用的技能并添加
Console.WriteLine($"{name}的回合");
//先学习一个技能或升级几个技能
while (!learnOrUpFlag)
{
if (canLearnSkill.Count != 0)
{
Console.WriteLine($"请选择学习技能还是升级技能：0-学习，1-升级");
int learnOrUp = int.Parse(Console.ReadLine());
switch (learnOrUp)
{
case 0:
LearnNewSkill();//学习新技能
learnOrUpFlag = true;
break;
case 1:
UpdateCanUpLevel();
if (canUpSkill.Count != 0)
{
UpSkillLevel();
learnOrUpFlag = true;
}
else
{
Console.WriteLine("您没有可升级的技能");
learnOrUpFlag = false;
}
break;
default:
break;
}
}
else
{
Console.WriteLine($"所有的技能都学会了");
UpdateCanUpLevel();
if (canUpSkill.Count != 0)
{
UpSkillLevel();
learnOrUpFlag = true;
}
else
{
Console.WriteLine("所有的技能都学会了，并都升到了满级");
learnOrUpFlag = true;
}
}
}
//学会技能以后
if (learnOrUpFlag)
{
Console.WriteLine($"*********************");
switch (heroState)
{
case HeroState.Dizziness:
Console.WriteLine("0-购买装备,666-退出");
Console.WriteLine($"当前英雄的状态是{heroState}");
int choose = int.Parse(Console.ReadLine());
switch (choose)
{
case 0:
BuyEquipments();
break;
case 666:
break;
default:
break;
}
break;
case HeroState.Silence:
Console.WriteLine("0-购买装备,1-普通攻击");
Console.WriteLine($"当前英雄的状态是{heroState}");
int choose1 = int.Parse(Console.ReadLine());
switch (choose1)
{
case 0:
BuyEquipments();
break;
case 1:
CommonAttack(heroS);
break;
default:
break;
}
break;
default:
bool flag = false;
while (!flag)
{
Console.WriteLine("0-购买装备,1-普通攻击，2-技能攻击");
Console.WriteLine($"当前英雄的状态是{heroState}");
int choose2 = int.Parse(Console.ReadLine());
switch (choose2)
{
case 0:
BuyEquipments();
flag = true;
break;
case 1:
CommonAttack(heroS);
flag = true;
break;
case 2:
if (canUseSkill.Count != 0)
{
SkillAttack(heroS);
flag = true;
}
else
{
Console.WriteLine("没有技能可以使用");
flag = false;
}
break;
default:
flag = true;
break;
}
}
break;
}
}
heroState = HeroState.Normal;
learnOrUpFlag = false;
}
public void Death()
{
Console.WriteLine(name + "死了");
}
public void Won()
{
Console.WriteLine(name + "赢了");
}
}
/// <summary>
/// 技能类型
/// </summary>
enum SkillType
{
Dizziness,
Silence,
Normal
}
class Skill
{
public string name;
public int level;
public int money;
/// <summary>
/// 技能类型
/// </summary>
public Action<Hero,Hero> skillAction;
public SkillType skillType;
/// <summary>
/// 基础伤害
/// </summary>
public int basicHurt;
/// <summary>
/// 等级伤害加成
/// </summary>
public float addHurt;
/// <summary>
/// 使用频率
/// </summary>
public int frequency;
public Skill(string name, int level, SkillType skillType, int basicHurt, float addHurt, int frequency, int money)
{
this.name = name;
this.level = level;
this.skillType = skillType;
this.basicHurt = basicHurt;
this.addHurt = addHurt;
this.frequency = frequency;
this.money = money;
switch (skillType)
{
case SkillType.Dizziness:
skillAction = DizzinessSkill;
break;
case SkillType.Silence:
skillAction = SilenceSkill;
break;
case SkillType.Normal:
skillAction = NormalSkill;
break;
}
}
public override string ToString()
{
return "--------【技能名称】：" + name + "-------" +
"\n【技能等级】：" + level +
"\n【技能类型】：令敌人" +skillType+
"\n【技能基础伤害】：" + basicHurt +
"\n【技能等级伤害加成】：" + addHurt +
"\n【技能使用频率】：每" + frequency + "回合使用一次";
}
/// <summary>
/// 眩晕技能
/// </summary>
/// <param name="heroG">攻击方英雄</param>
/// <param name="heroS">被攻击英雄</param>
public void DizzinessSkill(Hero heroG,Hero heroS)
{
heroS.heroState = HeroState.Dizziness;
Console.WriteLine($"{heroS.name}的状态为{heroS.heroState}");
heroG.skillUsed.Add(new CountRountSkill(heroG.countRount,this));
heroG.canUseSkill.Remove(this);
NormalSkill(heroG, heroS);
}
public void SilenceSkill(Hero heroG,Hero heroS)
{
heroS.heroState = HeroState.Silence;
heroG.skillUsed.Add(new CountRountSkill(heroG.countRount, this));
Console.WriteLine($"{heroS.name}的状态为{heroS.heroState}");
heroG.canUseSkill.Remove(this);
NormalSkill(heroG, heroS);
}
public void NormalSkill(Hero heroG,Hero heroS)
{
if (this.skillType == SkillType.Normal)
{
heroS.heroState = HeroState.Normal;
}
heroG.skillUsed.Add(new CountRountSkill(heroG.countRount, this));
heroS.blood -= this.basicHurt + (int)this.addHurt * this.basicHurt;
Console.WriteLine($"{heroG.name}向{heroS.name}释放了{name}技能");
Console.WriteLine($"{heroS.name}受到{this.basicHurt + (int)this.addHurt * this.basicHurt}点伤害");
Console.WriteLine($"{heroS.name}的剩余血量为{heroS.blood}");
heroG.money += this.money;
Console.WriteLine($"{heroG.name}获得了{money}的金钱");
Console.WriteLine($"{heroG.name}当前拥有的金钱数量是{heroG.money}");
}
/// <summary>
/// 等级升级
/// </summary>
public void UpLevel()
{
level += 1;
addHurt += 0.5f;
}
}
/// <summary>
/// 装备类型
/// </summary>
enum EquipmentType
{
ordinaryType,
disposableType
}
class Equipment
{
public string name;
/// <summary>
/// 装备花费
/// </summary>
public int speed;
/// <summary>
/// 装备类型
/// </summary>
public EquipmentType equipmentType;
/// <summary>
/// 攻击加成
/// </summary>
public int addAttack;
/// <summary>
/// 法术加成
/// </summary>
public int addMagic;
/// <summary>
/// 护甲加成
/// </summary>
public int addArmor;
/// <summary>
/// 魔抗加成
/// </summary>
public int addMagicResist;
/// <summary>
/// 恢复生命值
/// </summary>
public int addLiveValue;
/// <summary>
/// 装备总表
/// </summary>
public static List<Equipment> equipments=new List<Equipment>();
public Equipment(string name, int speed, EquipmentType equipmentType, int addLiveValue)
{
this.name = name;
this.speed = speed;
this.equipmentType = equipmentType;
this.addLiveValue = addLiveValue;
}
public Equipment(string name, int speed, EquipmentType equipmentType, int addAttack, int addMagic, int addArmor, int addMagicResist)
{
this.name = name;
this.speed = speed;
this.equipmentType = equipmentType;
this.addMagic = addMagic;
this.addArmor = addArmor;
this.addMagicResist = addMagicResist;
}
public override string ToString()
{
string type = "";
switch (equipmentType)
{
case EquipmentType.ordinaryType:
type = "普通类型";
return "--------【装备名称：" + name + "】-------"
+ "\n【装备花费：" + speed + "】"
+ "\n【装备类型：" + type + "】"
+ "\n【装备攻击加成：" + addAttack + "】"
+ "\n【装备法强加成：" + addMagic + "】"
+ "\n【装备护甲加成：" + addArmor + "】"
+ "\n【装备魔抗加成：" + addMagicResist + "】";
break;
case EquipmentType.disposableType:
type = "一次性类型";
return "--------【装备名称：" + name + "】-------"
+ "\n【装备花费：" + speed + "】"
+ "\n【装备类型：" + type + "】"
+ "\n【装备恢复生命值：" + addLiveValue + "】";
break;
default:
return "";
break;
}
}
}
class Program
{
public static void Main(string[] args)
{
//亚索的技能
Skill zgs = new Skill("斩钢闪", 1, SkillType.Dizziness, 100, 0, 2,1000);
Skill tqz = new Skill("踏前斩", 1, SkillType.Normal, 150, 0, 2,1500);
Skill bsdsl = new Skill("悲伤的失恋", 1, SkillType.Silence, 130, 0, 3,1300);
Skill tq = new Skill("偷钱", 1, SkillType.Normal, 100, 0, 1,1000);
//提莫的技能
Skill byg = new Skill("白月光", 1, SkillType.Dizziness, 90, 0, 2,900);
Skill fhj = new Skill("封喉剑", 1, SkillType.Silence, 140, 0, 3,1400);
Skill cxhl = new Skill("潮汐海灵", 1, SkillType.Normal, 140, 0, 2,1400);
Skill tx = new Skill("偷袭", 1, SkillType.Normal, 110, 0, 1,1100);
Equipment sxzl = new Equipment("三相之力", 3000, EquipmentType.ordinaryType, 40, 10, 20, 10);
Equipment wjzr = new Equipment("无尽之刃", 3200, EquipmentType.disposableType, 100, 0, 0, 0);
Equipment fzkls = new Equipment("肥仔快乐水", 1000, EquipmentType.disposableType, 500);
Hero ys = new Hero("疾风剑豪 亚索",1000,50,100);
Hero tm = new Hero("迅捷斥候 提莫", 1000, 50, 100);
ys.canLearnSkill.Add(zgs);
ys.canLearnSkill.Add(tqz);
ys.canLearnSkill.Add(bsdsl);
ys.canLearnSkill.Add(tq);
tm.canLearnSkill.Add(byg);
tm.canLearnSkill.Add(fhj);
tm.canLearnSkill.Add(cxhl);
tm.canLearnSkill.Add(tx);
Equipment.equipments.Add(sxzl);
Equipment.equipments.Add(wjzr);
Equipment.equipments.Add(fzkls);
ys.heroState = HeroState.Normal;
bool flag = ys.blood != null && tm.blood != null;
while (flag)
{
ys.startRound(tm);
if (ys.blood <= 0)
{
ys.Death();
tm.Won();
flag = false;
}
else if(tm.blood<=0)
{
tm.Death();
ys.Won();
flag = false;
}
else
{
tm.startRound(ys);
}
}
}
}
}
下面对我觉得困难的地方讲解一下
我的类：英雄类 技能类 武器类 和 CountRountSkil()类
1：为了解决一个技能使用后一定回合不能使用的问题创建了 CountRountSkil()类，将回合数和技能放进去，再放进列表，这样就能很方便的找到有那个技能可以恢复使用了。
2：利用委托和回调，先将技能的眩晕等方法委托给技能的技能类型列表里的action委托。等英雄使用该技能时，可以直接回调该技能方法。十分的快捷。