Refactored localization stuff into a single class. Decided I didn't like those duplicate strings flying around all over the place.

src/main/scala/li/cil/oc/Localization.scala

@@ -0,0 +1,109 @@
+package li.cil.oc
+
+import cpw.mods.fml.common.event.FMLFingerprintViolationEvent
+import net.minecraft.util.{ChatMessageComponent, StatCollector}
+
+object Localization {
+  private def resolveKey(key: String) = if (StatCollector.func_94522_b(Settings.namespace + key)) Settings.namespace + key else key
+
+  def localizeLater(formatKey: String, values: AnyRef*) = ChatMessageComponent.createFromTranslationWithSubstitutions(resolveKey(formatKey), values: _*)
+
+  def localizeLater(key: String) = ChatMessageComponent.createFromTranslationKey(resolveKey(key))
+
+  def localizeImmediately(formatKey: String, values: AnyRef*) = StatCollector.translateToLocalFormatted(resolveKey(formatKey), values: _*)
+
+  def localizeImmediately(key: String) = StatCollector.translateToLocal(resolveKey(key))
+
+  object Analyzer {
+    def Address(value: String) = localizeLater("gui.Analyzer.Address", value)
+
+    def AddressCopied = localizeLater("gui.Analyzer.AddressCopied")
+
+    def ChargerSpeed(value: Double) = localizeLater("gui.Analyzer.ChargerSpeed", (value * 100).toInt + "%")
+
+    def ComponentName(value: String) = localizeLater("gui.Analyzer.ComponentName", value)
+
+    def Components(count: Int, maxCount: Int) = localizeLater("gui.Analyzer.Components", count + "/" + maxCount)
+
+    def LastError(value: String) = localizeLater("gui.Analyzer.LastError", localizeLater(value))
+
+    def RobotOwner(owner: String) = localizeLater("gui.Analyzer.RobotOwner", owner)
+
+    def RobotName(name: String) = localizeLater("gui.Analyzer.RobotName", name)
+
+    def RobotXp(experience: Double, level: Int) = localizeLater("gui.Analyzer.RobotXp", "%.2f".format(experience), level.toString)
+
+    def StoredEnergy(value: String) = localizeLater("gui.Analyzer.StoredEnergy", value)
+
+    def TotalEnergy(value: String) = localizeLater("gui.Analyzer.TotalEnergy", value)
+
+    def Users(list: Iterable[String]) = localizeLater("gui.Analyzer.Users", list.mkString(", "))
+
+    def WirelessStrength(value: Double) = localizeLater("gui.Analyzer.WirelessStrength", value.toInt.toString)
+  }
+
+  object Chat {
+    def WarningLuaFallback = ChatMessageComponent.createFromText("§aOpenComputers§f: ").appendComponent(localizeLater("gui.Chat.WarningLuaFallback"))
+
+    def WarningProjectRed = ChatMessageComponent.createFromText("§aOpenComputers§f: ").appendComponent(localizeLater("gui.Chat.WarningProjectRed"))
+
+    def WarningPower = ChatMessageComponent.createFromText("§aOpenComputers§f: ").appendComponent(localizeLater("gui.Chat.WarningPower"))
+
+    def WarningFingerprint(event: FMLFingerprintViolationEvent) = ChatMessageComponent.createFromText("§aOpenComputers§f: ").appendComponent(localizeLater("gui.Chat.WarningFingerprint", event.expectedFingerprint, event.fingerprints.toArray.mkString(", ")))
+  }
+
+  object Robot {
+    def TurnOff = localizeImmediately("gui.Robot.TurnOff")
+
+    def TurnOn = localizeImmediately("gui.Robot.TurnOn")
+
+    def Power = localizeImmediately("gui.Robot.Power")
+  }
+
+  object RobotAssembler {
+    def InsertCase = localizeImmediately("gui.RobotAssembler.InsertCase")
+
+    def InsertCPU = localizeImmediately("gui.RobotAssembler.InsertCPU")
+
+    def InsertRAM = localizeImmediately("gui.RobotAssembler.InsertRAM")
+
+    def Complexity(complexity: Int, maxComplexity: Int) = localizeImmediately("gui.RobotAssembler.Complexity", complexity.toString, maxComplexity.toString)
+
+    def Run = localizeImmediately("gui.RobotAssembler.Run")
+
+    def CollectRobot = localizeImmediately("gui.RobotAssembler.CollectRobot")
+
+    def Progress(progress: Double, timeRemaining: String) = localizeImmediately("gui.RobotAssembler.Progress", progress.toInt.toString, timeRemaining)
+
+    def Warning(name: String) = "§7- " + localizeImmediately("gui.RobotAssembler.Warning." + name)
+
+    def Warnings = localizeImmediately("gui.RobotAssembler.Warnings")
+  }
+
+  object ServerRack {
+    def Top = localizeImmediately("gui.ServerRack.Top")
+
+    def Bottom = localizeImmediately("gui.ServerRack.Bottom")
+
+    def Left = localizeImmediately("gui.ServerRack.Left")
+
+    def Right = localizeImmediately("gui.ServerRack.Right")
+
+    def Back = localizeImmediately("gui.ServerRack.Back")
+
+    def None = localizeImmediately("gui.ServerRack.None")
+
+    def WirelessRange = localizeImmediately("gui.ServerRack.WirelessRange")
+  }
+
+  object Terminal {
+    def InvalidKey = localizeImmediately("gui.Terminal.InvalidKey")
+
+    def OutOfRange = localizeImmediately("gui.Terminal.OutOfRange")
+  }
+
+  object Tooltip {
+    def Materials = localizeImmediately("tooltip.Materials")
+  }
+
+}

src/main/scala/li/cil/oc/client/GuiHandler.scala

@@ -2,10 +2,9 @@ package li.cil.oc.client
 
 import li.cil.oc.common.inventory.ServerInventory
 import li.cil.oc.common.{GuiType, item, tileentity, GuiHandler => CommonGuiHandler}
-import li.cil.oc.{Items, Settings}
+import li.cil.oc.{Items, Localization, Settings}
 import net.minecraft.client.Minecraft
 import net.minecraft.entity.player.EntityPlayer
-import net.minecraft.util.StatCollector
 import net.minecraft.world.World
 
 object GuiHandler extends CommonGuiHandler {
@@ -60,10 +59,10 @@ object GuiHandler extends CommonGuiHandler {
                       }
                       true
                     })
-                    else player.addChatMessage(StatCollector.translateToLocal(Settings.namespace + "gui.Terminal.InvalidKey"))
+                    else player.addChatMessage(Localization.Terminal.InvalidKey)
                   }
-                  else player.addChatMessage(StatCollector.translateToLocal(Settings.namespace + "gui.Terminal.OutOfRange"))
+                  else player.addChatMessage(Localization.Terminal.OutOfRange)
-                case _ => player.addChatMessage(StatCollector.translateToLocal(Settings.namespace + "gui.Terminal.OutOfRange"))
+                case _ => player.addChatMessage(Localization.Terminal.OutOfRange)
               }
             }
           }

src/main/scala/li/cil/oc/client/PacketHandler.scala

