Code Sketch


BixuuFightingWorld
By: Mhalsakant School
Category: Programming
import java.awt.{BasicStroke, BorderLayout, CardLayout, Color, Dimension, Font, GradientPaint, Graphics, Graphics2D, Polygon, RenderingHints}
import java.awt.event.{ActionEvent, ActionListener, KeyAdapter, KeyEvent, MouseAdapter, MouseEvent, WindowAdapter, WindowEvent}
import java.awt.geom.{Ellipse2D, RoundRectangle2D}
import java.io.{BufferedReader, BufferedWriter, InputStreamReader, OutputStreamWriter, PrintWriter}
import java.net.{InetSocketAddress, ServerSocket, Socket, SocketTimeoutException}
import java.util.UUID
import java.util.concurrent.CopyOnWriteArrayList
import javax.swing.{BorderFactory, JButton, JFrame, JLabel, JPanel, JScrollPane, JTextField, SwingConstants, SwingUtilities, Timer, WindowConstants}
import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.HashSet
import scala.util.Random

object BixuuFightingWorld {
  val dark = new Color(8, 13, 29)
  val panelDark = new Color(16, 25, 48)
  val panelBlue = new Color(24, 42, 76)
  val cyan = new Color(83, 235, 255)
  val aqua = new Color(101, 255, 207)
  val gold = new Color(255, 211, 105)
  val violet = new Color(183, 126, 255)
  val white = new Color(239, 245, 255)
  val muted = new Color(159, 178, 211)

  def main(args: Array[String]): Unit = {
    SwingUtilities.invokeLater(new Runnable {
      override def run(): Unit = {
        val window = new MainWindow()
        window.setVisible(true)
      }
    })
  }

  def makeButton(text: String, action: () => Unit): JButton = {
    val b = new JButton(text)
    b.setFont(new Font("SansSerif", Font.BOLD, 14))
    b.setForeground(white)
    b.setBackground(new Color(31, 55, 91))
    b.setFocusPainted(false)
    b.setBorder(BorderFactory.createCompoundBorder(
      BorderFactory.createLineBorder(new Color(76, 194, 224), 1),
      BorderFactory.createEmptyBorder(10, 15, 10, 15)
    ))
    b.addActionListener(new ActionListener {
      override def actionPerformed(e: ActionEvent): Unit = action()
    })
    b
  }

  def makeLabel(text: String, size: Int, color: Color, align: Int = SwingConstants.CENTER): JLabel = {
    val l = new JLabel(text, align)
    l.setFont(new Font("SansSerif", Font.BOLD, size))
    l.setForeground(color)
    l
  }

  def makePanel(layout: java.awt.LayoutManager = new BorderLayout()): JPanel = {
    val p = new JPanel(layout)
    p.setBackground(dark)
    p
  }

  class MainWindow extends JFrame("BIXUU FIGHTING WORLD | Original Energy Arena") {
    var playerName = ""
    var playerId = ""
    var bucks = 650
    var diamonds = 35
    var avatarIndex = 0
    var selectedSkin = "Aurora Pulse"
    var activeGame: BattlePanel = null
    var lanSession: LanSession = null
    val events = ArrayBuffer[String]("NEON DROP WEEKEND", "CYBER CUP: BOT TAG CHALLENGE", "DOUBLE BIXUU BUCKS")
    val ownedSkins = scala.collection.mutable.Set[String]("Aurora Pulse")

    setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE)
    setMinimumSize(new Dimension(980, 680))
    setSize(1220, 820)
    setLocationRelativeTo(null)
    setResizable(true)

    addWindowListener(new WindowAdapter {
      override def windowClosing(e: WindowEvent): Unit = {
        if (activeGame != null) activeGame.stopGame()
        if (lanSession != null) lanSession.closeSession()
      }
    })

    showLogin()

    def showLogin(): Unit = {
      val root = makePanel(new BorderLayout(12, 12))
      root.setBorder(BorderFactory.createEmptyBorder(28, 44, 28, 44))
      val heading = makeLabel("BIXUU FIGHTING WORLD", 34, cyan)
      val sub = makeLabel("ORIGINAL MULTI-MODE ENERGY ARENA", 16, gold)
      val top = makePanel(new BorderLayout(4, 8))
      top.add(heading, BorderLayout.NORTH)
      top.add(sub, BorderLayout.SOUTH)
      val art = new LoginArtwork()
      val form = makePanel(new java.awt.FlowLayout(java.awt.FlowLayout.CENTER, 12, 12))
      val prompt = makeLabel("CREATE YOUR LOCAL PLAYER PROFILE", 14, white)
      val field = new JTextField(19)
      field.setFont(new Font("SansSerif", Font.PLAIN, 18))
      field.setPreferredSize(new Dimension(250, 40))
      val enter = makeButton("CREATE / LOGIN", () => {
        val raw = field.getText.trim
        if (raw.length > 0) {
          playerName = raw.take(18)
          playerId = "BX-" + Integer.toHexString(Math.abs(playerName.hashCode)).toUpperCase
          showLobby()
        } else {
          field.setText("Enter a player name")
        }
      })
      form.add(prompt)
      form.add(field)
      form.add(enter)
      val note = makeLabel("Local demo profile ? no password or real-money purchase ? offline play supported", 11, muted)
      val south = makePanel(new BorderLayout())
      south.add(form, BorderLayout.CENTER)
      south.add(note, BorderLayout.SOUTH)
      root.add(top, BorderLayout.NORTH)
      root.add(art, BorderLayout.CENTER)
      root.add(south, BorderLayout.SOUTH)
      setContentPane(root)
      revalidate()
      repaint()
    }

