AstralTransRocketries/OpenComputers
1
0
Fork 0
mirror of https://github.com/MightyPirates/OpenComputers.git synced 2025-09-16 10:51:55 -04:00
Code Issues Packages Projects Releases Wiki Activity

What am I even doing.

Browse Source
This commit is contained in:
Florian Nücke 2015-08-23 13:32:39 +02:00
parent 80abb55d5b
commit 117f877ec5
13 changed files with 201 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/scala/li/cil/oc/OpenComputers.scala
View File

@ -19,7 +19,7 @@ object OpenComputers {
final val Name = "OpenComputers"
final val Version = "1.5.15"
final val Version = "@VERSION@"
var log = LogManager.getLogger(Name)

4
src/main/scala/li/cil/oc/client/renderer/block/ServerRack.scala
View File

@ -7,7 +7,7 @@ import net.minecraft.client.renderer.RenderBlocks
import net.minecraftforge.common.util.ForgeDirection
object ServerRack {
def render(rack: tileentity.ServerRack, x: Int, y: Int, z: Int, block: Block, renderer: RenderBlocks): Unit = {
def render(rack: tileentity.Rack, x: Int, y: Int, z: Int, block: Block, renderer: RenderBlocks): Unit = {
val previousRenderAllFaces = renderer.renderAllFaces
val u1 = 1 / 16f
val u2 = 15 / 16f
@ -26,7 +26,7 @@ object ServerRack {
val front = rack.facing
def renderSide(side: ForgeDirection, lx: Double, lz: Double, hx: Double, hz: Double) {
if (side == front) {
for (i <- 0 until 4 if rack.isPresent(i).isDefined) {
for (i <- 0 until 4 if rack.getStackInSlot(i) != null) {
side match {
case ForgeDirection.WEST =>
renderer.setRenderBounds(lx, v2 - (i + 1) * fs, lz + u1, u2, v2 - i * fs, hz - u1)

13
src/main/scala/li/cil/oc/common/EventHandler.scala
View File

@ -365,12 +365,13 @@ object EventHandler {
case _ => // Dafuq?
}
case rack: ServerRack =>
(0 until rack.getSizeInventory).
map(rack.getMountable).
filter(_ != null).
map(_.machine()).
filter(_ != null).
foreach(_.stop())
// TODO
// (0 until rack.getSizeInventory).
// map(rack.getMountable).
// filter(_ != null).
// map(_.machine()).
// filter(_ != null).
// foreach(_.stop())
})
}
}

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

@ -52,5 +52,5 @@ class ServerRack extends RedstoneAware with traits.SpecialBlock with traits.Powe
override def hasTileEntity(metadata: Int) = true
override def createTileEntity(world: World, metadata: Int) = new tileentity.ServerRack()
override def createTileEntity(world: World, metadata: Int) = new tileentity.Rack()
}

35
src/main/scala/li/cil/oc/common/inventory/InventoryProxy.scala Normal file
View File

@ -0,0 +1,35 @@
package li.cil.oc.common.inventory
import net.minecraft.entity.player.EntityPlayer
import net.minecraft.inventory.IInventory
import net.minecraft.item.ItemStack
trait InventoryProxy extends IInventory {
def proxiedInventory: IInventory
override def getSizeInventory = proxiedInventory.getSizeInventory
override def getInventoryStackLimit = proxiedInventory.getInventoryStackLimit
override def hasCustomInventoryName = proxiedInventory.hasCustomInventoryName
override def getInventoryName = proxiedInventory.getInventoryName
override def markDirty() = proxiedInventory.markDirty()
override def getStackInSlot(slot: Int) = proxiedInventory.getStackInSlot(slot)
override def setInventorySlotContents(slot: Int, stack: ItemStack) = proxiedInventory.setInventorySlotContents(slot, stack)
override def decrStackSize(slot: Int, amount: Int) = proxiedInventory.decrStackSize(slot, amount)
override def openInventory() = proxiedInventory.openInventory()
override def closeInventory() = proxiedInventory.closeInventory()
override def getStackInSlotOnClosing(slot: Int) = proxiedInventory.getStackInSlotOnClosing(slot)
override def isItemValidForSlot(slot: Int, stack: ItemStack) = proxiedInventory.isItemValidForSlot(slot, stack)
override def isUseableByPlayer(player: EntityPlayer) = proxiedInventory.isUseableByPlayer(player)
}

2
src/main/scala/li/cil/oc/common/item/Terminal.scala
View File

@ -73,7 +73,7 @@ class Terminal(val parent: Delegator) extends traits.Delegate {
}
keys += key
terminal.connect(server.machine.node)
ServerPacketSender.sendServerState(rack, slot)
// ServerPacketSender.sendServerState(rack, slot)
stack.getTagCompound.setString(Settings.namespace + "key", key)
stack.getTagCompound.setString(Settings.namespace + "server", server.machine.node.address)
player.inventory.markDirty()

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

@ -61,7 +61,7 @@ class Rack extends traits.PowerAcceptor with traits.Hub with traits.PowerBalance
// ----------------------------------------------------------------------- //
// AbstractBusAware
override def installedComponents: Iterable[ManagedEnvironment] = ???
override def installedComponents: Iterable[ManagedEnvironment] = Iterable.empty // TODO
@Method(modid = Mods.IDs.StargateTech2)
override def getInterfaces(side: Int) = if (side != facing.ordinal) {
@ -125,7 +125,7 @@ class Rack extends traits.PowerAcceptor with traits.Hub with traits.PowerBalance
if (isServer) {
isOutputEnabled = hasRedstoneCard
isAbstractBusAvailable = hasAbstractBusCard
// ServerPacketSender.sendServerPresence(this) TODO
ServerPacketSender.sendServerPresence(this)
}
else {
world.markBlockForUpdate(x, y, z)
@ -142,7 +142,7 @@ class Rack extends traits.PowerAcceptor with traits.Hub with traits.PowerBalance
components.zipWithIndex.collect {
case (Some(mountable: RackMountable), slot) if isWorking(mountable) != lastWorking(slot) =>
lastWorking(slot) = isWorking(mountable)
// ServerPacketSender.sendServerState(this, slot) TODO
ServerPacketSender.sendServerState(this, slot)
world.notifyBlocksOfNeighborChange(x, y, z, block)
// These are working state dependent, so recompute them.
isOutputEnabled = hasRedstoneCard
@ -157,11 +157,11 @@ class Rack extends traits.PowerAcceptor with traits.Hub with traits.PowerBalance
def stacksForSide(side: ForgeDirection): IndexedSeq[ItemStack] =
if (side == facing) new Array[ItemStack](4)
else nodeMapping(toLocal(side.ordinal)).map(info => getStackInSlot(info._1))
else nodeMapping(toLocal(side).ordinal).map(info => getStackInSlot(info._1))
def nodesForSide(side: ForgeDirection): IndexedSeq[Node] =
if (side == facing) new Array[Node](4)
else nodeMapping(toLocal(side.ordinal)).map {
else nodeMapping(toLocal(side).ordinal).map {
case (slot, nodeNum) => (components(slot), nodeNum)
}.collect {
case (Some(mountable: RackMountable), nodeNum) => mountable.getNodeAt(nodeNum)

32
src/main/scala/li/cil/oc/common/tileentity/ServerRack.scala
View File

@ -110,14 +110,14 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
def markForSaving() = markChunkDirty = true
override def installedComponents = servers.flatMap {
case Some(server) => server.inventory.components collect {
case Some(server) => server.components collect {
case Some(component) => component
}
case _ => Iterable.empty
}
def hasAbstractBusCard = servers exists {
case Some(server) => server.machine.isRunning && server.inventory.items.exists {
case Some(server) => server.machine.isRunning && server.items.exists {
case Some(stack) => DriverAbstractBusCard.worksWith(stack, server.getClass)
case _ => false
}
@ -125,7 +125,7 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
}
def hasRedstoneCard = servers exists {
case Some(server) => server.machine.isRunning && server.inventory.items.exists {
case Some(server) => server.machine.isRunning && server.items.exists {
case Some(stack) => DriverRedstoneCard.worksWith(stack, server.getClass)
case _ => false
}
@ -280,7 +280,7 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
val isRunning = servers(i).fold(false)(_.machine.isRunning)
if (_isRunning(i) != isRunning) {
_isRunning(i) = isRunning
ServerPacketSender.sendServerState(this, i)
// ServerPacketSender.sendServerState(this, i)
world.notifyBlocksOfNeighborChange(x, y, z, block)
}
}
@ -289,7 +289,7 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
servers collect {
case Some(server) =>
server.inventory.updateComponents()
server.updateComponents()
terminals(server.slot).buffer.update()
}
}
@ -320,8 +320,8 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
super.readFromNBTForServer(nbt)
for (slot <- 0 until getSizeInventory) {
if (getStackInSlot(slot) != null) {
val server = new component.Server(this, slot)
servers(slot) = Option(server)
// val server = new component.Server(this, slot)
// servers(slot) = Option(server)
}
}
nbt.getTagList(Settings.namespace + "servers", NBT.TAG_COMPOUND).toArray[NBTTagCompound].
@ -456,11 +456,11 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
override protected def onItemAdded(slot: Int, stack: ItemStack) {
super.onItemAdded(slot, stack)
if (isServer) {
val server = new component.Server(this, slot)
servers(slot) = Some(server)
reconnectServer(slot, server)
Network.joinNewNetwork(server.machine.node)
terminals(slot).connect(server.machine.node)
// val server = new component.Server(this, slot)
// servers(slot) = Some(server)
// reconnectServer(slot, server)
// Network.joinNewNetwork(server.machine.node)
// terminals(slot).connect(server.machine.node)
}
}
@ -470,9 +470,9 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
servers(slot) match {
case Some(server) =>
server.machine.node.remove()
server.inventory.containerOverride = stack
server.inventory.save(new NBTTagCompound()) // Only flush components.
server.inventory.markDirty()
// server.containerOverride = stack
server.save(new NBTTagCompound()) // Only flush components.
server.markDirty()
case _ =>
}
servers(slot) = None
@ -485,7 +485,7 @@ class ServerRack extends traits.PowerAcceptor with traits.Hub with traits.PowerB
if (isServer) {
isOutputEnabled = hasRedstoneCard
isAbstractBusAvailable = hasAbstractBusCard
ServerPacketSender.sendServerPresence(this)
// ServerPacketSender.sendServerPresence(this)
}
else {
world.markBlockForUpdate(x, y, z)

3
src/main/scala/li/cil/oc/integration/opencomputers/DriverServer.scala
View File

@ -7,6 +7,7 @@ import li.cil.oc.api.network.ManagedEnvironment
import li.cil.oc.common.Slot
import li.cil.oc.common.tileentity
import li.cil.oc.server.component
import li.cil.oc.util.ExtendedInventory._
import net.minecraft.item.ItemStack
object DriverServer extends Item {
@ -17,7 +18,7 @@ object DriverServer extends Item {
api.Items.get(Constants.ItemName.ServerCreative))
override def createEnvironment(stack: ItemStack, host: EnvironmentHost): ManagedEnvironment = host match {
case rack: tileentity.ServerRack => new component.Server(rack, ???)
case rack: tileentity.Rack => new component.Server(rack, rack.indexOf(stack))
case _ => null // Welp.
}

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

@ -225,7 +225,7 @@ object PacketHandler extends CommonPacketHandler {
case Some(rack) => p.player match {
case player: EntityPlayerMP if rack.isUseableByPlayer(player) =>
rack.range = math.min(math.max(0, p.readInt()), Settings.get.maxWirelessRange).toInt
PacketSender.sendServerState(rack)
// PacketSender.sendServerState(rack)
case _ =>
}
case _ => // Invalid packet.
@ -243,9 +243,9 @@ object PacketHandler extends CommonPacketHandler {
case Some(server) => rack.reconnectServer(number, server)
case _ =>
}
PacketSender.sendServerState(rack, number)
// PacketSender.sendServerState(rack, number)
}
else PacketSender.sendServerState(rack, number, Some(player))
// else PacketSender.sendServerState(rack, number, Some(player))
case _ =>
}
case _ => // Invalid packet.

33
src/main/scala/li/cil/oc/server/PacketSender.scala
View File

@ -2,7 +2,9 @@ package li.cil.oc.server
import li.cil.oc.api.component.TextBuffer.ColorDepth
import li.cil.oc.api.driver.EnvironmentHost
import li.cil.oc.api.driver.item.RackMountable
import li.cil.oc.api.event.FileSystemAccessEvent
import li.cil.oc.api.internal.StateAware
import li.cil.oc.api.network.Node
import li.cil.oc.common._
import li.cil.oc.common.tileentity.Waypoint
@ -548,14 +550,14 @@ object PacketSender {
pb.sendToPlayersNearTileEntity(t)
}
def sendServerPresence(t: tileentity.ServerRack) {
def sendServerPresence(t: tileentity.Rack) {
val pb = new SimplePacketBuilder(PacketType.ServerPresence)
pb.writeTileEntity(t)
t.servers.foreach {
case Some(server) =>
t.components.foreach {
case Some(mountable: RackMountable) =>
pb.writeBoolean(true)
pb.writeUTF(server.machine.node.address)
pb.writeUTF(mountable.node.address)
case _ =>
pb.writeBoolean(false)
}
@ -563,28 +565,31 @@ object PacketSender {
pb.sendToPlayersNearTileEntity(t)
}
def sendServerState(t: tileentity.ServerRack) {
def sendServerState(t: tileentity.Rack) {
val pb = new SimplePacketBuilder(PacketType.ComputerState)
pb.writeTileEntity(t)
pb.writeInt(-1)
pb.writeInt(t.range)
// pb.writeInt(t.range) TODO
pb.sendToPlayersNearTileEntity(t)
}
def sendServerState(t: tileentity.ServerRack, number: Int, player: Option[EntityPlayerMP] = None) {
def sendServerState(t: tileentity.Rack, number: Int, player: Option[EntityPlayerMP] = None) {
val pb = new SimplePacketBuilder(PacketType.ComputerState)
pb.writeTileEntity(t)
pb.writeInt(number)
pb.writeBoolean(t.isRunning(number))
pb.writeDirection(t.sides(number))
val keys = t.terminals(number).keys
pb.writeInt(keys.length)
for (key <- keys) {
pb.writeUTF(key)
}
pb.writeBoolean(t.components(number) match {
case Some(mountable: RackMountable) => mountable.getCurrentState.contains(StateAware.State.IsWorking)
case _ => false
})
// pb.writeDirection(t.sides(number)) TODO
// val keys = t.terminals(number).keys
// pb.writeInt(keys.length)
// for (key <- keys) {
// pb.writeUTF(key)
// }
player match {
case Some(p) => pb.sendToPlayer(p)

191
src/main/scala/li/cil/oc/server/component/Server.scala
View File

@ -25,44 +25,77 @@ import net.minecraft.nbt.NBTTagCompound
import scala.collection.convert.WrapAsJava._
class Server(val rack: tileentity.ServerRack, val slot: Int) extends Environment with driver.item.RackMountable with MachineHost with internal.Server {
class Server(val rack: tileentity.Rack, val slot: Int) extends Environment with MachineHost with ServerInventory with ComponentInventory with driver.item.RackMountable with internal.Server {
val machine = Machine.create(this)
val inventory = new NetworkedInventory()
// Used to grab messages when not connected to any side in the server rack.
val node = api.Network.newNode(this, Visibility.Network).create()
machine.onHostChanged()
machine.onHostChanged() // TODO ???
def tier = Delegator.subItem(rack.getStackInSlot(slot)) match {
case Some(server: item.Server) => server.tier
case _ => 0
// ----------------------------------------------------------------------- //
// Environment
override def onConnect(node: Node) {
if (node == this.node) {
connectComponents()
}
}
override def onDisconnect(node: Node) {
if (node == this.node) {
disconnectComponents()
}
}
override def onMessage(message: Message) {
// If we're internal mode and this server is not connected to any side, we
// must manually propagate network messages to other servers in the rack.
// Ensure the message originated in our local network, to avoid infinite
// recursion if two unconnected servers are in one server rack.
// if (rack.internalSwitch && message.name == "network.message" &&
// rack.sides(this.slot).isEmpty && // Only if we're in internal mode.
// message.source != machine.node && // In this case it was relayed from another internal machine.
// node.network.node(message.source.address) != null) {
// for (slot <- rack.servers.indices) {
// rack.servers(slot) match {
// case Some(server) if server != this => server.machine.node.sendToNeighbors(message.name, message.data: _*)
// case _ =>
// }
// }
// }
}
override def load(nbt: NBTTagCompound) {
super.load(nbt)
machine.load(nbt.getCompoundTag("machine"))
}
override def save(nbt: NBTTagCompound) {
super.save(nbt)
nbt.setNewCompoundTag("machine", machine.save)
}
// ----------------------------------------------------------------------- //
// MachineHost
override def getCurrentState: util.EnumSet[State] = ???
override def onAnalyze(player: EntityPlayer, side: Int, hitX: Float, hitY: Float, hitZ: Float): Array[Node] = ???
override def getNodeCount: Int = ???
override def getNodeAt(index: Int): Node = ???
override def update(): Unit = ???
override def canUpdate: Boolean = ???
override def onActivate(player: EntityPlayer): Unit = ???
// ----------------------------------------------------------------------- //
override def internalComponents(): Iterable[ItemStack] = (0 until inventory.getSizeInventory).collect {
case i if inventory.getStackInSlot(i) != null && inventory.isComponentSlot(i, inventory.getStackInSlot(i)) => inventory.getStackInSlot(i)
override def internalComponents(): Iterable[ItemStack] = (0 until getSizeInventory).collect {
case i if getStackInSlot(i) != null && isComponentSlot(i, getStackInSlot(i)) => getStackInSlot(i)
}
override def componentSlot(address: String) = inventory.components.indexWhere(_.exists(env => env.node != null && env.node.address == address))
override def componentSlot(address: String) = components.indexWhere(_.exists(env => env.node != null && env.node.address == address))
override def onMachineConnect(node: Node) {
if (node == machine.node) {
node.connect(this.node)
}
onConnect(node)
}
override def onMachineDisconnect(node: Node) = onDisconnect(node)
// ----------------------------------------------------------------------- //
// EnvironmentHost
override def xPosition = rack.x + 0.5
@ -75,76 +108,56 @@ class Server(val rack: tileentity.ServerRack, val slot: Int) extends Environment
override def markChanged() = rack.markChanged()
// ----------------------------------------------------------------------- //
// ServerInventory
override def onConnect(node: Node) {}
override def tier = Delegator.subItem(container) match {
case Some(server: item.Server) => server.tier
case _ => 0
}
override def onDisconnect(node: Node) {}
// ----------------------------------------------------------------------- //
// ItemStackInventory
override def onMessage(message: Message) {
// If we're internal mode and this server is not connected to any side, we
// must manually propagate network messages to other servers in the rack.
// Ensure the message originated in our local network, to avoid infinite
// recursion if two unconnected servers are in one server rack.
if (rack.internalSwitch && message.name == "network.message" &&
rack.sides(this.slot).isEmpty && // Only if we're in internal mode.
message.source != machine.node && // In this case it was relayed from another internal machine.
node.network.node(message.source.address) != null) {
for (slot <- rack.servers.indices) {
rack.servers(slot) match {
case Some(server) if server != this => server.machine.node.sendToNeighbors(message.name, message.data: _*)
case _ =>
}
}
override def host = rack
// ----------------------------------------------------------------------- //
// ComponentInventory
override def container = rack.getStackInSlot(slot)
override protected def connectItemNode(node: Node) {
if (machine.node != null && node != null) {
api.Network.joinNewNetwork(machine.node)
machine.node.connect(node)
}
}
override def onMachineConnect(node: Node) {
if (node == machine.node) {
node.connect(this.node)
}
inventory.onConnect(node)
// ----------------------------------------------------------------------- //
// RackMountable
override def getNodeCount: Int = ???
override def getNodeAt(index: Int): Node = ???
override def onActivate(player: EntityPlayer): Unit = ???
// ----------------------------------------------------------------------- //
// ManagedEnvironment
override def canUpdate: Boolean = ???
override def update(): Unit = ???
// ----------------------------------------------------------------------- //
// StateAware
override def getCurrentState: util.EnumSet[State] = {
if (machine.isRunning) util.EnumSet.of(internal.StateAware.State.IsWorking)
else util.EnumSet.noneOf(classOf[internal.StateAware.State])
}
override def onMachineDisconnect(node: Node) = inventory.onDisconnect(node)
def load(nbt: NBTTagCompound) {
machine.load(nbt.getCompoundTag("machine"))
}
def save(nbt: NBTTagCompound) {
nbt.setNewCompoundTag("machine", machine.save)
inventory.saveComponents()
inventory.markDirty()
}
// Required due to abstract overrides in component inventory.
class NetworkedInventory extends ServerInventory with ComponentInventory {
override def onConnect(node: Node) {
if (node == this.node) {
connectComponents()
}
}
override def onDisconnect(node: Node) {
if (node == this.node) {
disconnectComponents()
}
}
override def tier = Server.this.tier
var containerOverride: ItemStack = _
override def container = if (containerOverride != null) containerOverride else rack.getStackInSlot(slot)
override def node() = machine.node
override def onMessage(message: Message) {}
override def host = rack
// Resolves conflict between ComponentInventory and ServerInventory.
override def getInventoryStackLimit = 1
}
// ----------------------------------------------------------------------- //
// Analyzable
override def onAnalyze(player: EntityPlayer, side: Int, hitX: Float, hitY: Float, hitZ: Float) = Array(machine.node)
}

9
src/main/scala/li/cil/oc/util/ExtendedInventory.scala
View File

@ -3,14 +3,19 @@ package li.cil.oc.util
import net.minecraft.inventory.IInventory
import net.minecraft.item.ItemStack
import scala.collection.mutable
import scala.language.implicitConversions
object ExtendedInventory {
implicit def extendedInventory(inventory: IInventory): ExtendedInventory = new ExtendedInventory(inventory)
class ExtendedInventory(val inventory: IInventory) extends Iterable[ItemStack] {
override def iterator: Iterator[ItemStack] = (for (stack <- (0 until inventory.getSizeInventory).map(inventory.getStackInSlot)) yield stack).iterator
class ExtendedInventory(val inventory: IInventory) extends mutable.IndexedSeq[ItemStack] {
override def length = inventory.getSizeInventory
override def update(idx: Int, elem: ItemStack) = inventory.setInventorySlotContents(idx, elem)
override def apply(idx: Int) = inventory.getStackInSlot(idx)
}
}