@@ -1,7 +1,7 @@
 package li.cil.oc.client
 
 import cpw.mods.fml.common.network.Player
-import li.cil.oc.Settings
+import li.cil.oc.{Localization, Settings}
 import li.cil.oc.api.component
 import li.cil.oc.common.tileentity._
 import li.cil.oc.common.tileentity.traits._
@@ -68,8 +68,7 @@ class PacketHandler extends CommonPacketHandler {
     val address = p.readUTF()
     if (Keyboard.isKeyDown(Keyboard.KEY_LCONTROL) || Keyboard.isKeyDown(Keyboard.KEY_LCONTROL)) {
       GuiScreen.setClipboardString(address)
-      player.sendChatToPlayer(ChatMessageComponent.createFromTranslationKey(
+      player.sendChatToPlayer(Localization.Analyzer.AddressCopied)
-        Settings.namespace + "gui.Analyzer.AddressCopied"))
     }
   }
 

src/main/scala/li/cil/oc/client/gui/Case.scala

@@ -2,7 +2,7 @@ package li.cil.oc.client.gui
 
 import java.util
 
-import li.cil.oc.Settings
+import li.cil.oc.Localization
 import li.cil.oc.client.{Textures, PacketSender => ClientPacketSender}
 import li.cil.oc.common.{container, tileentity}
 import net.minecraft.client.gui.GuiButton
@@ -40,8 +40,7 @@ class Case(playerInventory: InventoryPlayer, val computer: tileentity.Case) exte
       8, 6, 0x404040)
     if (powerButton.func_82252_a) {
       val tooltip = new java.util.ArrayList[String]
-      val which = if (computer.isRunning) "gui.Robot.TurnOff" else "gui.Robot.TurnOn"
+      tooltip.add(if (computer.isRunning) Localization.Robot.TurnOff else Localization.Robot.TurnOn)
-      tooltip.add(StatCollector.translateToLocal(Settings.namespace + which))
       copiedDrawHoveringText(tooltip, mouseX - guiLeft, mouseY - guiTop, fontRenderer)
     }
     GL11.glPopAttrib()

src/main/scala/li/cil/oc/client/gui/Rack.scala

@@ -2,9 +2,9 @@ package li.cil.oc.client.gui
 
 import java.util
 
-import li.cil.oc.Settings
 import li.cil.oc.client.{Textures, PacketSender => ClientPacketSender}
 import li.cil.oc.common.{container, tileentity}
+import li.cil.oc.{Localization, Settings}
 import net.minecraft.client.gui.{GuiButton, GuiScreen}
 import net.minecraft.client.renderer.Tessellator
 import net.minecraft.entity.player.InventoryPlayer
@@ -19,14 +19,14 @@ class Rack(playerInventory: InventoryPlayer, val rack: tileentity.Rack) extends
 
   protected var rangeButtons = new Array[GuiButton](2)
 
-  def sideName(number: Int) = StatCollector.translateToLocal(Settings.namespace + (rack.sides(number) match {
+  def sideName(number: Int) = rack.sides(number) match {
-    case ForgeDirection.UP => "gui.ServerRack.Top"
+    case ForgeDirection.UP => Localization.ServerRack.Top
-    case ForgeDirection.DOWN => "gui.ServerRack.Bottom"
+    case ForgeDirection.DOWN => Localization.ServerRack.Bottom
-    case ForgeDirection.EAST => "gui.ServerRack.Left"
+    case ForgeDirection.EAST => Localization.ServerRack.Left
-    case ForgeDirection.WEST => "gui.ServerRack.Right"
+    case ForgeDirection.WEST => Localization.ServerRack.Right
-    case ForgeDirection.NORTH => "gui.ServerRack.Back"
+    case ForgeDirection.NORTH => Localization.ServerRack.Back
-    case _ => "gui.ServerRack.None"
+    case _ => Localization.ServerRack.None
-  }))
+  }
 
   def add[T](list: util.List[T], value: Any) = list.add(value.asInstanceOf[T])
 
@@ -91,9 +91,7 @@ class Rack(playerInventory: InventoryPlayer, val rack: tileentity.Rack) extends
       StatCollector.translateToLocal(rack.getInvName),
       8, 6, 0x404040)
 