    def showLobby(): Unit = {
      val root = makePanel(new BorderLayout(10, 10))
      root.setBorder(BorderFactory.createEmptyBorder(12, 16, 12, 16))
      val top = makePanel(new BorderLayout(12, 4))
      val player = makeLabel("PLAYER  " + playerName + "   |   ID " + playerId, 15, gold, SwingConstants.LEFT)
      val wallet = makeLabel("BIXUU BUCKS  " + bucks + "     BIXUU DIAMONDS  " + diamonds, 15, cyan, SwingConstants.RIGHT)
      top.add(player, BorderLayout.WEST)
      top.add(wallet, BorderLayout.EAST)
      val banner = new LobbyArtwork()
      banner.setPreferredSize(new Dimension(1100, 220))
      val grid = new JPanel(new java.awt.GridLayout(2, 4, 10, 10))
      grid.setBackground(dark)
      grid.add(makeButton("BATTLE ARENA", () => startMatch("ARENA")))
      grid.add(makeButton("SQUAD PRACTICE", () => startMatch("SQUAD PRACTICE")))
      grid.add(makeButton("CLASH TAG", () => startMatch("CLASH TAG")))
      grid.add(makeButton("TRAINING GROUND", () => startMatch("TRAINING")))
      grid.add(makeButton("CUSTOM ROOM", () => showCustomRoom()))
      grid.add(makeButton("CHARACTER / LOOKS", () => showCharacters()))
      grid.add(makeButton("GEAR STORE", () => showStore()))
      grid.add(makeButton("EVENTS BOARD", () => showEvents()))
      val bottom = makePanel(new java.awt.FlowLayout(java.awt.FlowLayout.CENTER, 12, 6))
      bottom.add(makeButton("FRIENDS / LAN", () => showFriends()))
      bottom.add(makeButton("PROFILE", () => showProfile()))
      bottom.add(makeButton("LEADERBOARD", () => showLeaderboard()))
      bottom.add(makeButton("LOG OUT", () => showLogin()))
      val center = makePanel(new BorderLayout(10, 10))
      center.add(banner, BorderLayout.NORTH)
      center.add(grid, BorderLayout.CENTER)
      center.add(bottom, BorderLayout.SOUTH)
      root.add(top, BorderLayout.NORTH)
      root.add(center, BorderLayout.CENTER)
      setContentPane(root)
      revalidate()
      repaint()
    }

    def showCustomRoom(): Unit = {
      val modes = Array[AnyRef]("CUSTOM SOLO ROOM", "CUSTOM BOT ROOM", "LAN HOST ROOM", "LAN JOIN ROOM")
      val choice = javax.swing.JOptionPane.showInputDialog(this, "Choose a room type", "CUSTOM ROOM", javax.swing.JOptionPane.QUESTION_MESSAGE, null, modes, modes(0))
      if (choice == null) return
      val mode = choice.toString
      if (mode == "LAN HOST ROOM") {
        val portText = javax.swing.JOptionPane.showInputDialog(this, "Host port (default 5099)", "5099")
        if (portText == null) return
        val port = try { portText.trim.toInt } catch { case _: Throwable => 5099 }
        val session = new LanSession(playerName)
        val result = session.startHost(port)
        if (result) {
          lanSession = session
          javax.swing.JOptionPane.showMessageDialog(this, "LAN room hosted on port " + port + ". Share your local Wi-Fi IP and port with friends.")
          startMatch("LAN HOST", session)
        } else {
          javax.swing.JOptionPane.showMessageDialog(this, "Could not host this port. Try another port or use Training.")
          session.closeSession()
        }
      } else if (mode == "LAN JOIN ROOM") {
        val ip = javax.swing.JOptionPane.showInputDialog(this, "Host IP address (same Wi-Fi)")
        if (ip == null || ip.trim.length == 0) return
        val portText = javax.swing.JOptionPane.showInputDialog(this, "Host port (default 5099)", "5099")
        if (portText == null) return
        val port = try { portText.trim.toInt } catch { case _: Throwable => 5099 }
        val session = new LanSession(playerName)
        if (session.joinHost(ip.trim, port)) {
          lanSession = session
          startMatch("LAN CLIENT", session)
        } else {
          javax.swing.JOptionPane.showMessageDialog(this, "Could not join. Check the IP, port and same Wi-Fi connection.")
          session.closeSession()
        }
      } else startMatch(mode)
    }

    def startMatch(mode: String, session: LanSession = null): Unit = {
      if (activeGame != null) activeGame.stopGame()
      activeGame = new BattlePanel(playerName, mode, selectedSkin, avatarIndex, session, (earned: Int) => {
        bucks += earned
        if (mode != "TRAINING") diamonds += 1
      }, () => {
        if (lanSession != null) { lanSession.closeSession(); lanSession = null }
        activeGame = null
        showLobby()
      })
      val root = makePanel(new BorderLayout(6, 6))
      val hud = makeLabel("BIXUU FIGHTING WORLD   |   " + playerName + "   |   " + mode + "   |   BUCKS " + bucks, 13, gold, SwingConstants.LEFT)
      hud.setBorder(BorderFactory.createEmptyBorder(6, 12, 6, 12))
      val controls = makePanel(new java.awt.FlowLayout(java.awt.FlowLayout.CENTER, 8, 5))
      controls.add(makeButton("PULSE TAG [F]", () => activeGame.usePulse()))
      controls.add(makeButton("SHIELD [Q]", () => activeGame.useShield()))
      controls.add(makeButton("DASH [SPACE]", () => activeGame.dash()))
      controls.add(makeButton("PICKUP [E]", () => activeGame.interact()))
      controls.add(makeButton("PAUSE [P]", () => activeGame.togglePause()))
      controls.add(makeButton("LOBBY [ESC]", () => activeGame.exitToLobby()))
      root.add(hud, BorderLayout.NORTH)
      root.add(activeGame, BorderLayout.CENTER)
      root.add(controls, BorderLayout.SOUTH)
      setContentPane(root)
      revalidate()
      repaint()
      activeGame.requestFocusInWindow()
      activeGame.startGame()
    }

