Scala - 小项目 - 奥特曼打小怪兽

一、项目描述

奥特曼 1个
   名字
   血量
   普通  必杀 一次只能打1只
   魔法       所有
   奥特曼的攻击 10%必杀 30%魔法 60%普攻
    
   小怪兽 4只
   名字
   血量
   普通  
  
   回合制游戏
   示例输出:
======== 第1回合 ========
(aa奥特曼,血量：100)
	使用魔法，攻击了b1小怪兽，小怪兽血量：80
	使用魔法，攻击了b2小怪兽，小怪兽血量：80
	使用魔法，攻击了b3小怪兽，小怪兽血量：80
	使用魔法，攻击了b4小怪兽，小怪兽血量：80
(b1小怪兽,血量：80)
	使用普攻，攻击了aa奥特曼，奥特曼血量：95
(b2小怪兽,血量：80)
	使用普攻，攻击了aa奥特曼，奥特曼血量：90
(b3小怪兽,血量：80)
	使用普攻，攻击了aa奥特曼，奥特曼血量：85
(b4小怪兽,血量：80)
	使用普攻，攻击了aa奥特曼，奥特曼血量：80

  
   奥特曼血量为0,小怪兽胜利
   所有的小怪兽都死了,奥特曼胜利

   奥特曼 普攻、必杀、魔法只能攻击存活的小怪兽，且普攻、必杀随机攻击存活的小怪兽
   奥特曼、小怪兽 血量不能小与0

二、代码

2.1 AMan.scala

// AMan.scala

package Practice.AplayB

import scala.collection.mutable.ListBuffer
import scala.util.Random

class AMan (val name2:String = "aa", val live2: Int = 100) {
  val name = name2
  var live = live2
  var x: Int = 40 // 普攻
  var y: Int = 100 // 必杀
  var z: Int = 20 // 魔法
  def this(name2: String, live2: Int, x2: Int, y2: Int, z2: Int) {
    this(name2, live2) //必须调用this()
    x = x2
    y = y2
    z = z2
  }
  def playB(lst: List[BMan]): Boolean = {
    var idlist = ListBuffer[Int]()
    for(i <- 0 until  lst.length){
      if(lst(i).live > 0){
        idlist.append(i)
      }
    }
    if(idlist.length == 0){
      return true
    }
    val t = Random.nextInt(idlist.length) // [0, idlist.length)
    val bd = idlist(t) //要攻击的B的下标
    val d = Random.nextInt(10) //[0, 10)
    if(d < 6){ // 60%可能性普攻
      lst(bd).live -= x
      if(lst(bd).live < 0){
        lst(bd).live = 0
      }
      printf("\t使用普攻，攻击了%s小怪兽，小怪兽血量：%d\n", lst(bd).name, lst(bd).live)
    }
    else if(d < 9){ // 30%可能性魔法
      for(x <- lst){
        if(x.live > 0){
          x.live -= z
          if(x.live < 0){
            x.live = 0
          }
          printf("\t使用魔法，攻击了%s小怪兽，小怪兽血量：%d\n", x.name, x.live)
        }
      }
    }
    else { // 10%可能性必杀
      lst(bd).live -= y
      if(lst(bd).live < 0){
        lst(bd).live = 0
      }
      printf("\t使用必杀，攻击了%s小怪兽，小怪兽血量：%d\n", lst(bd).name, lst(bd).live)
    }
    false
  }
}

2.2 BMan.scala

// BMan.scala

package Practice.AplayB

class BMan (name2: String, live2: Int = 100) {
  val name = name2
  var live = live2
  var x = 10
  def this(name2: String, live2: Int, x2: Int) {
    this(name2, live2)
    x = x2
  }
  def playA(a: AMan): Boolean = {
    if(a.live <= 0){
      return true
    }
    a.live -= x
    if(a.live < 0){
      a.live = 0
    }
    printf("\t使用普攻，攻击了%s奥特曼，奥特曼血量：%d\n", a.name, a.live)
    false
  }
}

2.3 Test.scala

// Test.scala

package Practice.AplayB

import scala.util.control.Breaks._

object Test {
  def main(args: Array[String]): Unit = {
    var aa = new AMan("aa", 100)
    var b1 = new BMan("b1", 100, 5)
    var b2 = new BMan("b2", 100, 5)
    var b3 = new BMan("b3", 100, 5)
    var b4 = new BMan("b4", 100, 5)
    val lst = List(b1, b2, b3, b4)
    var k = 1
    breakable(
      while(true){
        printf("======== 第%d回合 ========\n", k)
        k += 1
        println(aa.name + "奥特曼", "血量：" + aa.live)
        if(aa.live > 0){
          aa.playB(lst)
        }
        for(x <- lst){
          println(x.name + "小怪兽", "血量：" + x.live)
          if(x.live > 0){
            x.playA(aa)
          }
        }
        if(aa.live == 0){
          println("小怪兽胜利了")
          break()
        }
        var tmp = false
        for(x <- lst){
          if(x.live > 0){
            tmp = true
          }
        }
        if(tmp == false){
          println("奥特曼胜利了")
          break()
        }
        println()
      }
    )
  }
}