-    fontRenderer.drawString(
+    fontRenderer.drawString(Localization.ServerRack.WirelessRange, 8, 31, 0x404040)
-      StatCollector.translateToLocal(Settings.namespace + "gui.ServerRack.WirelessRange"),
-      8, 31, 0x404040)
 
     {
       // Background for range value.
@@ -120,8 +118,7 @@ class Rack(playerInventory: InventoryPlayer, val rack: tileentity.Rack) extends
 
     for (i <- 0 to 3 if powerButtons(i).func_82252_a) {
       val tooltip = new java.util.ArrayList[String]
-      val which = if (rack.isRunning(i)) "gui.Robot.TurnOff" else "gui.Robot.TurnOn"
+      tooltip.add(if (rack.isRunning(i)) Localization.Robot.TurnOff else Localization.Robot.TurnOn)
-      tooltip.add(StatCollector.translateToLocal(Settings.namespace + which))
       copiedDrawHoveringText(tooltip, mouseX - guiLeft, mouseY - guiTop, fontRenderer)
     }
 

src/main/scala/li/cil/oc/client/gui/Robot.scala

@@ -2,7 +2,6 @@ package li.cil.oc.client.gui
 
 import java.util
 
-import li.cil.oc.{Settings, api}
 import li.cil.oc.client.renderer.TextBufferRenderCache
 import li.cil.oc.client.renderer.gui.BufferRenderer
 import li.cil.oc.client.{Textures, PacketSender => ClientPacketSender}
@@ -10,13 +9,13 @@ import li.cil.oc.common.container.StaticComponentSlot
 import li.cil.oc.common.{container, tileentity}
 import li.cil.oc.server.driver
 import li.cil.oc.util.RenderState
+import li.cil.oc.{Localization, api}
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiButton
 import net.minecraft.client.renderer.Tessellator
 import net.minecraft.client.renderer.texture.TextureMap
 import net.minecraft.entity.player.InventoryPlayer
 import net.minecraft.inventory.Slot
-import net.minecraft.util.StatCollector
 import org.lwjgl.input.{Keyboard, Mouse}
 import org.lwjgl.opengl.GL11
 
@@ -141,7 +140,7 @@ class Robot(playerInventory: InventoryPlayer, val robot: tileentity.Robot) exten
     GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS) // Me lazy... prevents NEI render glitch.
     if (isPointInRegion(powerX, powerY, powerWidth, powerHeight, mouseX, mouseY)) {
       val tooltip = new java.util.ArrayList[String]
-      val format = StatCollector.translateToLocal(Settings.namespace + "gui.Robot.Power") + ": %d%% (%d/%d)"
+      val format = Localization.Robot.Power + ": %d%% (%d/%d)"
       tooltip.add(format.format(
         ((robot.globalBuffer / robot.globalBufferSize) * 100).toInt,
         robot.globalBuffer.toInt,
@@ -150,8 +149,7 @@ class Robot(playerInventory: InventoryPlayer, val robot: tileentity.Robot) exten
     }
     if (powerButton.func_82252_a) {
       val tooltip = new java.util.ArrayList[String]
-      val which = if (robot.isRunning) "gui.Robot.TurnOff" else "gui.Robot.TurnOn"
+      tooltip.add(if (robot.isRunning) Localization.Robot.TurnOff else Localization.Robot.TurnOn)
-      tooltip.add(StatCollector.translateToLocal(Settings.namespace + which))
       copiedDrawHoveringText(tooltip, mouseX - guiLeft, mouseY - guiTop, fontRenderer)
     }
     GL11.glPopAttrib()

src/main/scala/li/cil/oc/client/gui/RobotAssembler.scala

@@ -2,14 +2,13 @@ package li.cil.oc.client.gui
 
 import java.util
 
-import li.cil.oc.{Settings, api}
 import li.cil.oc.api.driver.{Inventory, Memory, Processor, Slot}
 import li.cil.oc.client.{Textures, PacketSender => ClientPacketSender}
 import li.cil.oc.common.{container, tileentity}
+import li.cil.oc.{Localization, api}
 import net.minecraft.client.gui.GuiButton
 import net.minecraft.client.renderer.Tessellator
 import net.minecraft.entity.player.InventoryPlayer
-import net.minecraft.util.StatCollector
 import org.lwjgl.opengl.GL11
 
 import scala.collection.convert.WrapAsJava._
@@ -106,39 +105,35 @@ class RobotAssembler(playerInventory: InventoryPlayer, val assembler: tileentity
     GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS) // Me lazy... prevents NEI render glitch.
     if (!assemblerContainer.isAssembling) {
       def drawMessage(message: String) {
-        fontRenderer.drawString(
+        fontRenderer.drawString(message, 30, 94, 0x404040)
-          StatCollector.translateToLocal(Settings.namespace + message),
-          30, 94, 0x404040)
       }
       if (!inventorySlots.getSlot(0).getHasStack) {
-        drawMessage("gui.RobotAssembler.InsertCase")
+        drawMessage(Localization.RobotAssembler.InsertCase)
       }
       else if (api.Items.get(inventorySlots.getSlot(0).getStack) == api.Items.get("robot")) {
-        drawMessage("gui.RobotAssembler.CollectRobot")
+        drawMessage(Localization.RobotAssembler.CollectRobot)
       }
       else if (!hasCPU) {
-        drawMessage("gui.RobotAssembler.InsertCPU")
+        drawMessage(Localization.RobotAssembler.InsertCPU)
       }
       else if (!hasRAM) {
-        drawMessage("gui.RobotAssembler.InsertRAM")
+        drawMessage(Localization.RobotAssembler.InsertRAM)
       }
       else {
-        fontRenderer.drawString(
+        fontRenderer.drawString(Localization.RobotAssembler.Complexity(assembler.complexity, assembler.maxComplexity), 30, 94, if (isCapacityValid) 0x404040 else 0x804040)
-          StatCollector.translateToLocalFormatted(Settings.namespace + "gui.RobotAssembler.Complexity", Int.box(assembler.complexity), Int.box(assembler.maxComplexity)),
-          30, 94, if (isCapacityValid) 0x404040 else 0x804040)
       }
       if (runButton.func_82252_a) {
         val tooltip = new java.util.ArrayList[String]
-        tooltip.add(StatCollector.translateToLocal(Settings.namespace + "gui.RobotAssembler.Run"))
+        tooltip.add(Localization.RobotAssembler.Run)
         if (canBuild) {
           var warnings = mutable.ArrayBuffer.empty[String]
           for ((name, check) <- suggestedComponents) {
             if (!check()) {
-              warnings += "§7- " + StatCollector.translateToLocal(Settings.namespace + "gui.RobotAssembler.Warning." + name)
+              warnings += Localization.RobotAssembler.Warning(name)
             }
           }
           if (warnings.length > 0) {
-            tooltip.add(StatCollector.translateToLocalFormatted(Settings.namespace + "gui.RobotAssembler.Warnings"))
+            tooltip.add(Localization.RobotAssembler.Warnings)
             tooltip.addAll(warnings)
           }
         }
@@ -148,7 +143,7 @@ class RobotAssembler(playerInventory: InventoryPlayer, val assembler: tileentity
     else if (isPointInRegion(progressX, progressY, progressWidth, progressHeight, mouseX, mouseY)) {
       val tooltip = new java.util.ArrayList[String]
       val timeRemaining = formatTime(assemblerContainer.assemblyRemainingTime)
-      tooltip.add(StatCollector.translateToLocalFormatted(Settings.namespace + "gui.RobotAssembler.Progress", assemblerContainer.assemblyProgress.toInt.toString, timeRemaining))
+      tooltip.add(Localization.RobotAssembler.Progress(assemblerContainer.assemblyProgress, timeRemaining))
       copiedDrawHoveringText(tooltip, mouseX - guiLeft, mouseY - guiTop, fontRenderer)
     }
     GL11.glPopAttrib()

src/main/scala/li/cil/oc/common/ConnectionHandler.scala

@@ -3,28 +3,27 @@ package li.cil.oc.common
 import cpw.mods.fml.common.network.{IConnectionHandler, Player}
 import li.cil.oc.util.LuaStateFactory
 import li.cil.oc.util.mods.{Mods, ProjectRed}
-import li.cil.oc.{OpenComputers, Settings, UpdateCheck}
+import li.cil.oc.{Localization, OpenComputers, Settings, UpdateCheck}
 import net.minecraft.entity.player.EntityPlayerMP
 import net.minecraft.network.packet.{NetHandler, Packet1Login}
 import net.minecraft.network.{INetworkManager, NetLoginHandler}
 import net.minecraft.server.MinecraftServer
-import net.minecraft.util.ChatMessageComponent
 
 object ConnectionHandler extends IConnectionHandler {
   def playerLoggedIn(player: Player, netHandler: NetHandler, manager: INetworkManager) {
     if (netHandler.isServerHandler) player match {
       case p: EntityPlayerMP =>
         if (!LuaStateFactory.isAvailable) {
-          p.sendChatToPlayer(ChatMessageComponent.createFromText("§aOpenComputers§f: ").addKey(Settings.namespace + "gui.Chat.WarningLuaFallback"))
+          p.sendChatToPlayer(Localization.Chat.WarningLuaFallback)
         }
         if (Mods.ProjectRed.isAvailable && !ProjectRed.isAPIAvailable) {
-          p.sendChatToPlayer(ChatMessageComponent.createFromText("§aOpenComputers§f: ").addKey(Settings.namespace + "gui.Chat.WarningProjectRed"))
+          p.sendChatToPlayer(Localization.Chat.WarningProjectRed)
         }
         if (!Settings.get.pureIgnorePower && Settings.get.ignorePower) {
-          p.sendChatToPlayer(ChatMessageComponent.createFromText("§aOpenComputers§f: ").addKey(Settings.namespace + "gui.Chat.WarningPower"))
+          p.sendChatToPlayer(Localization.Chat.WarningPower)
         }
         OpenComputers.tampered match {
-          case Some(event) => p.sendChatToPlayer(ChatMessageComponent.createFromText("§aOpenComputers§f: ").addFormatted(Settings.namespace + "gui.Chat.WarningFingerprint", event.expectedFingerprint, event.fingerprints.toArray.mkString(", ")))
+          case Some(event) => p.sendChatToPlayer(Localization.Chat.WarningFingerprint(event))
           case _ =>
         }
         // Do update check in local games and for OPs.

src/main/scala/li/cil/oc/common/block/AccessPoint.scala

@@ -3,15 +3,15 @@ package li.cil.oc.common.block
 import java.util
 
 import cpw.mods.fml.common.Optional
-import li.cil.oc.Settings
 import li.cil.oc.common.tileentity
 import li.cil.oc.util.Tooltip
+import li.cil.oc.{Localization, Settings}
 import mcp.mobius.waila.api.{IWailaConfigHandler, IWailaDataAccessor}
 import net.minecraft.client.renderer.texture.IconRegister
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.ItemStack
 import net.minecraft.nbt.NBTTagCompound
-import net.minecraft.util.{Icon, StatCollector}
+import net.minecraft.util.Icon
 import net.minecraft.world.World
 import net.minecraftforge.common.ForgeDirection
 
@@ -31,12 +31,10 @@ class AccessPoint(val parent: SimpleDelegator) extends SimpleDelegate {
     val nbt = accessor.getNBTData
     val node = nbt.getTagList(Settings.namespace + "componentNodes").tagAt(accessor.getSide.ordinal).asInstanceOf[NBTTagCompound]
     if (node.hasKey("address")) {
-      tooltip.add(StatCollector.translateToLocalFormatted(
+      tooltip.add(Localization.Analyzer.Address(node.getString("address")).toString)
-        Settings.namespace + "gui.Analyzer.Address", node.getString("address")))
     }
     if (nbt.hasKey(Settings.namespace + "strength")) {
-      tooltip.add(StatCollector.translateToLocalFormatted(
+      tooltip.add(Localization.Analyzer.WirelessStrength(nbt.getDouble(Settings.namespace + "strength")).toString)
-        Settings.namespace + "gui.Analyzer.WirelessStrength", nbt.getDouble(Settings.namespace + "strength").toInt.toString))
     }
   }
 

src/main/scala/li/cil/oc/common/block/Capacitor.scala

@@ -3,14 +3,14 @@ package li.cil.oc.common.block
 import java.util
 
 import cpw.mods.fml.common.Optional
-import li.cil.oc.Settings
 import li.cil.oc.common.tileentity
 import li.cil.oc.util.Tooltip
+import li.cil.oc.{Localization, Settings}
 import mcp.mobius.waila.api.{IWailaConfigHandler, IWailaDataAccessor}
 import net.minecraft.client.renderer.texture.IconRegister
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.ItemStack
-import net.minecraft.util.{Icon, StatCollector}
+import net.minecraft.util.Icon
 import net.minecraft.world.{IBlockAccess, World}
 import net.minecraftforge.common.ForgeDirection
 
@@ -29,8 +29,7 @@ class Capacitor(val parent: SimpleDelegator) extends SimpleDelegate {
   override def wailaBody(stack: ItemStack, tooltip: util.List[String], accessor: IWailaDataAccessor, config: IWailaConfigHandler) {
     val node = accessor.getNBTData.getCompoundTag(Settings.namespace + "node")
     if (node.hasKey("buffer")) {
-      tooltip.add(StatCollector.translateToLocalFormatted(
+      tooltip.add(Localization.Analyzer.StoredEnergy(node.getDouble("buffer").toInt.toString).toString)
-        Settings.namespace + "gui.Analyzer.StoredEnergy", node.getDouble("buffer").toInt.toString))
     }
   }
 

src/main/scala/li/cil/oc/common/block/Case.scala

@@ -7,12 +7,12 @@ import cpw.mods.fml.relauncher.{Side, SideOnly}
 import li.cil.oc.common.{GuiType, tileentity}
 import li.cil.oc.util.mods.BuildCraft
 import li.cil.oc.util.{Color, Tooltip}
-import li.cil.oc.{OpenComputers, Settings}
+import li.cil.oc.{Localization, OpenComputers, Settings}
 import mcp.mobius.waila.api.{IWailaConfigHandler, IWailaDataAccessor}
 import net.minecraft.client.renderer.texture.IconRegister
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.{EnumRarity, ItemStack}
-import net.minecraft.util.{Icon, StatCollector}
+import net.minecraft.util.Icon
 import net.minecraft.world.{IBlockAccess, World}
 import net.minecraftforge.common.ForgeDirection
 
@@ -41,8 +41,7 @@ abstract class Case(val parent: SimpleDelegator) extends RedstoneAware with Simp
     val nbt = accessor.getNBTData
     val node = nbt.getCompoundTag(Settings.namespace + "computer").getCompoundTag("node")
     if (node.hasKey("address")) {
-      tooltip.add(StatCollector.translateToLocalFormatted(
+      tooltip.add(Localization.Analyzer.Address(node.getString("address")).toString)
-        Settings.namespace + "gui.Analyzer.Address", node.getString("address")))
     }
   }
 

src/main/scala/li/cil/oc/common/block/Charger.scala

@@ -4,17 +4,17 @@ import java.util
 
 import cpw.mods.fml.common.Optional
 import cpw.mods.fml.relauncher.{Side, SideOnly}
-import li.cil.oc.Settings
 import li.cil.oc.client.Textures
 import li.cil.oc.common.tileentity
 import li.cil.oc.server.PacketSender
 import li.cil.oc.util.Tooltip
 import li.cil.oc.util.mods.BuildCraft
+import li.cil.oc.{Localization, Settings}
 import mcp.mobius.waila.api.{IWailaConfigHandler, IWailaDataAccessor}
 import net.minecraft.client.renderer.texture.IconRegister
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.ItemStack
-import net.minecraft.util.{Icon, StatCollector}
+import net.minecraft.util.Icon
 import net.minecraft.world.{IBlockAccess, World}
 import net.minecraftforge.common.ForgeDirection
 
@@ -31,9 +31,7 @@ class Charger(val parent: SimpleDelegator) extends RedstoneAware with SimpleDele
   override def wailaBody(stack: ItemStack, tooltip: util.List[String], accessor: IWailaDataAccessor, config: IWailaConfigHandler) {
     accessor.getTileEntity match {
       case charger: tileentity.Charger =>
-        tooltip.add(StatCollector.translateToLocalFormatted(
+        tooltip.add(Localization.Analyzer.ChargerSpeed(charger.chargeSpeed).toString)
-          Settings.namespace + "gui.Analyzer.ChargerSpeed",
-          (charger.chargeSpeed * 100).toInt + "%"))
       case _ =>
     }
   }

src/main/scala/li/cil/oc/common/block/DiskDrive.scala

@@ -6,13 +6,13 @@ import cpw.mods.fml.common.Optional
 import li.cil.oc.common.{GuiType, tileentity}
 import li.cil.oc.util.Tooltip
 import li.cil.oc.util.mods.Mods
-import li.cil.oc.{OpenComputers, Settings}
+import li.cil.oc.{Localization, OpenComputers, Settings}
 import mcp.mobius.waila.api.{IWailaConfigHandler, IWailaDataAccessor}
 import net.minecraft.client.renderer.texture.IconRegister
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.ItemStack
 import net.minecraft.nbt.NBTTagCompound
-import net.minecraft.util.{Icon, StatCollector}
+import net.minecraft.util.Icon
 import net.minecraft.world.World
 import net.minecraftforge.common.ForgeDirection
 
@@ -40,8 +40,7 @@ class DiskDrive(val parent: SimpleDelegator) extends SimpleDelegate {
         getCompoundTag(Settings.namespace + "data").
         getCompoundTag("node")
       if (node.hasKey("address")) {
-        tooltip.add(StatCollector.translateToLocalFormatted(
+        tooltip.add(Localization.Analyzer.Address(node.getString("address")).toString)
-          Settings.namespace + "gui.Analyzer.Address", node.getString("address")))
       }
     }
   }

src/main/scala/li/cil/oc/common/block/Hologram.scala

@@ -4,14 +4,14 @@ import java.util
 
 import cpw.mods.fml.common.Optional
 import cpw.mods.fml.relauncher.{Side, SideOnly}
-import li.cil.oc.Settings
 import li.cil.oc.common.tileentity
 import li.cil.oc.util.Tooltip
+import li.cil.oc.{Localization, Settings}
 import mcp.mobius.waila.api.{IWailaConfigHandler, IWailaDataAccessor}
 import net.minecraft.client.renderer.texture.IconRegister
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.{EnumRarity, ItemStack}
-import net.minecraft.util.{AxisAlignedBB, Icon, StatCollector}
+import net.minecraft.util.{AxisAlignedBB, Icon}
 import net.minecraft.world.{IBlockAccess, World}
 import net.minecraftforge.common.ForgeDirection
 
@@ -30,8 +30,7 @@ abstract class Hologram(val parent: SpecialDelegator) extends SpecialDelegate {
   override def wailaBody(stack: ItemStack, tooltip: util.List[String], accessor: IWailaDataAccessor, config: IWailaConfigHandler) {
     val node = accessor.getNBTData.getCompoundTag(Settings.namespace + "node")
     if (node.hasKey("address")) {
-      tooltip.add(StatCollector.translateToLocalFormatted(
+      tooltip.add(Localization.Analyzer.Address(node.getString("address")).toString)
-        Settings.namespace + "gui.Analyzer.Address", node.getString("address")))
     }
   }
 

src/main/scala/li/cil/oc/common/block/Item.scala

@@ -2,9 +2,9 @@ package li.cil.oc.common.block
 
 import java.util
 
-import li.cil.oc.{Settings, api}
 import li.cil.oc.common.tileentity
 import li.cil.oc.util.ItemUtils
+import li.cil.oc.{Settings, api}
 import net.minecraft.block.Block
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.{EnumRarity, ItemBlock, ItemStack}

src/main/scala/li/cil/oc/common/block/Keyboard.scala

@@ -3,14 +3,14 @@ package li.cil.oc.common.block
 import java.util
 
 import cpw.mods.fml.common.Optional
-import li.cil.oc.Settings
 import li.cil.oc.common.tileentity
 import li.cil.oc.util.Tooltip
+import li.cil.oc.{Localization, Settings}
 import mcp.mobius.waila.api.{IWailaConfigHandler, IWailaDataAccessor}
 import net.minecraft.client.renderer.texture.IconRegister
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.ItemStack
-import net.minecraft.util.{AxisAlignedBB, Icon, StatCollector}
+import net.minecraft.util.{AxisAlignedBB, Icon}
 import net.minecraft.world.{IBlockAccess, World}
 import net.minecraftforge.common.ForgeDirection
 import org.lwjgl.opengl.GL11
@@ -28,8 +28,7 @@ class Keyboard(val parent: SpecialDelegator) extends SpecialDelegate {
   override def wailaBody(stack: ItemStack, tooltip: util.List[String], accessor: IWailaDataAccessor, config: IWailaConfigHandler) {
     val node = accessor.getNBTData.getCompoundTag(Settings.namespace + "keyboard").getCompoundTag("node")
     if (node.hasKey("address")) {
-      tooltip.add(StatCollector.translateToLocalFormatted(
+      tooltip.add(Localization.Analyzer.Address(node.getString("address")).toString)
-        Settings.namespace + "gui.Analyzer.Address", node.getString("address")))
     }
   }
 

src/main/scala/li/cil/oc/common/block/Screen.scala

@@ -7,14 +7,14 @@ import cpw.mods.fml.relauncher.{Side, SideOnly}
 import li.cil.oc.common.{GuiType, tileentity}
 import li.cil.oc.util.mods.BuildCraft
 import li.cil.oc.util.{Color, PackedColor, Tooltip}
-import li.cil.oc.{OpenComputers, Settings}
+import li.cil.oc.{Localization, OpenComputers, Settings}
 import mcp.mobius.waila.api.{IWailaConfigHandler, IWailaDataAccessor}
 import net.minecraft.client.renderer.texture.IconRegister
 import net.minecraft.entity.Entity
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.entity.projectile.EntityArrow
 import net.minecraft.item.{EnumRarity, ItemStack}
-import net.minecraft.util.{Icon, StatCollector}
+import net.minecraft.util.Icon
 import net.minecraft.world.{IBlockAccess, World}
 import net.minecraftforge.common.ForgeDirection
 
@@ -39,8 +39,7 @@ abstract class Screen(val parent: SimpleDelegator) extends RedstoneAware with Si
   override def wailaBody(stack: ItemStack, tooltip: util.List[String], accessor: IWailaDataAccessor, config: IWailaConfigHandler) {
     val node = accessor.getNBTData.getCompoundTag("node")
     if (node.hasKey("address")) {
-      tooltip.add(StatCollector.translateToLocalFormatted(
+      tooltip.add(Localization.Analyzer.Address(node.getString("address")).toString)
-        Settings.namespace + "gui.Analyzer.Address", node.getString("address")))
     }
   }
 

src/main/scala/li/cil/oc/common/event/ExperienceUpgradeHandler.scala

@@ -1,10 +1,9 @@
 package li.cil.oc.common.event
 
-import li.cil.oc.Settings
 import li.cil.oc.api.event._
 import li.cil.oc.api.machine.Robot
 import li.cil.oc.server.component
-import net.minecraft.util.ChatMessageComponent
+import li.cil.oc.{Localization, Settings}
 import net.minecraftforge.event.ForgeSubscribe
 import org.lwjgl.opengl.GL11
 
@@ -14,8 +13,7 @@ object ExperienceUpgradeHandler {
     val (level, experience) = getLevelAndExperience(e.robot)
     // This is basically a 'does it have an experience upgrade' check.
     if (experience != 0.0) {
-      e.player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+      e.player.sendChatToPlayer(Localization.Analyzer.RobotXp(experience, level))
-        Settings.namespace + "gui.Analyzer.RobotXp", "%.2f".format(experience), level: Integer))
     }
   }
 

src/main/scala/li/cil/oc/common/item/Analyzer.scala

@@ -2,14 +2,13 @@ package li.cil.oc.common.item
 
 import java.util
 
-import li.cil.oc.Settings
 import li.cil.oc.api.network._
 import li.cil.oc.server.PacketSender
 import li.cil.oc.util.Tooltip
+import li.cil.oc.{Localization, Settings}
 import net.minecraft.client.renderer.texture.IconRegister
 import net.minecraft.entity.player.{EntityPlayer, EntityPlayerMP}
 import net.minecraft.item.ItemStack
-import net.minecraft.util.ChatMessageComponent
 import net.minecraft.world.World
 import net.minecraftforge.common.ForgeDirection
 
@@ -50,27 +49,19 @@ class Analyzer(val parent: Delegator) extends Delegate {
     node match {
       case connector: Connector =>
         if (connector.localBufferSize > 0) {
-          player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+          player.sendChatToPlayer(Localization.Analyzer.StoredEnergy("%.2f/%.2f".format(connector.localBuffer, connector.localBufferSize)))
-            Settings.namespace + "gui.Analyzer.StoredEnergy",
-            "%.2f/%.2f".format(connector.localBuffer, connector.localBufferSize)))
         }
-        player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+        player.sendChatToPlayer(Localization.Analyzer.TotalEnergy("%.2f/%.2f".format(connector.globalBuffer, connector.globalBufferSize)))
-          Settings.namespace + "gui.Analyzer.TotalEnergy",
-          "%.2f/%.2f".format(connector.globalBuffer, connector.globalBufferSize)))
       case _ =>
     }
     node match {
       case component: Component =>
-        player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+        player.sendChatToPlayer(Localization.Analyzer.ComponentName(component.name))
-          Settings.namespace + "gui.Analyzer.ComponentName",
-          component.name))
       case _ =>
     }
     val address = node.address()
     if (address != null && !address.isEmpty) {
-      player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+      player.sendChatToPlayer(Localization.Analyzer.Address(address))
-        Settings.namespace + "gui.Analyzer.Address",
-        address))
       PacketSender.sendAnalyze(address, player)
     }
   }