    def showStore(): Unit = {
      val root = makePanel(new BorderLayout(12, 12))
      root.setBorder(BorderFactory.createEmptyBorder(24, 35, 24, 35))
      root.add(makeLabel("BIXUU GEAR STORE", 28, cyan), BorderLayout.NORTH)
      val grid = new JPanel(new java.awt.GridLayout(0, 2, 12, 12))
      grid.setBackground(dark)
      val items = Array(("Aurora Pulse Skin", "120 Bixuu Bucks", 120, 0), ("Solar Flare Skin", "220 Bixuu Bucks", 220, 0), ("Nebula Trail", "8 Bixuu Diamonds", 0, 8), ("Crystal Shield Look", "12 Bixuu Diamonds", 0, 12), ("Hoverboard Neon Paint", "160 Bixuu Bucks", 160, 0), ("Victory Emote: Star Pop", "100 Bixuu Bucks", 100, 0))
      var i = 0
      while (i < items.length) {
        val item = items(i)
        val box = makePanel(new BorderLayout(5, 5))
        box.setBorder(BorderFactory.createLineBorder(new Color(65, 130, 170), 1))
        box.add(makeLabel(item._1, 16, white), BorderLayout.CENTER)
        box.add(makeLabel(item._2, 12, gold), BorderLayout.NORTH)
        box.add(makeButton("BUY", () => {
          if (ownedSkins.contains(item._1)) javax.swing.JOptionPane.showMessageDialog(this, "Already owned!")
          else if (bucks >= item._3 && diamonds >= item._4) {
            bucks -= item._3
            diamonds -= item._4
            ownedSkins += item._1
            selectedSkin = item._1
            javax.swing.JOptionPane.showMessageDialog(this, "Unlocked: " + item._1)
            showStore()
          } else javax.swing.JOptionPane.showMessageDialog(this, "Not enough Bixuu currency. Earn more in matches.")
        }), BorderLayout.SOUTH)
        grid.add(box)
        i += 1
      }
      root.add(new JScrollPane(grid), BorderLayout.CENTER)
      root.add(makeButton("BACK TO LOBBY", () => showLobby()), BorderLayout.SOUTH)
      setContentPane(root)
      revalidate()
      repaint()
    }

    def showCharacters(): Unit = {
      val names = Array("NOVA RUNNER", "VOLT MAGE", "AURORA GUARD", "CYBER SCOUT")
      val descriptions = Array("Fast explorer with a bright pulse trail.", "Energy specialist with a violet aura.", "Balanced guardian with a prism shield.", "Agile scout with a hoverboard style.")
      val root = makePanel(new BorderLayout(12, 12))
      root.setBorder(BorderFactory.createEmptyBorder(25, 30, 25, 30))
      root.add(makeLabel("CHOOSE YOUR HERO", 28, cyan), BorderLayout.NORTH)
      val grid = new JPanel(new java.awt.GridLayout(2, 2, 12, 12))
      grid.setBackground(dark)
      var i = 0
      while (i < names.length) {
        val index = i
        val card = makePanel(new BorderLayout(4, 4))
        card.setBorder(BorderFactory.createLineBorder(new Color(72, 151, 188), 1))
        card.add(makeLabel(names(index), 18, gold), BorderLayout.NORTH)
        card.add(makeLabel(descriptions(index), 12, muted), BorderLayout.CENTER)
        card.add(makeButton("SELECT", () => { avatarIndex = index; showCharacters() }), BorderLayout.SOUTH)
        grid.add(card)
        i += 1
      }
      root.add(grid, BorderLayout.CENTER)
      root.add(makeButton("BACK TO LOBBY", () => showLobby()), BorderLayout.SOUTH)
      setContentPane(root)
      revalidate()
      repaint()
    }

    def showEvents(): Unit = {
      val root = makePanel(new BorderLayout(10, 10))
      root.setBorder(BorderFactory.createEmptyBorder(20, 28, 20, 28))
      root.add(makeLabel("LIVE EVENTS BOARD", 27, gold), BorderLayout.NORTH)
      val list = new JPanel(new java.awt.GridLayout(0, 1, 8, 8))
      list.setBackground(dark)
      var i = 0
      while (i < events.length) {
        list.add(makeLabel("?  " + events(i), 16, white, SwingConstants.LEFT))
        i += 1
      }
      root.add(new JScrollPane(list), BorderLayout.CENTER)
      val bottom = makePanel(new java.awt.FlowLayout())
      bottom.add(makeButton("ADD LOCAL EVENT", () => {
        val name = javax.swing.JOptionPane.showInputDialog(this, "Event title")
        if (name != null && name.trim.length > 0) { events += name.trim.take(60); showEvents() }
      }))
      bottom.add(makeButton("BACK TO LOBBY", () => showLobby()))
      root.add(bottom, BorderLayout.SOUTH)
      setContentPane(root)
      revalidate()
      repaint()
    }

    def showFriends(): Unit = {
      val root = makePanel(new BorderLayout(12, 12))
      root.setBorder(BorderFactory.createEmptyBorder(24, 30, 24, 30))
      root.add(makeLabel("FRIENDS & LAN ROOMS", 27, cyan), BorderLayout.NORTH)
      val info = makeLabel("Use Custom Room ? LAN HOST or LAN JOIN on the same Wi-Fi. Up to 12 remote clients can connect to one host in this prototype.", 14, white)
      root.add(info, BorderLayout.CENTER)
      val bottom = makePanel(new java.awt.FlowLayout())
      bottom.add(makeButton("HOST LAN ROOM", () => showCustomRoom()))
      bottom.add(makeButton("BACK TO LOBBY", () => showLobby()))
      root.add(bottom, BorderLayout.SOUTH)
      setContentPane(root)
      revalidate()
      repaint()
    }

    def showProfile(): Unit = {
      val root = makePanel(new BorderLayout(10, 10))
      root.setBorder(BorderFactory.createEmptyBorder(35, 45, 35, 45))
      root.add(makeLabel("PLAYER PROFILE", 28, cyan), BorderLayout.NORTH)
      val body = makePanel(new java.awt.GridLayout(0, 1, 8, 8))
      body.add(makeLabel("NAME: " + playerName, 17, white, SwingConstants.LEFT))
      body.add(makeLabel("PLAYER ID: " + playerId, 15, gold, SwingConstants.LEFT))
      body.add(makeLabel("GEAR LOOK: " + selectedSkin, 15, white, SwingConstants.LEFT))
      body.add(makeLabel("BIXUU BUCKS: " + bucks + "   |   BIXUU DIAMONDS: " + diamonds, 15, gold, SwingConstants.LEFT))
      root.add(body, BorderLayout.CENTER)
      root.add(makeButton("BACK TO LOBBY", () => showLobby()), BorderLayout.SOUTH)
      setContentPane(root)
      revalidate()
      repaint()
    }

