255 lines
7.8 KiB
Kotlin
255 lines
7.8 KiB
Kotlin
package net.shadowfacts.phycon.block.terminal
|
|
|
|
import net.minecraft.screen.slot.Slot
|
|
import net.minecraft.screen.slot.SlotActionType
|
|
import net.minecraft.entity.player.PlayerEntity
|
|
import net.minecraft.entity.player.PlayerInventory
|
|
import net.minecraft.item.ItemStack
|
|
import net.minecraft.network.PacketByteBuf
|
|
import net.minecraft.screen.ScreenHandler
|
|
import net.minecraft.screen.ScreenHandlerType
|
|
import net.minecraft.server.network.ServerPlayerEntity
|
|
import net.minecraft.util.Identifier
|
|
import net.minecraft.util.registry.Registry
|
|
import net.shadowfacts.phycon.DefaultPlugin
|
|
import net.shadowfacts.phycon.PhysicalConnectivity
|
|
import net.shadowfacts.phycon.init.PhyBlocks
|
|
import net.shadowfacts.phycon.init.PhyScreens
|
|
import net.shadowfacts.phycon.networking.S2CTerminalUpdateDisplayedItems
|
|
import net.shadowfacts.phycon.util.SortMode
|
|
import net.shadowfacts.phycon.util.TerminalSettings
|
|
import net.shadowfacts.phycon.util.copyWithCount
|
|
import java.lang.ref.WeakReference
|
|
import kotlin.math.ceil
|
|
import kotlin.math.max
|
|
import kotlin.math.min
|
|
import kotlin.math.roundToInt
|
|
|
|
/**
|
|
* @author shadowfacts
|
|
*/
|
|
abstract class AbstractTerminalScreenHandler<T: AbstractTerminalBlockEntity>(
|
|
handlerType: ScreenHandlerType<*>,
|
|
syncId: Int,
|
|
val playerInv: PlayerInventory,
|
|
val terminal: T,
|
|
): ScreenHandler(handlerType, syncId),
|
|
AbstractTerminalBlockEntity.NetItemObserver {
|
|
|
|
private val rowsDisplayed = 6
|
|
|
|
private val fakeInv = FakeInventory(this)
|
|
private var searchQuery: String = ""
|
|
private var settings = TerminalSettings()
|
|
var totalEntries = 0
|
|
private set
|
|
var scrollPosition = 0f
|
|
private var itemEntries = listOf<Entry>()
|
|
set(value) {
|
|
field = value
|
|
if (terminal.world!!.isClient) {
|
|
itemsForDisplay = value.map {
|
|
it.stack.copyWithCount(it.amount)
|
|
}
|
|
}
|
|
}
|
|
var itemsForDisplay = listOf<ItemStack>()
|
|
private set
|
|
|
|
open val xOffset: Int = 0
|
|
|
|
init {
|
|
if (!terminal.world!!.isClient) {
|
|
assert(terminal.netItemObserver?.get() === null)
|
|
terminal.netItemObserver = WeakReference(this)
|
|
// intentionally don't call netItemsChanged immediately, we need to wait for the client to send us its settings
|
|
}
|
|
|
|
val xOffset = xOffset
|
|
|
|
// network
|
|
for (y in 0 until 6) {
|
|
for (x in 0 until 9) {
|
|
addSlot(TerminalFakeSlot(fakeInv, y * 9 + x, xOffset + 66 + x * 18, 18 + y * 18))
|
|
}
|
|
}
|
|
|
|
// internal buffer
|
|
for (y in 0 until 6) {
|
|
for (x in 0 until 3) {
|
|
addSlot(Slot(terminal.internalBuffer, y * 3 + x, xOffset + 8 + x * 18, 18 + y * 18))
|
|
}
|
|
}
|
|
|
|
// player inv
|
|
for (y in 0 until 3) {
|
|
for (x in 0 until 9) {
|
|
addSlot(Slot(playerInv, x + y * 9 + 9, xOffset + 66 + x * 18, 140 + y * 18))
|
|
}
|
|
}
|
|
// hotbar
|
|
for (x in 0 until 9) {
|
|
addSlot(Slot(playerInv, x, xOffset + 66 + x * 18, 198))
|
|
}
|
|
}
|
|
|
|
override fun netItemsChanged() {
|
|
val player = playerInv.player
|
|
assert(player is ServerPlayerEntity)
|
|
|
|
val filtered = terminal.cachedNetItems.object2IntEntrySet().filter {
|
|
if (searchQuery.isBlank()) return@filter true
|
|
if (searchQuery.startsWith('@')) {
|
|
val unprefixed = searchQuery.drop(1)
|
|
val key = Registry.ITEM.getKey(it.key.item)
|
|
if (key.isPresent && key.get().value.namespace.startsWith(unprefixed, true)) {
|
|
return@filter true
|
|
}
|
|
}
|
|
it.key.name.string.contains(searchQuery, true)
|
|
}
|
|
|
|
totalEntries = filtered.size
|
|
|
|
val sorted =
|
|
when (settings[DefaultPlugin.SORT_MODE]) {
|
|
SortMode.COUNT_HIGH_FIRST -> filtered.sortedByDescending { it.intValue }
|
|
SortMode.COUNT_LOW_FIRST -> filtered.sortedBy { it.intValue }
|
|
SortMode.ALPHABETICAL -> filtered.sortedBy { it.key.name.string }
|
|
}
|
|
|
|
|
|
val offsetInItems = currentScrollOffsetInItems()
|
|
val end = min(offsetInItems + rowsDisplayed * 9, sorted.size)
|
|
itemEntries = sorted.subList(offsetInItems, end).map { Entry(it.key, it.intValue) }
|
|
|
|
// itemEntries = sorted.map { Entry(it.key, it.intValue) }
|
|
|
|
(player as ServerPlayerEntity).networkHandler.sendPacket(S2CTerminalUpdateDisplayedItems(terminal, itemEntries, searchQuery, settings, scrollPosition, totalEntries))
|
|
}
|
|
|
|
fun totalRows(): Int {
|
|
return ceil(totalEntries / 9f).toInt()
|
|
}
|
|
|
|
fun maxScrollOffsetInRows(): Int {
|
|
return totalRows() - rowsDisplayed
|
|
}
|
|
|
|
fun currentScrollOffsetInRows(): Int {
|
|
return max(0, (scrollPosition * maxScrollOffsetInRows()).roundToInt())
|
|
}
|
|
|
|
fun currentScrollOffsetInItems(): Int {
|
|
return currentScrollOffsetInRows() * 9
|
|
}
|
|
|
|
fun sendUpdatedItemsToClient(player: ServerPlayerEntity, query: String, settings: TerminalSettings, scrollPosition: Float) {
|
|
this.searchQuery = query
|
|
this.settings = settings
|
|
this.scrollPosition = scrollPosition
|
|
netItemsChanged()
|
|
}
|
|
|
|
fun receivedUpdatedItemsFromServer(entries: List<Entry>, query: String, scrollPosition: Float, totalEntries: Int) {
|
|
assert(playerInv.player.world.isClient)
|
|
|
|
this.searchQuery = query
|
|
this.scrollPosition = scrollPosition
|
|
this.totalEntries = totalEntries
|
|
itemEntries = entries
|
|
}
|
|
|
|
override fun canUse(player: PlayerEntity): Boolean {
|
|
return true
|
|
}
|
|
|
|
override fun close(player: PlayerEntity) {
|
|
super.close(player)
|
|
|
|
terminal.netItemObserver = null
|
|
}
|
|
|
|
override fun onSlotClick(slotId: Int, clickData: Int, actionType: SlotActionType, player: PlayerEntity) {
|
|
if (isBufferSlot(slotId)) {
|
|
// todo: why does this think it's quick_craft sometimes?
|
|
if ((actionType == SlotActionType.PICKUP || actionType == SlotActionType.QUICK_CRAFT) && !cursorStack.isEmpty) {
|
|
// placing cursor stack into buffer
|
|
val bufferSlot = slotId - bufferSlotsStart // subtract 54 to convert the handler slot ID to a valid buffer index
|
|
terminal.internalBuffer.markSlot(bufferSlot, TerminalBufferInventory.Mode.TO_NETWORK)
|
|
}
|
|
}
|
|
super.onSlotClick(slotId, clickData, actionType, player)
|
|
}
|
|
|
|
override fun transferSlot(player: PlayerEntity, slotId: Int): ItemStack {
|
|
if (isNetworkSlot(slotId)) {
|
|
return ItemStack.EMPTY;
|
|
}
|
|
|
|
val slot = slots[slotId]
|
|
if (!slot.hasStack()) {
|
|
return ItemStack.EMPTY
|
|
}
|
|
|
|
val result = slot.stack.copy()
|
|
|
|
if (isBufferSlot(slotId)) {
|
|
// last boolean param is fromLast
|
|
if (!insertItem(slot.stack, playerSlotsStart, playerSlotsEnd, true)) {
|
|
return ItemStack.EMPTY
|
|
}
|
|
if (slot.stack.isEmpty) {
|
|
terminal.internalBuffer.markSlot(slotId - bufferSlotsStart, TerminalBufferInventory.Mode.UNASSIGNED)
|
|
}
|
|
} else if (isPlayerSlot(slotId)) {
|
|
val slotsInsertedInto = tryInsertItem(slot.stack, bufferSlotsStart until playerSlotsStart) { terminal.internalBuffer.getMode(it - bufferSlotsStart) != TerminalBufferInventory.Mode.FROM_NETWORK }
|
|
slotsInsertedInto.forEach { terminal.internalBuffer.markSlot(it - bufferSlotsStart, TerminalBufferInventory.Mode.TO_NETWORK) }
|
|
if (slotsInsertedInto.isEmpty()) {
|
|
return ItemStack.EMPTY
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
private fun tryInsertItem(stack: ItemStack, slots: IntRange, slotPredicate: (Int) -> Boolean): Collection<Int> {
|
|
val slotsInsertedInto = mutableListOf<Int>()
|
|
for (index in slots) {
|
|
if (stack.isEmpty) break
|
|
if (!slotPredicate(index)) continue
|
|
|
|
val slot = this.slots[index]
|
|
val slotStack = slot.stack
|
|
if (slotStack.isEmpty) {
|
|
slot.stack = stack.copy()
|
|
stack.count = 0
|
|
|
|
slot.markDirty()
|
|
slotsInsertedInto.add(index)
|
|
} else if (ItemStack.canCombine(slotStack, stack) && slotStack.count < slotStack.maxCount) {
|
|
val maxToMove = slotStack.maxCount - slotStack.count
|
|
val toMove = min(maxToMove, stack.count)
|
|
slotStack.increment(toMove)
|
|
stack.decrement(toMove)
|
|
|
|
slot.markDirty()
|
|
slotsInsertedInto.add(index)
|
|
}
|
|
}
|
|
return slotsInsertedInto
|
|
}
|
|
|
|
val networkSlotsStart = 0
|
|
val networkSlotsEnd = 54
|
|
val bufferSlotsStart = 54
|
|
val bufferSlotsEnd = 72
|
|
val playerSlotsStart = 72
|
|
val playerSlotsEnd = 72 + 36
|
|
fun isNetworkSlot(id: Int) = id in 0 until bufferSlotsStart
|
|
fun isBufferSlot(id: Int) = id in bufferSlotsStart until playerSlotsStart
|
|
fun isPlayerSlot(id: Int) = id >= playerSlotsStart
|
|
|
|
data class Entry(val stack: ItemStack, val amount: Int)
|
|
}
|