src/main/scala/li/cil/oc/common/tileentity/Charger.scala

@@ -3,10 +3,9 @@ package li.cil.oc.common.tileentity
 import cpw.mods.fml.relauncher.{Side, SideOnly}
 import li.cil.oc.api.network.{Analyzable, Node, Visibility}
 import li.cil.oc.server.{PacketSender => ServerPacketSender}
-import li.cil.oc.{Settings, api}
+import li.cil.oc.{Localization, Settings, api}
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.nbt.NBTTagCompound
-import net.minecraft.util.ChatMessageComponent
 import net.minecraftforge.common.ForgeDirection
 
 class Charger extends traits.Environment with traits.PowerAcceptor with traits.RedstoneAware with traits.Rotatable with Analyzable {
@@ -30,9 +29,7 @@ class Charger extends traits.Environment with traits.PowerAcceptor with traits.R
   override protected def connector(side: ForgeDirection) = Option(if (side != facing) node else null)
 
   def onAnalyze(player: EntityPlayer, side: Int, hitX: Float, hitY: Float, hitZ: Float) = {
-    player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+    player.sendChatToPlayer(Localization.Analyzer.ChargerSpeed(chargeSpeed))
-      Settings.namespace + "gui.Analyzer.ChargerSpeed",
-      (chargeSpeed * 100).toInt + "%"))
     null
   }
 

