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

雨点打透心脏的1/2处 2023-06-12 06:20 3阅读 0赞

# 一、项目描述 #

奥特曼 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()
          }
        )
      }
    }