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()
      }
    )
  }
}