AstralTransRocketries/OpenComputers
1
0
Fork 0
mirror of https://github.com/MightyPirates/OpenComputers.git synced 2025-09-17 11:15:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Florian Nücke 2014-06-20 12:43:56 +02:00
parent 56f46cb923
commit 79c202fe21
32 changed files with 224 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
src/main/scala/li/cil/oc/Localization.scala Normal file
View File

@ -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")
}
}

9
src/main/scala/li/cil/oc/client/GuiHandler.scala
View File

@ -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"))
case _ => player.addChatMessage(StatCollector.translateToLocal(Settings.namespace + "gui.Terminal.OutOfRange"))
else player.addChatMessage(Localization.Terminal.OutOfRange)
case _ => player.addChatMessage(Localization.Terminal.OutOfRange)
}
}
}

5
src/main/scala/li/cil/oc/client/PacketHandler.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.AddressCopied"))
player.sendChatToPlayer(Localization.Analyzer.AddressCopied)
}
}

5
src/main/scala/li/cil/oc/client/gui/Case.scala
View File

@ -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(StatCollector.translateToLocal(Settings.namespace + which))
tooltip.add(if (computer.isRunning) Localization.Robot.TurnOff else Localization.Robot.TurnOn)
copiedDrawHoveringText(tooltip, mouseX - guiLeft, mouseY - guiTop, fontRenderer)
}
GL11.glPopAttrib()

25
src/main/scala/li/cil/oc/client/gui/Rack.scala
View File

@ -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 {
case ForgeDirection.UP => "gui.ServerRack.Top"
case ForgeDirection.DOWN => "gui.ServerRack.Bottom"
case ForgeDirection.EAST => "gui.ServerRack.Left"
case ForgeDirection.WEST => "gui.ServerRack.Right"
case ForgeDirection.NORTH => "gui.ServerRack.Back"
case _ => "gui.ServerRack.None"
}))
def sideName(number: Int) = rack.sides(number) match {
case ForgeDirection.UP => Localization.ServerRack.Top
case ForgeDirection.DOWN => Localization.ServerRack.Bottom
case ForgeDirection.EAST => Localization.ServerRack.Left
case ForgeDirection.WEST => Localization.ServerRack.Right
case ForgeDirection.NORTH => Localization.ServerRack.Back
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(
StatCollector.translateToLocal(Settings.namespace + "gui.ServerRack.WirelessRange"),
8, 31, 0x404040)
fontRenderer.drawString(Localization.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(StatCollector.translateToLocal(Settings.namespace + which))
tooltip.add(if (rack.isRunning(i)) Localization.Robot.TurnOff else Localization.Robot.TurnOn)
copiedDrawHoveringText(tooltip, mouseX - guiLeft, mouseY - guiTop, fontRenderer)
}

8
src/main/scala/li/cil/oc/client/gui/Robot.scala
View File

@ -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(StatCollector.translateToLocal(Settings.namespace + which))
tooltip.add(if (robot.isRunning) Localization.Robot.TurnOff else Localization.Robot.TurnOn)
copiedDrawHoveringText(tooltip, mouseX - guiLeft, mouseY - guiTop, fontRenderer)
}
GL11.glPopAttrib()

27
src/main/scala/li/cil/oc/client/gui/RobotAssembler.scala
View File

@ -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(
StatCollector.translateToLocal(Settings.namespace + message),
30, 94, 0x404040)
fontRenderer.drawString(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(
StatCollector.translateToLocalFormatted(Settings.namespace + "gui.RobotAssembler.Complexity", Int.box(assembler.complexity), Int.box(assembler.maxComplexity)),
30, 94, if (isCapacityValid) 0x404040 else 0x804040)
fontRenderer.drawString(Localization.RobotAssembler.Complexity(assembler.complexity, 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()

11
src/main/scala/li/cil/oc/common/ConnectionHandler.scala
View File

@ -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.

10
src/main/scala/li/cil/oc/common/block/AccessPoint.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.Address", node.getString("address")))
tooltip.add(Localization.Analyzer.Address(node.getString("address")).toString)
}
if (nbt.hasKey(Settings.namespace + "strength")) {
tooltip.add(StatCollector.translateToLocalFormatted(
Settings.namespace + "gui.Analyzer.WirelessStrength", nbt.getDouble(Settings.namespace + "strength").toInt.toString))
tooltip.add(Localization.Analyzer.WirelessStrength(nbt.getDouble(Settings.namespace + "strength")).toString)
}
}

7
src/main/scala/li/cil/oc/common/block/Capacitor.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.StoredEnergy", node.getDouble("buffer").toInt.toString))
tooltip.add(Localization.Analyzer.StoredEnergy(node.getDouble("buffer").toInt.toString).toString)
}
}

7
src/main/scala/li/cil/oc/common/block/Case.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.Address", node.getString("address")))
tooltip.add(Localization.Analyzer.Address(node.getString("address")).toString)
}
}

8
src/main/scala/li/cil/oc/common/block/Charger.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.ChargerSpeed",
(charger.chargeSpeed * 100).toInt + "%"))
tooltip.add(Localization.Analyzer.ChargerSpeed(charger.chargeSpeed).toString)
case _ =>
}
}

7
src/main/scala/li/cil/oc/common/block/DiskDrive.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.Address", node.getString("address")))
tooltip.add(Localization.Analyzer.Address(node.getString("address")).toString)
}
}
}

