use of net.minecraft.network.play.client.CPacketClickWindow in project SpongeCommon by SpongePowered.
the class PacketPhase method setupPacketToStateMapping.
public void setupPacketToStateMapping() {
this.packetTranslationMap.put(CPacketKeepAlive.class, packet -> General.IGNORED);
this.packetTranslationMap.put(CPacketChatMessage.class, packet -> General.HANDLED_EXTERNALLY);
this.packetTranslationMap.put(CPacketUseEntity.class, packet -> {
final CPacketUseEntity useEntityPacket = (CPacketUseEntity) packet;
final CPacketUseEntity.Action action = useEntityPacket.getAction();
if (action == CPacketUseEntity.Action.INTERACT) {
return General.INTERACT_ENTITY;
} else if (action == CPacketUseEntity.Action.ATTACK) {
return General.ATTACK_ENTITY;
} else if (action == CPacketUseEntity.Action.INTERACT_AT) {
return General.INTERACT_AT_ENTITY;
} else {
return General.INVALID;
}
});
this.packetTranslationMap.put(CPacketPlayer.class, packet -> General.MOVEMENT);
this.packetTranslationMap.put(CPacketPlayer.Position.class, packet -> General.MOVEMENT);
this.packetTranslationMap.put(CPacketPlayer.Rotation.class, packet -> General.MOVEMENT);
this.packetTranslationMap.put(CPacketPlayer.PositionRotation.class, packet -> General.MOVEMENT);
this.packetTranslationMap.put(CPacketPlayerDigging.class, packet -> {
final CPacketPlayerDigging playerDigging = (CPacketPlayerDigging) packet;
final CPacketPlayerDigging.Action action = playerDigging.getAction();
final IPhaseState<? extends PacketContext<?>> state = INTERACTION_ACTION_MAPPINGS.get(action);
return state == null ? General.UNKNOWN : state;
});
this.packetTranslationMap.put(CPacketPlayerTryUseItemOnBlock.class, packet -> {
// Note that CPacketPlayerTryUseItem is swapped with CPacketPlayerBlockPlacement
final CPacketPlayerTryUseItemOnBlock blockPlace = (CPacketPlayerTryUseItemOnBlock) packet;
final BlockPos blockPos = blockPlace.getPos();
final EnumFacing front = blockPlace.getDirection();
final MinecraftServer server = SpongeImpl.getServer();
if (blockPos.getY() < server.getBuildLimit() - 1 || front != EnumFacing.UP && blockPos.getY() < server.getBuildLimit()) {
return General.PLACE_BLOCK;
}
return General.INVALID;
});
this.packetTranslationMap.put(CPacketPlayerTryUseItem.class, packet -> General.USE_ITEM);
this.packetTranslationMap.put(CPacketHeldItemChange.class, packet -> Inventory.SWITCH_HOTBAR_SCROLL);
this.packetTranslationMap.put(CPacketAnimation.class, packet -> General.ANIMATION);
this.packetTranslationMap.put(CPacketEntityAction.class, packet -> {
final CPacketEntityAction playerAction = (CPacketEntityAction) packet;
final CPacketEntityAction.Action action = playerAction.getAction();
return PLAYER_ACTION_MAPPINGS.get(action);
});
this.packetTranslationMap.put(CPacketInput.class, packet -> General.HANDLED_EXTERNALLY);
this.packetTranslationMap.put(CPacketCloseWindow.class, packet -> General.CLOSE_WINDOW);
this.packetTranslationMap.put(CPacketClickWindow.class, packet -> fromWindowPacket((CPacketClickWindow) packet));
this.packetTranslationMap.put(CPacketConfirmTransaction.class, packet -> General.UNKNOWN);
this.packetTranslationMap.put(CPacketCreativeInventoryAction.class, packet -> General.CREATIVE_INVENTORY);
this.packetTranslationMap.put(CPacketEnchantItem.class, packet -> Inventory.ENCHANT_ITEM);
this.packetTranslationMap.put(CPacketUpdateSign.class, packet -> General.UPDATE_SIGN);
this.packetTranslationMap.put(CPacketPlayerAbilities.class, packet -> General.IGNORED);
this.packetTranslationMap.put(CPacketTabComplete.class, packet -> General.HANDLED_EXTERNALLY);
this.packetTranslationMap.put(CPacketClientStatus.class, packet -> {
final CPacketClientStatus clientStatus = (CPacketClientStatus) packet;
final CPacketClientStatus.State status = clientStatus.getStatus();
if (status == CPacketClientStatus.State.PERFORM_RESPAWN) {
return General.REQUEST_RESPAWN;
}
return General.IGNORED;
});
this.packetTranslationMap.put(CPacketCustomPayload.class, packet -> General.HANDLED_EXTERNALLY);
this.packetTranslationMap.put(CPacketSpectate.class, packet -> General.IGNORED);
this.packetTranslationMap.put(CPacketResourcePackStatus.class, packet -> General.RESOURCE_PACK);
this.packetTranslationMap.put(CPacketPlaceRecipe.class, packet -> Inventory.PLACE_RECIPE);
}
use of net.minecraft.network.play.client.CPacketClickWindow in project SpongeCommon by SpongePowered.
the class BasicInventoryPacketState method unwind.
@Override
public void unwind(InventoryPacketContext context) {
final EntityPlayerMP player = context.getPacketPlayer();
// The server will disable the player's crafting after receiving a
// client packet
// that did not pass validation (server click item != packet click item)
// The server then sends a SPacketConfirmTransaction and waits for a
// CPacketConfirmTransaction to re-enable crafting confirming that the
// client
// acknowledged the denied transaction.
// To detect when this happens, we turn off capturing so we can avoid
// firing
// invalid events.
// See MixinNetHandlerPlayServer processClickWindow redirect for rest of
// fix.
// --bloodmc
final IMixinContainer mixinContainer = ContainerUtil.toMixin(player.openContainer);
if (!mixinContainer.capturingInventory()) {
mixinContainer.getCapturedTransactions().clear();
return;
}
// TODO clear this shit out of the context
final CPacketClickWindow packetIn = context.getPacket();
final ItemStackSnapshot lastCursor = context.getCursor();
final ItemStackSnapshot newCursor = ItemStackUtil.snapshotOf(player.inventory.getItemStack());
final Transaction<ItemStackSnapshot> transaction = new Transaction<>(lastCursor, newCursor);
final net.minecraft.inventory.Container openContainer = player.openContainer;
final List<SlotTransaction> slotTransactions = mixinContainer.getCapturedTransactions();
final int usedButton = packetIn.getUsedButton();
final List<Entity> capturedItems = new ArrayList<>();
for (EntityItem entityItem : context.getCapturedItems()) {
capturedItems.add(EntityUtil.fromNative(entityItem));
}
try (CauseStackManager.StackFrame frame = Sponge.getCauseStackManager().pushCauseFrame()) {
Sponge.getCauseStackManager().pushCause(openContainer);
Sponge.getCauseStackManager().pushCause(player);
final ClickInventoryEvent inventoryEvent;
inventoryEvent = this.createInventoryEvent(player, ContainerUtil.fromNative(openContainer), transaction, Lists.newArrayList(slotTransactions), capturedItems, usedButton);
// If this happens and we captured no entities, avoid firing events
if (mixinContainer.getCapturedTransactions().isEmpty() && capturedItems.isEmpty() && transaction.getOriginal().equals(transaction.getFinal())) {
mixinContainer.setCaptureInventory(false);
return;
}
if (inventoryEvent != null) {
// Don't fire inventory drop events when there are no entities
if (inventoryEvent instanceof AffectEntityEvent && ((AffectEntityEvent) inventoryEvent).getEntities().isEmpty()) {
slotTransactions.clear();
mixinContainer.setCaptureInventory(false);
return;
}
// packet has everything we want.
if (!(inventoryEvent instanceof ClickInventoryEvent.Drag)) {
PacketPhaseUtil.validateCapturedTransactions(packetIn.getSlotId(), openContainer, inventoryEvent.getTransactions());
}
SpongeImpl.postEvent(inventoryEvent);
if (inventoryEvent.isCancelled() || PacketPhaseUtil.allTransactionsInvalid(inventoryEvent.getTransactions())) {
if (inventoryEvent instanceof ClickInventoryEvent.Drop) {
capturedItems.clear();
}
// Restore cursor
if (inventoryEvent.isCancelled() || !inventoryEvent.getCursorTransaction().isValid()) {
PacketPhaseUtil.handleCustomCursor(player, inventoryEvent.getCursorTransaction().getOriginal());
} else if (inventoryEvent.getCursorTransaction().getCustom().isPresent()) {
PacketPhaseUtil.handleCustomCursor(player, inventoryEvent.getCursorTransaction().getFinal());
}
// Restore target slots
PacketPhaseUtil.handleSlotRestore(player, openContainer, inventoryEvent.getTransactions(), true);
} else {
PacketPhaseUtil.handleSlotRestore(player, openContainer, inventoryEvent.getTransactions(), false);
// Handle cursor
if (!inventoryEvent.getCursorTransaction().isValid()) {
PacketPhaseUtil.handleCustomCursor(player, inventoryEvent.getCursorTransaction().getOriginal());
} else if (inventoryEvent.getCursorTransaction().getCustom().isPresent()) {
PacketPhaseUtil.handleCustomCursor(player, inventoryEvent.getCursorTransaction().getFinal());
} else if (inventoryEvent instanceof ClickInventoryEvent.Drag) {
int increment;
increment = slotTransactions.stream().filter((t) -> !t.isValid()).mapToInt((t) -> t.getFinal().getQuantity()).sum();
final ItemStack cursor = inventoryEvent.getCursorTransaction().getFinal().createStack();
cursor.setQuantity(cursor.getQuantity() + increment);
PacketPhaseUtil.handleCustomCursor(player, cursor.createSnapshot());
} else if (inventoryEvent instanceof ClickInventoryEvent.Double && !(inventoryEvent instanceof ClickInventoryEvent.Shift)) {
int decrement;
decrement = slotTransactions.stream().filter((t) -> !t.isValid()).mapToInt((t) -> t.getOriginal().getQuantity()).sum();
final ItemStack cursor = inventoryEvent.getCursorTransaction().getFinal().createStack();
cursor.setQuantity(cursor.getQuantity() - decrement);
PacketPhaseUtil.handleCustomCursor(player, cursor.createSnapshot());
}
if (inventoryEvent instanceof SpawnEntityEvent) {
processSpawnedEntities(player, (SpawnEntityEvent) inventoryEvent);
} else if (!context.getCapturedEntitySupplier().isEmpty()) {
SpawnEntityEvent spawnEntityEvent = SpongeEventFactory.createSpawnEntityEvent(Sponge.getCauseStackManager().getCurrentCause(), context.getCapturedEntities());
SpongeImpl.postEvent(spawnEntityEvent);
if (!spawnEntityEvent.isCancelled()) {
processSpawnedEntities(player, spawnEntityEvent);
}
}
}
}
}
slotTransactions.clear();
mixinContainer.setCaptureInventory(false);
}
use of net.minecraft.network.play.client.CPacketClickWindow in project SpongeCommon by SpongePowered.
the class DropItemWithHotkeyState method unwind.
@Override
public void unwind(InventoryPacketContext context) {
final EntityPlayerMP player = context.getPacketPlayer();
// final ItemStack usedStack = context.getItemUsed();
// final ItemStackSnapshot usedSnapshot = ItemStackUtil.snapshotOf(usedStack);
final Entity spongePlayer = EntityUtil.fromNative(player);
try (CauseStackManager.StackFrame frame = Sponge.getCauseStackManager().pushCauseFrame()) {
Sponge.getCauseStackManager().pushCause(spongePlayer);
Sponge.getCauseStackManager().addContext(EventContextKeys.SPAWN_TYPE, InternalSpawnTypes.DROPPED_ITEM);
context.getCapturedBlockSupplier().acceptAndClearIfNotEmpty(blocks -> TrackingUtil.processBlockCaptures(blocks, this, context));
context.getCapturedItemsSupplier().acceptAndClearIfNotEmpty(items -> {
final ArrayList<Entity> entities = new ArrayList<>();
for (EntityItem item : items) {
entities.add(EntityUtil.fromNative(item));
}
int usedButton = 0;
if (context.getPacket() instanceof CPacketPlayerDigging) {
final CPacketPlayerDigging packetIn = context.getPacket();
usedButton = packetIn.getAction() == CPacketPlayerDigging.Action.DROP_ITEM ? PacketPhase.PACKET_BUTTON_PRIMARY_ID : 1;
} else {
final CPacketClickWindow packetIn = context.getPacket();
usedButton = packetIn.getUsedButton();
}
Transaction<ItemStackSnapshot> cursorTrans = new Transaction<>(ItemStackSnapshot.NONE, ItemStackSnapshot.NONE);
final IMixinContainer mixinContainer = ContainerUtil.toMixin(player.openContainer);
List<SlotTransaction> slotTrans = mixinContainer.getCapturedTransactions();
ClickInventoryEvent.Drop dropItemEvent = ((DropItemWithHotkeyState) this).createInventoryEvent(player, ContainerUtil.fromNative(player.openContainer), cursorTrans, Lists.newArrayList(slotTrans), entities, usedButton);
SpongeImpl.postEvent(dropItemEvent);
if (dropItemEvent.isCancelled() || PacketPhaseUtil.allTransactionsInvalid(dropItemEvent.getTransactions())) {
((IMixinEntityPlayerMP) player).restorePacketItem(EnumHand.MAIN_HAND);
PacketPhaseUtil.handleSlotRestore(player, player.openContainer, dropItemEvent.getTransactions(), true);
} else {
processSpawnedEntities(player, dropItemEvent);
}
slotTrans.clear();
mixinContainer.setCaptureInventory(false);
});
context.getCapturedEntityDropSupplier().acceptIfNotEmpty(itemMapping -> {
});
final IMixinContainer mixinContainer = ContainerUtil.toMixin(player.openContainer);
mixinContainer.setCaptureInventory(false);
mixinContainer.getCapturedTransactions().clear();
}
}
Aggregations