src/main/scala/li/cil/oc/common/tileentity/Geolyzer.scala

@@ -1,7 +1,7 @@
 package li.cil.oc.common.tileentity
 
-import li.cil.oc.{Settings, api}
 import li.cil.oc.api.network.{Arguments, Callback, Context, Visibility}
+import li.cil.oc.{Settings, api}
 import net.minecraft.block.{Block, BlockFluid}
 import net.minecraftforge.fluids.FluidRegistry
 

src/main/scala/li/cil/oc/common/tileentity/Keyboard.scala

@@ -1,9 +1,9 @@
 package li.cil.oc.common.tileentity
 
 import cpw.mods.fml.relauncher.{Side, SideOnly}
-import li.cil.oc.{Settings, api}
 import li.cil.oc.api.network.{Analyzable, SidedEnvironment}
 import li.cil.oc.util.ExtendedNBT._
+import li.cil.oc.{Settings, api}
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.nbt.NBTTagCompound
 import net.minecraftforge.common.ForgeDirection

src/main/scala/li/cil/oc/common/tileentity/PowerDistributor.scala

@@ -1,9 +1,9 @@
 package li.cil.oc.common.tileentity
 
 import cpw.mods.fml.relauncher.{Side, SideOnly}
-import li.cil.oc.{Settings, api}
 import li.cil.oc.api.network._
 import li.cil.oc.util.ExtendedNBT._