    def showLeaderboard(): Unit = {
      val root = makePanel(new BorderLayout(10, 10))
      root.setBorder(BorderFactory.createEmptyBorder(30, 40, 30, 40))
      root.add(makeLabel("LOCAL SEASON LEADERBOARD", 26, gold), BorderLayout.NORTH)
      root.add(makeLabel("1. " + playerName + "   ?   YOUR CURRENT PROFILE\n\nThis offline build tracks your match score locally. Online global rankings need a hosted game server.", 16, white), BorderLayout.CENTER)
      root.add(makeButton("BACK TO LOBBY", () => showLobby()), BorderLayout.SOUTH)
      setContentPane(root)
      revalidate()
      repaint()
    }
  }

  class LoginArtwork extends JPanel {
    setPreferredSize(new Dimension(900, 420))
    override def paintComponent(graphics: Graphics): Unit = {
      super.paintComponent(graphics)
      val g = graphics.create().asInstanceOf[Graphics2D]
      g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON)
      val w = getWidth
      val h = getHeight
      g.setPaint(new GradientPaint(0, 0, new Color(12, 31, 70), 0, h, new Color(20, 11, 47)))
      g.fillRect(0, 0, w, h)
      var i = 0
      while (i < 100) {
        val sx = (i * 97) % Math.max(1, w)
        val sy = (i * 53) % Math.max(1, h)
        g.setColor(new Color(115, 220, 255, 90 + (i % 140)))
        g.fillOval(sx, sy, 2 + (i % 3), 2 + (i % 3))
        i += 1
      }
      g.setColor(new Color(35, 95, 160, 160))
      g.fillOval(w / 2 - 220, h / 2 - 130, 440, 260)
      g.setColor(cyan)
      g.setStroke(new BasicStroke(3f))
      g.drawOval(w / 2 - 220, h / 2 - 130, 440, 260)
      g.setFont(new Font("SansSerif", Font.BOLD, 38))
      g.setColor(white)
      val title = "ENTER THE ARENA"
      g.drawString(title, (w - g.getFontMetrics.stringWidth(title)) / 2, h / 2 + 14)
      g.setFont(new Font("SansSerif", Font.PLAIN, 16))
      g.setColor(gold)
      val sub = "Build your squad. Collect energy. Become the champion."
      g.drawString(sub, (w - g.getFontMetrics.stringWidth(sub)) / 2, h / 2 + 50)
      g.dispose()
    }
  }

  class LobbyArtwork extends JPanel {
    override def paintComponent(graphics: Graphics): Unit = {
      super.paintComponent(graphics)
      val g = graphics.create().asInstanceOf[Graphics2D]
      g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON)
      val w = getWidth
      val h = getHeight
      g.setPaint(new GradientPaint(0, 0, new Color(11, 29, 66), 0, h, new Color(14, 13, 38)))
      g.fillRect(0, 0, w, h)
      var i = 0
      while (i < 14) {
        val bw = 34 + (i % 3) * 18
        val bh = 65 + ((i * 31) % 100)
        val x = i * (w / 13) - 18
        g.setColor(new Color(24, 42, 77))
        g.fillRoundRect(x, h - bh, bw, bh, 7, 7)
        g.setColor(if (i % 2 == 0) cyan else violet)
        var r = 0
        while (r < 4) {
          g.fillRect(x + 8 + (r % 2) * 12, h - bh + 12 + r * 15, 5, 7)
          r += 1
        }
        i += 1
      }
      g.setColor(new Color(8, 12, 25, 220))
      g.fillRect(0, h - 32, w, 32)
      g.setColor(gold)
      g.setFont(new Font("SansSerif", Font.BOLD, 25))
      g.drawString("BIXUU FIGHTING WORLD", 24, 44)
      g.setFont(new Font("SansSerif", Font.PLAIN, 13))
      g.setColor(white)
      g.drawString("NEON ARENA  ?  ENERGY TAG MODES  ?  CUSTOM ROOMS", 26, 67)
      g.dispose()
    }
  }

  case class PeerSnapshot(id: String, name: String, x: Double, z: Double, score: Int)

  class LanSession(localName: String) {
    val localId = UUID.randomUUID().toString.replace("-", "").take(8)
    @volatile var running = false
    @volatile var isHost = false
    var server: ServerSocket = null
    var clientSocket: Socket = null
    var clientOut: PrintWriter = null
    val peerWriters = new CopyOnWriteArrayList[PrintWriter]()
    val peerMap = new java.util.concurrent.ConcurrentHashMap[String, PeerSnapshot]()
    @volatile var lx = 0.0
    @volatile var lz = 0.0
    @volatile var localScore = 0

    def startHost(port: Int): Boolean = {
      try {
        server = new ServerSocket(port)
        server.setSoTimeout(800)
        running = true
        isHost = true
        val t = new Thread(new Runnable {
          override def run(): Unit = {
            while (running) {
              try {
                val s = server.accept()
                if (peerWriters.size() < 12) {
                  val out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(s.getOutputStream, "UTF-8")), true)
                  peerWriters.add(out)
                  val reader = new BufferedReader(new InputStreamReader(s.getInputStream, "UTF-8"))
                  val worker = new Thread(new Runnable {
                    override def run(): Unit = {
                      var line = reader.readLine()
                      while (running && line != null) {
                        parsePeerLine(line)
                        line = reader.readLine()
                      }
                      peerWriters.remove(out)
                      try { s.close() } catch { case _: Throwable => }
                    }
                  })
                  worker.setDaemon(true)
                  worker.start()
                } else {
                  try { s.close() } catch { case _: Throwable => }
                }
              } catch {
                case _: SocketTimeoutException =>
                case _: Throwable =>
              }
            }
          }
        })
        t.setDaemon(true)
        t.start()
        true
      } catch {
        case _: Throwable => false
      }
    }

    def joinHost(ip: String, port: Int): Boolean = {
      try {
        clientSocket = new Socket()
        clientSocket.connect(new InetSocketAddress(ip, port), 2500)
        clientSocket.setSoTimeout(0)
        clientOut = new PrintWriter(new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream, "UTF-8")), true)
        val reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream, "UTF-8"))
        running = true
        isHost = false
        val t = new Thread(new Runnable {
          override def run(): Unit = {
            var line = reader.readLine()
            while (running && line != null) {
              if (line.startsWith("S|")) parseStateLine(line.substring(2))
              line = reader.readLine()
            }
          }
        })
        t.setDaemon(true)
        t.start()
        true
      } catch {
        case _: Throwable => false
      }
    }

    def parsePeerLine(line: String): Unit = {
      val p = line.split("\\|", -1)
      if (p.length >= 6 && p(0) == "P") {
        try {
          val peer = PeerSnapshot(p(1), p(2), p(3).toDouble, p(4).toDouble, p(5).toInt)
          peerMap.put(peer.id, peer)
        } catch { case _: Throwable => }
      }
    }

    def parseStateLine(line: String): Unit = {
      val rows = line.split(";")
      var i = 0
      while (i < rows.length) {
        val p = rows(i).split("\\|", -1)
        if (p.length >= 5) {
          try {
            val peer = PeerSnapshot(p(0), p(1), p(2).toDouble, p(3).toDouble, p(4).toInt)
            if (peer.id != localId) peerMap.put(peer.id, peer)
          } catch { case _: Throwable => }
        }
        i += 1
      }
    }

    def updateLocal(x: Double, z: Double, score: Int): Unit = {
      lx = x
      lz = z
      localScore = score
      val safeName = localName.replace("|", "_").replace(";", "_").replace("\n", "_")
      if (!isHost && clientOut != null) clientOut.println("P|" + localId + "|" + safeName + "|" + x + "|" + z + "|" + score)
    }

    def broadcast(): Unit = {
      if (isHost && running) {
        val safeName = localName.replace("|", "_").replace(";", "_")
        val sb = new StringBuilder
        sb.append(localId).append("|").append(safeName).append("|").append(lx).append("|").append(lz).append("|").append(localScore)
        val it = peerMap.values().iterator()
        while (it.hasNext) {
          val p = it.next()
          sb.append(";").append(p.id).append("|").append(p.name).append("|").append(p.x).append("|").append(p.z).append("|").append(p.score)
        }
        val message = "S|" + sb.toString
        val wi = peerWriters.iterator()
        while (wi.hasNext) wi.next().println(message)
      }
    }

    def remotePlayers(): Seq[PeerSnapshot] = {
      import scala.collection.JavaConverters._
      peerMap.values().asScala.toSeq
    }

    def closeSession(): Unit = {
      running = false
      try { if (server != null) server.close() } catch { case _: Throwable => }
      try { if (clientSocket != null) clientSocket.close() } catch { case _: Throwable => }
      peerWriters.clear()
      peerMap.clear()
    }
  }

  case class Bot(var x: Double, var z: Double, var hp: Int, var pulseDelay: Int)
  case class Orb(var x: Double, var z: Double, var vx: Double, var vz: Double, var ttl: Int, val friendly: Boolean)
  case class Pickup(var x: Double, var z: Double, val kind: String)

  class BattlePanel(name: String, mode: String, skin: String, heroIndex: Int, lan: LanSession, onReward: Int => Unit, onExit: () => Unit) extends JPanel {
    val keys = new HashSet[Int]()
    val rng = new Random()
    var px = 0.0
    var pz = 0.0
    var yaw = 0.0
    var health = 100
    var energy = 100
    var score = 0
    var taggedBots = 0
    var shieldTicks = 0
    var dashTicks = 0
    var jumpTicks = 0
    var pulseCooldown = 0
    var paused = false
    var finished = false
    var matchTicks = 0
    var rewardPaid = false
    var message = "Collect energy cells. Use F to send a harmless pulse-tag at rogue bots."
    val bots = ArrayBuffer[Bot]()
    val orbs = ArrayBuffer[Orb]()
    val pickups = ArrayBuffer[Pickup]()
    val timer = new Timer(33, new ActionListener { override def actionPerformed(e: ActionEvent): Unit = updateGame() })

    setFocusable(true)
    setBackground(new Color(8, 14, 31))
    setPreferredSize(new Dimension(1120, 650))
    resetWorld()

    def resetWorld(): Unit = {
      bots.clear(); orbs.clear(); pickups.clear()
      var i = 0
      while (i < (if (mode == "TRAINING") 5 else 10)) {
        val bx = (rng.nextDouble() * 760.0) - 380.0
        val bz = 260.0 + rng.nextDouble() * 1300.0
        bots += Bot(bx, bz, 2, 20 + rng.nextInt(30))
        i += 1
      }
      i = 0
      while (i < 18) {
        pickups += Pickup((rng.nextDouble() * 800.0) - 400.0, 180.0 + rng.nextDouble() * 1450.0, if (i % 4 == 0) "DIAMOND" else "BUCK")
        i += 1
      }
    }

    def startGame(): Unit = { timer.start(); requestFocusInWindow() }
    def stopGame(): Unit = { timer.stop(); keys.clear() }
    def statusText(): String = "HP " + health + "   ENERGY " + energy + "   TAGS " + taggedBots + "   BUCKS " + score

    addKeyListener(new KeyAdapter {
      override def keyPressed(e: KeyEvent): Unit = {
        keys += e.getKeyCode
        if (e.getKeyCode == KeyEvent.VK_F) usePulse()
        if (e.getKeyCode == KeyEvent.VK_Q) useShield()
        if (e.getKeyCode == KeyEvent.VK_SPACE) dash()
        if (e.getKeyCode == KeyEvent.VK_E) interact()
        if (e.getKeyCode == KeyEvent.VK_P || e.getKeyCode == KeyEvent.VK_ESCAPE) togglePause()
        if (e.getKeyCode == KeyEvent.VK_B) exitToLobby()
        if (e.getKeyCode == KeyEvent.VK_R && finished) {
          health = 100; energy = 100; score = 0; taggedBots = 0; matchTicks = 0
          finished = false; paused = false; rewardPaid = false; px = 0.0; pz = 0.0; yaw = 0.0
          resetWorld(); message = "NEW ROUND! COLLECT ENERGY CELLS AND TAG THE DRONES."
        }
      }
      override def keyReleased(e: KeyEvent): Unit = keys -= e.getKeyCode
    })

    addMouseListener(new MouseAdapter {
      override def mousePressed(e: MouseEvent): Unit = {
        requestFocusInWindow()
        if (e.getButton == MouseEvent.BUTTON1) usePulse()
      }
    })

    def togglePause(): Unit = { paused = !paused; message = if (paused) "PAUSED - press P to resume" else "Back in the arena!"; repaint() }
    def exitToLobby(): Unit = { stopGame(); if (lan != null) lan.closeSession(); onExit() }
    def dash(): Unit = { if (!paused && !finished && energy >= 8) { dashTicks = 12; energy -= 8; message = "NEON DASH!" } }
    def useShield(): Unit = { if (!paused && !finished && energy >= 15) { shieldTicks = 100; energy -= 15; message = "PRISM SHIELD ACTIVE" } }

    def usePulse(): Unit = {
      if (!paused && !finished && energy >= 10 && pulseCooldown <= 0) {
        val dx = Math.sin(yaw)
        val dz = Math.cos(yaw)
        orbs += Orb(px, pz, dx * 18.0, dz * 18.0, 45, true)
        energy -= 10
        pulseCooldown = 15
        message = "AURORA ENERGY PULSE RELEASED"
      }
    }

    def interact(): Unit = {
      var found = -1
      var i = 0
      while (i < pickups.length && found < 0) {
        val p = pickups(i)
        if (distance(px, pz, p.x, p.z) < 65.0) found = i
        i += 1
      }
      if (found >= 0) {
        val p = pickups.remove(found)
        if (p.kind == "DIAMOND") { message = "BIXUU DIAMOND CELL FOUND!" }
        else { score += 15; message = "BIXUU BUCKS +15!" }
      } else message = "Move close to an energy pickup and press E."
      repaint()
    }

    def distance(ax: Double, az: Double, bx: Double, bz: Double): Double = Math.sqrt((ax - bx) * (ax - bx) + (az - bz) * (az - bz))

    def updateGame(): Unit = {
      if (!paused && !finished) {
        matchTicks += 1
        if (keys.contains(KeyEvent.VK_LEFT)) yaw -= 0.055
        if (keys.contains(KeyEvent.VK_RIGHT)) yaw += 0.055
        val speed = if (dashTicks > 0) 8.5 else 4.0
        if (keys.contains(KeyEvent.VK_W) || keys.contains(KeyEvent.VK_UP)) { px += Math.sin(yaw) * speed; pz += Math.cos(yaw) * speed }
        if (keys.contains(KeyEvent.VK_S) || keys.contains(KeyEvent.VK_DOWN)) { px -= Math.sin(yaw) * speed; pz -= Math.cos(yaw) * speed }
        if (keys.contains(KeyEvent.VK_A)) { px -= Math.cos(yaw) * speed; pz += Math.sin(yaw) * speed }
        if (keys.contains(KeyEvent.VK_D)) { px += Math.cos(yaw) * speed; pz -= Math.sin(yaw) * speed }
        px = Math.max(-650.0, Math.min(650.0, px))
        pz = Math.max(-150.0, Math.min(1750.0, pz))
        if (dashTicks > 0) dashTicks -= 1
        if (jumpTicks > 0) jumpTicks -= 1
        if (shieldTicks > 0) shieldTicks -= 1
        if (pulseCooldown > 0) pulseCooldown -= 1
        if (energy < 100 && matchTicks % 5 == 0) energy = Math.min(100, energy + 1)

        var i = 0
        while (i < bots.length) {
          val b = bots(i)
          val dx = px - b.x
          val dz = pz - b.z
          val d = Math.sqrt(dx * dx + dz * dz)
          if (d > 70.0 && d < 1000.0) { b.x += dx / d * 0.85; b.z += dz / d * 0.85 }
          b.pulseDelay -= 1
          if (d < 185.0 && b.pulseDelay <= 0) {
            if (shieldTicks <= 0) health = Math.max(0, health - 4)
            b.pulseDelay = 38
            message = if (shieldTicks > 0) "SHIELD BLOCKED A DRONE TAG" else "A DRONE TAGGED YOU - KEEP MOVING"
          }
          i += 1
        }

        i = orbs.length - 1
        while (i >= 0) {
          val orb = orbs(i)
          orb.x += orb.vx
          orb.z += orb.vz
          orb.ttl -= 1
          var hit = -1
          var j = 0
          while (j < bots.length && hit < 0) {
            if (distance(orb.x, orb.z, bots(j).x, bots(j).z) < 38.0) hit = j
            j += 1
          }
          if (hit >= 0) {
            val b = bots(hit)
            b.hp -= 1
            if (b.hp <= 0) {
              val bx = b.x
              val bz = b.z
              bots.remove(hit)
              pickups += Pickup(bx, bz, "BUCK")
              taggedBots += 1
              score += 30
              message = "ROGUE DRONE TAGGED! +30 BIXUU BUCKS"
            }
            orbs.remove(i)
          } else if (orb.ttl <= 0) orbs.remove(i)
          i -= 1
        }

        if (lan != null && lan.running) {
          lan.updateLocal(px, pz, score)
          lan.broadcast()
        }
        if (health <= 0) {
          finished = true
          message = "ENERGY DEPLETED - PRESS R TO RETRY OR B FOR LOBBY"
          if (!rewardPaid) { rewardPaid = true; onReward(Math.max(0, score / 2)) }
        }
        if (mode != "TRAINING" && taggedBots >= 8) {
          finished = true
          message = "ARENA CLEARED! PRESS R TO PLAY AGAIN OR B FOR LOBBY"
          if (!rewardPaid) { rewardPaid = true; onReward(score + 100) }
        }
        if (matchTicks > 60 * 60 * 6 && mode == "TRAINING") { matchTicks = 0 }
        repaint()
      }
    }

    def project(wx: Double, wz: Double, height: Double = 0.0): (Int, Int, Double) = {
      val dx = wx - px
      val dz = wz - pz
      val c = Math.cos(yaw)
      val s = Math.sin(yaw)
      val rx = dx * c - dz * s
      val rz = dx * s + dz * c
      val depth = Math.max(20.0, rz + 250.0)
      val scale = 510.0 / depth
      val sx = (getWidth / 2.0 + rx * scale).toInt
      val horizon = (getHeight * 0.39).toInt
      val sy = (horizon + 205.0 * scale - height * scale).toInt
      (sx, sy, scale)
    }

    def drawTower(g: Graphics2D, wx: Double, wz: Double, tint: Color): Unit = {
      val p = project(wx, wz)
      val x = p._1
      val y = p._2
      val sc = p._3
      val bw = Math.max(4, (70 * sc).toInt)
      val bh = Math.max(8, (230 * sc).toInt)
      if (x > -bw && x < getWidth + bw && y > 0 && y < getHeight + bh) {
        g.setColor(new Color(tint.getRed, tint.getGreen, tint.getBlue, 165))
        g.fillRoundRect(x - bw / 2, y - bh, bw, bh, 8, 8)
        g.setColor(new Color(90, 220, 255, 170))
        g.drawLine(x - bw / 2, y - bh + 10, x - bw / 2, y)
        var row = 0
        while (row < 5) {
          g.setColor(if (row % 2 == 0) new Color(100, 230, 255, 170) else new Color(192, 124, 255, 170))
          g.fillRect(x - bw / 3, y - bh + 16 + row * Math.max(4, bh / 7), Math.max(2, bw / 6), Math.max(2, bh / 18))
          row += 1
        }
      }
    }

    def drawBot(g: Graphics2D, b: Bot): Unit = {
      val p = project(b.x, b.z, 0.0)
      val x = p._1
      val y = p._2
      val sc = p._3
      val r = Math.max(5, (24 * sc).toInt)
      if (x > -50 && x < getWidth + 50 && y > 0 && y < getHeight + 60) {
        g.setColor(new Color(255, 70, 130, 65))
        g.fillOval(x - r * 2, y - r * 2, r * 4, r * 4)
        g.setColor(new Color(55, 72, 112))
        g.fillRoundRect(x - r, y - r, r * 2, r * 2, r, r)
        g.setColor(new Color(255, 90, 145))
        g.fillOval(x - r / 2, y - r / 2, r, Math.max(3, r / 2))
        g.setColor(white)
        g.drawOval(x - r, y - r, r * 2, r * 2)
      }
    }

    def drawPickup(g: Graphics2D, p: Pickup): Unit = {
      val v = project(p.x, p.z, 12.0)
      val x = v._1; val y = v._2; val sc = v._3
      val r = Math.max(3, (11 * sc).toInt)
      if (x > -25 && x < getWidth + 25 && y > 0 && y < getHeight + 20) {
        g.setColor(if (p.kind == "DIAMOND") new Color(70, 230, 255) else gold)
        val poly = new Polygon(Array(x, x + r, x, x - r), Array(y - r, y, y + r, y), 4)
        g.fillPolygon(poly)
        g.setColor(white)
        g.drawPolygon(poly)
      }
    }

    def drawOrb(g: Graphics2D, o: Orb): Unit = {
      val p = project(o.x, o.z, 28.0)
      val r = Math.max(3, (9 * p._3).toInt)
      g.setColor(new Color(75, 235, 255, 100))
      g.fillOval(p._1 - r * 2, p._2 - r * 2, r * 4, r * 4)
      g.setColor(cyan)
      g.fillOval(p._1 - r, p._2 - r, r * 2, r * 2)
    }

    override def paintComponent(graphics: Graphics): Unit = {
      super.paintComponent(graphics)
      val g = graphics.create().asInstanceOf[Graphics2D]
      g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON)
      val w = getWidth
      val h = getHeight
      g.setPaint(new GradientPaint(0, 0, new Color(17, 32, 72), 0, h, new Color(8, 12, 28)))
      g.fillRect(0, 0, w, h)

      // distant neon skyline and sky lights
      var i = 0
      while (i < 100) {
        val sx = (i * 83) % Math.max(1, w)
        val sy = (i * 41) % Math.max(1, (h * 0.38).toInt)
        g.setColor(new Color(120, 205, 255, 100))
        g.fillOval(sx, sy, 2, 2)
        i += 1
      }
      g.setColor(new Color(44, 65, 125, 150))
      g.fillOval(w / 2 - 150, 35, 300, 115)
      g.setColor(new Color(65, 220, 255, 150))
      g.drawOval(w / 2 - 150, 35, 300, 115)

      val horizon = (h * 0.39).toInt
      g.setColor(new Color(21, 34, 67))
      g.fillRect(0, horizon, w, h - horizon)
      g.setColor(new Color(37, 63, 99))
      val road = new Polygon(Array(w / 2 - 80, w / 2 + 80, w + 130, -130), Array(horizon, horizon, h, h), 4)
      g.fillPolygon(road)
      g.setColor(new Color(65, 195, 229, 95))
      g.setStroke(new BasicStroke(2f))
      g.drawLine(w / 2 - 80, horizon, -100, h)
      g.drawLine(w / 2 + 80, horizon, w + 100, h)
      var line = 0
      while (line < 10) {
        val depth = 80 + line * 95.0
        val p = project(0, pz + depth)
        g.setColor(new Color(67, 155, 194, 50 + line * 7))
        g.drawLine(0, p._2, w, p._2)
        line += 1
      }

      // world towers (projected 3D-style)
      var t = 0
      while (t < 16) {
        val side = if (t % 2 == 0) -1.0 else 1.0
        val row = t / 2
        drawTower(g, side * (280 + (row % 3) * 65), pz + 250 + row * 155, if (t % 3 == 0) new Color(53, 91, 143) else new Color(35, 64, 110))
        t += 1
      }

      val orderedBots = bots.sortBy(b => -b.z)
      orderedBots.foreach(b => drawBot(g, b))
      pickups.foreach(p => drawPickup(g, p))
      orbs.foreach(o => drawOrb(g, o))

      // remote LAN players
      if (lan != null && lan.running) {
        lan.remotePlayers().foreach { peer =>
          val p = project(peer.x, peer.z, 0.0)
          val scale = Math.max(5, (22 * p._3).toInt)
          g.setColor(new Color(255, 205, 90, 170))
          g.fillOval(p._1 - scale / 2, p._2 - scale, scale, scale)
          g.setColor(gold)
          g.fillRoundRect(p._1 - scale / 3, p._2, scale * 2 / 3, scale, 8, 8)
          g.setFont(new Font("SansSerif", Font.BOLD, 10))
          g.drawString(peer.name, p._1 - 22, p._2 - scale - 5)
        }
      }

      // player's stylized avatar and energy device
      val jumpOffset = if (jumpTicks > 0) 25 else 0
      val cx = w / 2
      val cy = h - 112 - jumpOffset
      g.setColor(new Color(60, 220, 255, 45))
      g.fillOval(cx - 48, cy + 45, 96, 25)
      g.setColor(new Color(30, 52, 89))
      g.fillRoundRect(cx - 22, cy - 35, 44, 76, 15, 15)
      val heroColor = heroIndex match {
        case 0 => new Color(55, 220, 255)
        case 1 => new Color(186, 110, 255)
        case 2 => new Color(88, 255, 193)
        case _ => new Color(255, 179, 89)
      }
      g.setColor(heroColor)
      g.fillOval(cx - 18, cy - 68, 36, 36)
      g.setColor(new Color(221, 241, 255))
      g.fillRoundRect(cx - 13, cy - 29, 26, 55, 8, 8)
      g.setColor(new Color(65, 220, 255))
      g.fillRoundRect(cx + 18, cy - 18, 16, 33, 6, 6)
      g.setColor(gold)
      g.fillOval(cx + 20, cy - 23, 12, 12)
      g.setColor(white)
      g.setFont(new Font("SansSerif", Font.BOLD, 12))
      g.drawString(name, cx - 32, cy - 78)
      if (shieldTicks > 0) {
        g.setColor(new Color(100, 210, 255, 80))
        g.setStroke(new BasicStroke(3f))
        g.drawOval(cx - 43, cy - 79, 86, 140)
      }

      // HUD
      g.setColor(new Color(4, 11, 25, 205))
      g.fillRoundRect(12, 12, 330, 86, 14, 14)
      g.setColor(cyan)
      g.setFont(new Font("SansSerif", Font.BOLD, 14))
      g.drawString("BIXUU FIGHTING WORLD  |  " + mode, 25, 34)
      g.setColor(white)
      g.setFont(new Font("SansSerif", Font.PLAIN, 12))
      g.drawString("HP " + health + "   ENERGY " + energy + "   TAGS " + taggedBots, 25, 55)
      g.drawString("BUCKS " + score + "   GEAR " + skin, 25, 76)

      g.setColor(new Color(4, 11, 25, 210))
      g.fillRoundRect(w - 205, 14, 190, 78, 12, 12)
      g.setColor(gold)
      g.setFont(new Font("SansSerif", Font.BOLD, 12))
      g.drawString("ARENA RADAR", w - 184, 33)
      g.setColor(new Color(30, 57, 83))
      g.fillOval(w - 178, 41, 135, 42)
      g.setColor(aqua)
      g.fillOval(w - 112, 58, 7, 7)
      g.setColor(new Color(255, 92, 143))
      bots.foreach { b =>
        val rx = w - 112 + ((b.x - px) / 15.0).toInt
        val rz = 62 - ((b.z - pz) / 40.0).toInt
        if (rx > w - 175 && rx < w - 48 && rz > 43 && rz < 80) g.fillOval(rx, rz, 5, 5)
      }

      g.setColor(new Color(4, 11, 25, 200))
      g.fillRoundRect(12, h - 49, w - 24, 36, 10, 10)
      g.setColor(gold)
      g.setFont(new Font("SansSerif", Font.BOLD, 12))
      g.drawString(message, 24, h - 26)
      g.setColor(muted)
      g.drawString("WASD MOVE  ?  ARROWS TURN  ?  F PULSE TAG  ?  SPACE DASH  ?  E PICKUP  ?  P PAUSE", Math.max(340, w - 690), h - 26)

      if (paused || finished) {
        g.setColor(new Color(2, 5, 15, 190))
        g.fillRect(0, 0, w, h)
        g.setColor(if (finished && health > 0) aqua else white)
        g.setFont(new Font("SansSerif", Font.BOLD, 34))
        val title = if (finished && health > 0) "ARENA CLEARED!" else if (health <= 0) "ENERGY DEPLETED" else "PAUSED"
        val tw = g.getFontMetrics.stringWidth(title)
        g.drawString(title, (w - tw) / 2, h / 2 - 8)
        g.setFont(new Font("SansSerif", Font.PLAIN, 15))
        g.setColor(white)
        val msg = if (finished) "Press R to restart or B to return to lobby" else "Press P to resume"
        g.drawString(msg, (w - g.getFontMetrics.stringWidth(msg)) / 2, h / 2 + 28)
      }
      g.dispose()
    }
  }
}

BixuuFightingWorld.main(Array[String]())