7
src/main/scala/li/cil/oc/common/block/Hologram.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.Address", node.getString("address")))
tooltip.add(Localization.Analyzer.Address(node.getString("address")).toString)
}
}

2
src/main/scala/li/cil/oc/common/block/Item.scala
View File

@ -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}

7
src/main/scala/li/cil/oc/common/block/Keyboard.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.Address", node.getString("address")))
tooltip.add(Localization.Analyzer.Address(node.getString("address")).toString)
}
}

7
src/main/scala/li/cil/oc/common/block/Screen.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.Address", node.getString("address")))
tooltip.add(Localization.Analyzer.Address(node.getString("address")).toString)
}
}

6
src/main/scala/li/cil/oc/common/event/ExperienceUpgradeHandler.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.RobotXp", "%.2f".format(experience), level: Integer))
e.player.sendChatToPlayer(Localization.Analyzer.RobotXp(experience, level))
}
}

19
src/main/scala/li/cil/oc/common/item/Analyzer.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.StoredEnergy",
"%.2f/%.2f".format(connector.localBuffer, connector.localBufferSize)))
player.sendChatToPlayer(Localization.Analyzer.StoredEnergy("%.2f/%.2f".format(connector.localBuffer, connector.localBufferSize)))
}
player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
Settings.namespace + "gui.Analyzer.TotalEnergy",
"%.2f/%.2f".format(connector.globalBuffer, connector.globalBufferSize)))
player.sendChatToPlayer(Localization.Analyzer.TotalEnergy("%.2f/%.2f".format(connector.globalBuffer, connector.globalBufferSize)))
case _ =>
}
node match {
case component: Component =>
player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
Settings.namespace + "gui.Analyzer.ComponentName",
component.name))
player.sendChatToPlayer(Localization.Analyzer.ComponentName(component.name))
case _ =>
}
val address = node.address()
if (address != null && !address.isEmpty) {
player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
Settings.namespace + "gui.Analyzer.Address",
address))
player.sendChatToPlayer(Localization.Analyzer.Address(address))
PacketSender.sendAnalyze(address, player)
}
}

7
src/main/scala/li/cil/oc/common/tileentity/Charger.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.ChargerSpeed",
(chargeSpeed * 100).toInt + "%"))
player.sendChatToPlayer(Localization.Analyzer.ChargerSpeed(chargeSpeed))
null
}

2
src/main/scala/li/cil/oc/common/tileentity/Geolyzer.scala
View File

@ -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

2
src/main/scala/li/cil/oc/common/tileentity/Keyboard.scala
View File

@ -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

2
src/main/scala/li/cil/oc/common/tileentity/PowerDistributor.scala
View File

@ -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

12
src/main/scala/li/cil/oc/common/tileentity/Rack.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.LastError", ChatMessageComponent.createFromTranslationKey(value)))
player.sendChatToPlayer(Localization.Analyzer.LastError(value))
case _ =>
}
player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
Settings.namespace + "gui.Analyzer.Components", computer.componentCount + "/" + servers(slot).get.maxComponents))
player.sendChatToPlayer(Localization.Analyzer.Components(computer.componentCount, servers(slot).get.maxComponents))
val list = computer.users
if (list.size > 0) {
player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
Settings.namespace + "gui.Analyzer.Users", list.mkString(", ")))
player.sendChatToPlayer(Localization.Analyzer.Users(list))
}
Array(computer.node)
}

7
src/main/scala/li/cil/oc/common/tileentity/Robot.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.RobotOwner", owner))
player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
Settings.namespace + "gui.Analyzer.RobotName", player_.getCommandSenderName))
player.sendChatToPlayer(Localization.Analyzer.RobotOwner(owner))
player.sendChatToPlayer(Localization.Analyzer.RobotName(player_.getCommandSenderName))
MinecraftForge.EVENT_BUS.post(new RobotAnalyzeEvent(this, player))
super.onAnalyze(player, side, hitX, hitY, hitZ)
}

6
src/main/scala/li/cil/oc/common/tileentity/WirelessRouter.scala
View File

@ -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(
Settings.namespace + "gui.Analyzer.WirelessStrength", Double.box(strength)))
player.sendChatToPlayer(Localization.Analyzer.WirelessStrength(strength))
Array(componentNodes(side))
}

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

@ -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(
Settings.namespace + "gui.Analyzer.LastError", ChatMessageComponent.createFromTranslationKey(value)))
player.sendChatToPlayer(Localization.Analyzer.LastError(value))
case _ =>
}
player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
Settings.namespace + "gui.Analyzer.Components", computer.componentCount + "/" + maxComponents))
player.sendChatToPlayer(Localization.Analyzer.Components(computer.componentCount, maxComponents))
val list = users
if (list.size > 0) {
player.sendChatToPlayer(ChatMessageComponent.createFromTranslationWithSubstitutions(
Settings.namespace + "gui.Analyzer.Users", list.mkString(", ")))
player.sendChatToPlayer(Localization.Analyzer.Users(list))
}
Array(computer.node)
}

4
src/main/scala/li/cil/oc/server/PacketHandler.scala
View File

@ -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 _ =>
}
}

5
src/main/scala/li/cil/oc/server/component/GraphicsCard.scala
View File

@ -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) {

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

@ -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.

5
src/main/scala/li/cil/oc/util/ItemCosts.scala
View File

@ -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)

7
src/main/scala/li/cil/oc/util/Tooltip.scala
View File

@ -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\]"""