+import li.cil.oc.{Settings, api}
 import net.minecraft.nbt.NBTTagCompound
 import net.minecraftforge.common.ForgeDirection
 

src/main/scala/li/cil/oc/common/tileentity/Rack.scala

@@ -9,11 +9,10 @@ import li.cil.oc.client.Sound
 import li.cil.oc.server.{component, driver, PacketSender => ServerPacketSender}
 import li.cil.oc.util.ExtendedNBT._
 import li.cil.oc.util.mods.Waila
-import li.cil.oc.{Settings, api, common}
+import li.cil.oc.{Localization, Settings, api, common}
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.ItemStack
 import net.minecraft.nbt.{NBTTagCompound, NBTTagString}
-import net.minecraft.util.ChatMessageComponent
 import net.minecraftforge.common.ForgeDirection
 import net.minecraftforge.event.ForgeSubscribe
 import net.minecraftforge.event.world.WorldEvent
@@ -164,16 +163,13 @@ class Rack extends traits.PowerAcceptor with traits.Hub with traits.PowerBalance
         val computer = servers(slot).get.machine
         computer.lastError match {
           case value if value != null =>
-            player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+            player.sendChatToPlayer(Localization.Analyzer.LastError(value))
-              Settings.namespace + "gui.Analyzer.LastError", ChatMessageComponent.createFromTranslationKey(value)))
           case _ =>
         }
-        player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+        player.sendChatToPlayer(Localization.Analyzer.Components(computer.componentCount, servers(slot).get.maxComponents))
-          Settings.namespace + "gui.Analyzer.Components", computer.componentCount + "/" + servers(slot).get.maxComponents))
         val list = computer.users
         if (list.size > 0) {
-          player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+          player.sendChatToPlayer(Localization.Analyzer.Users(list))
-            Settings.namespace + "gui.Analyzer.Users", list.mkString(", ")))
         }
         Array(computer.node)
       }

src/main/scala/li/cil/oc/common/tileentity/Robot.scala

@@ -19,7 +19,6 @@ import net.minecraft.client.Minecraft
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.ItemStack
 import net.minecraft.nbt.NBTTagCompound
-import net.minecraft.util.ChatMessageComponent
 import net.minecraftforge.common.{ForgeDirection, MinecraftForge}
 import net.minecraftforge.fluids.{BlockFluidBase, FluidRegistry}
 
@@ -115,10 +114,8 @@ class Robot(val isRemote: Boolean) extends traits.Computer with traits.PowerInfo
   def name = info.name
 
   override def onAnalyze(player: EntityPlayer, side: Int, hitX: Float, hitY: Float, hitZ: Float) = {
-    player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+    player.sendChatToPlayer(Localization.Analyzer.RobotOwner(owner))
-      Settings.namespace + "gui.Analyzer.RobotOwner", owner))
+    player.sendChatToPlayer(Localization.Analyzer.RobotName(player_.getCommandSenderName))
-    player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
-      Settings.namespace + "gui.Analyzer.RobotName", player_.getCommandSenderName))
     MinecraftForge.EVENT_BUS.post(new RobotAnalyzeEvent(this, player))
     super.onAnalyze(player, side, hitX, hitY, hitZ)
   }

src/main/scala/li/cil/oc/common/tileentity/WirelessRouter.scala

@@ -3,10 +3,9 @@ package li.cil.oc.common.tileentity
 import li.cil.oc.api.network._
 import li.cil.oc.util.ExtendedNBT._
 import li.cil.oc.util.mods.Mods
-import li.cil.oc.{Settings, api}
+import li.cil.oc.{Localization, Settings, api}
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.nbt.NBTTagCompound
-import net.minecraft.util.ChatMessageComponent
 import net.minecraftforge.common.ForgeDirection
 
 import scala.collection.convert.WrapAsScala._
@@ -19,8 +18,7 @@ class WirelessRouter extends Router with WirelessEndpoint {
   // ----------------------------------------------------------------------- //
 
   override def onAnalyze(player: EntityPlayer, side: Int, hitX: Float, hitY: Float, hitZ: Float): Array[Node] = {
-    player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+    player.sendChatToPlayer(Localization.Analyzer.WirelessStrength(strength))
-      Settings.namespace + "gui.Analyzer.WirelessStrength", Double.box(strength)))
     Array(componentNodes(side))
   }
 

src/main/scala/li/cil/oc/common/tileentity/traits/Computer.scala

@@ -2,7 +2,6 @@ package li.cil.oc.common.tileentity.traits
 
 import cpw.mods.fml.common.Optional
 import cpw.mods.fml.relauncher.{Side, SideOnly}
-import li.cil.oc.Settings
 import li.cil.oc.api.Machine
 import li.cil.oc.api.machine.Owner
 import li.cil.oc.api.network.{Analyzable, Node}
@@ -11,9 +10,9 @@ import li.cil.oc.common.tileentity.RobotProxy
 import li.cil.oc.server.{driver, PacketSender => ServerPacketSender}
 import li.cil.oc.util.ExtendedNBT._
 import li.cil.oc.util.mods.Waila
+import li.cil.oc.{Localization, Settings}
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.nbt.{NBTTagCompound, NBTTagString}
-import net.minecraft.util.ChatMessageComponent
 import net.minecraftforge.common.ForgeDirection
 import stargatetech2.api.bus.IBusDevice
 
@@ -193,16 +192,13 @@ trait Computer extends Environment with ComponentInventory with Rotatable with B
   override def onAnalyze(player: EntityPlayer, side: Int, hitX: Float, hitY: Float, hitZ: Float) = {
     computer.lastError match {
       case value if value != null =>
-        player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+        player.sendChatToPlayer(Localization.Analyzer.LastError(value))
-          Settings.namespace + "gui.Analyzer.LastError", ChatMessageComponent.createFromTranslationKey(value)))
       case _ =>
     }
-    player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+    player.sendChatToPlayer(Localization.Analyzer.Components(computer.componentCount, maxComponents))
-      Settings.namespace + "gui.Analyzer.Components", computer.componentCount + "/" + maxComponents))
     val list = users
     if (list.size > 0) {
-      player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
+      player.sendChatToPlayer(Localization.Analyzer.Users(list))
-        Settings.namespace + "gui.Analyzer.Users", list.mkString(", ")))
     }
     Array(computer.node)
   }

src/main/scala/li/cil/oc/server/PacketHandler.scala

@@ -1,12 +1,12 @@
 package li.cil.oc.server
 
 import cpw.mods.fml.common.network.Player
-import li.cil.oc.{Settings, api}
 import li.cil.oc.api.machine.Machine
 import li.cil.oc.common.multipart.EventHandler
 import li.cil.oc.common.tileentity._
 import li.cil.oc.common.tileentity.traits.{Computer, TileEntity}
 import li.cil.oc.common.{PacketType, PacketHandler => CommonPacketHandler}
+import li.cil.oc.{Settings, api}
 import net.minecraft.entity.player.{EntityPlayer, EntityPlayerMP}
 import net.minecraft.util.ChatMessageComponent
 import net.minecraftforge.common.{DimensionManager, ForgeDirection}
@@ -54,7 +54,7 @@ class PacketHandler extends CommonPacketHandler {
         if (!computer.isPaused) {
           computer.start()
           computer.lastError match {
-            case message if message != null => player.sendChatToPlayer(ChatMessageComponent.createFromTranslationKey(message))
+            case message if message != null => player.sendChatToPlayer(ChatMessageComponent.createFromTranslationKey(Settings.namespace + message))
             case _ =>
           }
         }

src/main/scala/li/cil/oc/server/component/GraphicsCard.scala

@@ -1,14 +1,13 @@
 package li.cil.oc.server.component
 
-import li.cil.oc.Settings
 import li.cil.oc.api.Network
 import li.cil.oc.api.component.TextBuffer
 import li.cil.oc.api.component.TextBuffer.ColorDepth
 import li.cil.oc.api.network._
 import li.cil.oc.common.component
 import li.cil.oc.util.PackedColor
+import li.cil.oc.{Localization, Settings}
 import net.minecraft.nbt.NBTTagCompound
-import net.minecraft.util.StatCollector
 
 abstract class GraphicsCard extends component.ManagedComponent {
   val node = Network.newNode(this, Visibility.Neighbors).
@@ -283,7 +282,7 @@ abstract class GraphicsCard extends component.ManagedComponent {
             else s.setBackgroundColor(0x000000)
             s.fill(0, 0, w, h, ' ')
             try {
-              val message = "Unrecoverable error:\n" + StatCollector.translateToLocal(machine.lastError) + "\n"
+              val message = "Unrecoverable error:\n" + Localization.localizeImmediately(machine.lastError) + "\n"
               val wrapRegEx = s"(.{1,${math.max(1, w - 2)}})\\s".r
               val lines = wrapRegEx.replaceAllIn(message, m => m.group(1) + "\n").lines.toArray
               for ((line, idx) <- lines.zipWithIndex) {

src/main/scala/li/cil/oc/server/component/machine/Machine.scala

@@ -108,15 +108,15 @@ class Machine(val owner: Owner, constructor: Constructor[_ <: Architecture]) ext
       verifyComponents()
       val rules = owner.world.getWorldInfo.getGameRulesInstance
       if (rules.hasRule("doDaylightCycle") && !rules.getGameRuleBooleanValue("doDaylightCycle")) {
-        crash(Settings.namespace + "gui.Error.DaylightCycle")
+        crash("gui.Error.DaylightCycle")
         false
       }
       else if (componentCount > owner.maxComponents) {
-        crash(Settings.namespace + (owner match {
+        crash(owner match {
           case t: tileentity.Case if !t.hasCPU => "gui.Error.NoCPU"
           case s: server.component.Server if !s.hasCPU => "gui.Error.NoCPU"
           case _ => "gui.Error.ComponentOverflow"
-        }))
+        })
         false
       }
       else if (owner.installedMemory > 0) {
@@ -129,12 +129,12 @@ class Machine(val owner: Owner, constructor: Constructor[_ <: Architecture]) ext
           }
         }
         else {
-          crash(Settings.namespace + "gui.Error.NoEnergy")
+          crash("gui.Error.NoEnergy")
           false
         }
       }
       else {
-        crash(Settings.namespace + "gui.Error.NoRAM")
+        crash("gui.Error.NoRAM")
         false
       }
     case Machine.State.Paused if remainingPause > 0 =>
@@ -329,7 +329,7 @@ class Machine(val owner: Owner, constructor: Constructor[_ <: Architecture]) ext
     // Component overflow check, crash if too many components are connected, to
     // avoid confusion on the user's side due to components not showing up.
     if (componentCount > owner.maxComponents) {
-      crash(Settings.namespace + "gui.Error.ComponentOverflow")
+      crash("gui.Error.ComponentOverflow")
     }
 
     // Update world time for time().
@@ -354,11 +354,11 @@ class Machine(val owner: Owner, constructor: Constructor[_ <: Architecture]) ext
              Machine.State.Stopped => // No power consumption.
         case Machine.State.Sleeping if remainIdle > 0 && signals.isEmpty =>
           if (!node.tryChangeBuffer(-cost * Settings.get.sleepCostFactor)) {
-            crash(Settings.namespace + "gui.Error.NoEnergy")
+            crash("gui.Error.NoEnergy")
           }
         case _ =>
           if (!node.tryChangeBuffer(-cost)) {
-            crash(Settings.namespace + "gui.Error.NoEnergy")
+            crash("gui.Error.NoEnergy")
           }
       })
     }
@@ -392,7 +392,7 @@ class Machine(val owner: Owner, constructor: Constructor[_ <: Architecture]) ext
         node.sendToReachable("computer.stopped")
         start()
       // Resume from pauses based on sleep or signal underflow.
-      case Machine.State.Sleeping if remainIdle <= 0 || !signals.isEmpty =>
+      case Machine.State.Sleeping if remainIdle <= 0 || signals.nonEmpty =>
         switchTo(Machine.State.Yielded)
       // Resume in case we paused  because the game was paused.
       case Machine.State.Paused =>
@@ -431,10 +431,10 @@ class Machine(val owner: Owner, constructor: Constructor[_ <: Architecture]) ext
         }
         catch {
           case e: java.lang.Error if e.getMessage == "not enough memory" =>
-            crash(Settings.namespace + "gui.Error.OutOfMemory")
+            crash("gui.Error.OutOfMemory")
           case e: Throwable =>
             OpenComputers.log.log(Level.WARNING, "Faulty architecture implementation for synchronized calls.", e)
-            crash(Settings.namespace + "gui.Error.InternalError")
+            crash("gui.Error.InternalError")
         }
 
         assert(state.top != Machine.State.Running)
@@ -780,7 +780,12 @@ class Machine(val owner: Owner, constructor: Constructor[_ <: Architecture]) ext
                   switchTo(Machine.State.Stopping)
                 }
               case result: ExecutionResult.Error =>
-                crash(result.message)
+                if (result.message != null) {
+                  crash(result.message)
+                }
+                else {
+                  crash("unknown error")
+                }
             }
           case Machine.State.Paused =>
             state.pop() // Paused
@@ -796,7 +801,7 @@ class Machine(val owner: Owner, constructor: Constructor[_ <: Architecture]) ext
     catch {
       case e: Throwable =>
         OpenComputers.log.log(Level.WARNING, "Architecture's runThreaded threw an error. This should never happen!", e)
-        crash(Settings.namespace + "gui.Error.InternalError")
+        crash("gui.Error.InternalError")
     }
 
     // Keep track of time spent executing the computer.

src/main/scala/li/cil/oc/util/ItemCosts.scala

@@ -2,11 +2,10 @@ package li.cil.oc.util
 
 import java.util
 
-import li.cil.oc.{Items, Settings}
+import li.cil.oc.{Items, Localization}
 import net.minecraft.block.Block
 import net.minecraft.item.crafting._
 import net.minecraft.item.{Item, ItemStack}
-import net.minecraft.util.StatCollector
 import net.minecraftforge.oredict.{OreDictionary, ShapedOreRecipe, ShapelessOreRecipe}
 
 import scala.collection.convert.WrapAsScala._
@@ -54,7 +53,7 @@ object ItemCosts {
   }
 
   def addTooltip(stack: ItemStack, tooltip: util.List[String]) {
-    tooltip.add(StatCollector.translateToLocal(Settings.namespace + "tooltip.Materials"))
+    tooltip.add(Localization.Tooltip.Materials)
     for ((ingredient, count) <- computeIngredients(stack)) {
       val line = math.ceil(count).toInt + "x " + ingredient.getDisplayName
       tooltip.add(line)

src/main/scala/li/cil/oc/util/Tooltip.scala

@@ -1,9 +1,8 @@
 package li.cil.oc.util
 
-import li.cil.oc.Settings
+import li.cil.oc.Localization
 import li.cil.oc.client.KeyBindings
 import net.minecraft.client.Minecraft
-import net.minecraft.util.StatCollector
 import org.lwjgl.input.Keyboard
 
 import scala.collection.convert.WrapAsJava._
@@ -13,13 +12,13 @@ object Tooltip {
   val maxWidth = 220
 
   def get(name: String, args: Any*): java.util.List[String] = {
-    val tooltip = StatCollector.translateToLocal(Settings.namespace + "tooltip." + name).format(args.map(_.toString): _*)
+    val tooltip = Localization.localizeImmediately("tooltip." + name).format(args.map(_.toString): _*)
     val isSubTooltip = name.contains(".")
     val font = Minecraft.getMinecraft.fontRenderer
     val shouldShorten = (isSubTooltip || font.getStringWidth(tooltip) > maxWidth) && !KeyBindings.showExtendedTooltips
     if (shouldShorten) {
       if (isSubTooltip) Seq.empty[String]
-      else Seq(StatCollector.translateToLocalFormatted(Settings.namespace + "tooltip.TooLong", Keyboard.getKeyName(KeyBindings.extendedTooltip.keyCode)))
+      else Seq(Localization.localizeImmediately("tooltip.TooLong", Keyboard.getKeyName(KeyBindings.extendedTooltip.keyCode)))
     }
     else {
       val nl = """\[nl\]"""