示例#1
0
 @Override
 public IMessage onMessage(PacketInvokStarting message, MessageContext ctx) {
   ctx.getServerHandler().playerEntity.closeScreen();
   HammerHelper.startInvoking(
       ctx.getServerHandler().playerEntity.worldObj,
       ctx.getServerHandler().playerEntity,
       message.x,
       message.y,
       message.z);
   return null;
 }
示例#2
0
 @Override
 public IMessage onMessage(PacketTcomAction message, MessageContext ctx) {
   TileTcom tile = message.getTileEntity(ctx.getServerHandler().playerEntity.worldObj);
   if (tile == null) {
     return null;
   }
   if (message.mat != null) {
     tile.extractItems(message.mat, ctx.getServerHandler().playerEntity);
   } else if (message.enchant >= 0) {
     tile.extractEnchantment(message.enchant, ctx.getServerHandler().playerEntity);
   } else {
     tile.updateClient(ctx.getServerHandler().playerEntity);
   }
   return null;
 }
  @Override
  public IMessage onMessage(ItemBarPacketProcessor message, MessageContext ctx) {
    try {
      ItemStack stack = null;

      if (message.slot > -1 && message.slot < 9) {
        stack = ctx.getServerHandler().playerEntity.inventory.getStackInSlot(message.slot);
      }
      if (stack != null && stack.getItem() != null && stack.getItem() instanceof ItemBraceBase) {
        ((ItemBraceBase) stack.getItem())
            .wheelEvent(ctx.getServerHandler().playerEntity, stack, message.key, message.dwheel);
      }
    } finally {
    }

    return null;
  }
 @Override
 public IMessage onMessage(AddTrustedPlayerMessage message, MessageContext ctx) {
   World world = ctx.getServerHandler().playerEntity.worldObj;
   TurretBase turret =
       (TurretBase) world.getTileEntity(message.getX(), message.getY(), message.getZ());
   turret.addTrustedPlayer(message.getPlayer());
   world.markBlockForUpdate(message.getX(), message.getY(), message.getZ());
   return null;
 }
 @Override
 public IMessage onMessage(ItemNamePacket message, MessageContext ctx) {
   EntityPlayerMP player = ctx.getServerHandler().playerEntity;
   TileEntity hammer = player.worldObj.getTileEntity(message.x, message.y, message.z);
   if (hammer != null && hammer instanceof TileEntitySteamHammer) {
     ContainerSteamAnvil anvil = (ContainerSteamAnvil) player.openContainer;
     anvil.updateItemName(message.name);
   }
   return null;
 }
 @Override
 public PacketAllReceiversReady onMessage(PacketGetAllReceivers message, MessageContext ctx) {
   EntityPlayer player = ctx.getServerHandler().playerEntity;
   TeleportDestinations destinations = TeleportDestinations.getDestinations(player.worldObj);
   List<TeleportDestinationClientInfo> destinationList =
       new ArrayList<TeleportDestinationClientInfo>(destinations.getValidDestinations(null));
   addDimensions(destinationList);
   addRfToolsDimensions(player.worldObj, destinationList);
   return new PacketAllReceiversReady(destinationList);
 }
示例#7
0
  @Override
  public IMessage onMessage(PacketGuiId message, MessageContext ctx) {

    EntityPlayerMP p = ctx.getServerHandler().playerEntity;

    int i = message.getData().getInteger("gui");

    p.openGui(MCEconomy2.instance, i, p.worldObj, (int) p.posX, (int) p.posY, (int) p.posZ);

    return null;
  }
 @Override
 public IMessage onMessage(MessageSwitchRecipe message, MessageContext ctx) {
   Container container = ctx.getServerHandler().playerEntity.openContainer;
   if (container instanceof ContainerRecipeBook) {
     if (message.getDirection() == 1) {
       ((ContainerRecipeBook) container).nextRecipe();
     } else if (message.getDirection() == -1) {
       ((ContainerRecipeBook) container).prevRecipe();
     }
   }
   return null;
 }
  @Override
  public IMessage onMessage(MessageTelePipeUpdate message, MessageContext ctx) {
    TileEntity te =
        ctx.getServerHandler().playerEntity.worldObj.getTileEntity(message.x, message.y, message.z);
    if (te instanceof TileGenericPipe) {
      PipeTeleport<?> pipe = (PipeTeleport<?>) ((TileGenericPipe) te).pipe;
      // only allow the owner to change pipe state
      EntityPlayerMP entityPlayer = (EntityPlayerMP) ctx.getServerHandler().playerEntity;
      if (!PipeTeleport.canPlayerModifyPipe(entityPlayer, pipe)) {
        entityPlayer.addChatComponentMessage(
            new ChatComponentText("Sorry, You may not change pipe state."));
        return null;
      }
      int frequency = message._freq;
      if (frequency < 0) {
        frequency = 0;
      }
      pipe.setFrequency(frequency);
      pipe.state = (byte) message._state;
      pipe.isPublic = message._isPublic;
    }

    return null;
  }
示例#10
0
 public EntityPlayer getPlayerFromMessageContext(MessageContext ctx) {
   switch (ctx.side) {
     case CLIENT:
       {
         assert false : "Message for CLIENT received on dedicated server";
       }
     case SERVER:
       {
         EntityPlayer entityPlayerMP = ctx.getServerHandler().playerEntity;
         return entityPlayerMP;
       }
     default:
       assert false : "Invalid side in TestMsgHandler: " + ctx.side;
   }
   return null;
 }
    public IMessage onMessage(PacketSetExplosiveState packet, MessageContext context) {
      EntityPlayer player = context.getServerHandler().playerEntity;

      if (getWorld(player).getBlock(packet.x, packet.y, packet.z) != null
          && getWorld(player).getBlock(packet.x, packet.y, packet.z) instanceof IExplosive) {
        if (packet.state.equalsIgnoreCase("activate")) {
          ((IExplosive) getWorld(player).getBlock(packet.x, packet.y, packet.z))
              .activateMine(getWorld(player), packet.x, packet.y, packet.z);
        } else if (packet.state.equalsIgnoreCase("defuse")) {
          ((IExplosive) getWorld(player).getBlock(packet.x, packet.y, packet.z))
              .defuseMine(getWorld(player), packet.x, packet.y, packet.z);
        } else if (packet.state.equalsIgnoreCase("detonate")) {
          ((IExplosive) getWorld(player).getBlock(packet.x, packet.y, packet.z))
              .explode(getWorld(player), packet.x, packet.y, packet.z);
        }
      }

      return null;
    }
 @Override
 public IMessage onMessage(MessageSeedInfuser message, MessageContext ctx) {
   int x = message.x, y = message.y, z = message.z;
   if (ctx.side.isServer()) {
     TileEntity te = ctx.getServerHandler().playerEntity.worldObj.getTileEntity(x, y, z);
     if (te instanceof TileEntitySeedInfuser) {
       TileEntitySeedInfuser infuser = (TileEntitySeedInfuser) te;
       if (infuser.getStackInSlot(1) != null && infuser.getStackInSlot(1).stackSize > 0) {
         infuser.setInfusing(true);
       }
       int index = infuser.getRecipeIndex();
       if (index != -1) {
         return new MessageSeedInfuser(x, y, z, index);
       }
     }
   } else {
     TileEntity te = FluxedCrystals.proxy.getClientWorld().getTileEntity(x, y, z);
     if (te instanceof TileEntitySeedInfuser) {
       ((TileEntitySeedInfuser) te).setRecipeIndex(message.data);
       te.getWorldObj().markBlockForUpdate(x, y, z);
     }
   }
   return null;
 }
 @Override
 public IMessage onMessage(PacketClientRequest message, MessageContext ctx) {
   NuclearNetworkHelper.sendDisplaySettingsToPlayer(
       message.x, message.y, message.z, ctx.getServerHandler().playerEntity);
   return null;
 }
 @Override
 public IMessage onMessage(NBTPacketUp message, MessageContext ctx) {
   if (message.type == TypesUp.RECONFIGURE.ordinal())
     PacketCarriageUpdate.receive(message.body, ctx.getServerHandler().playerEntity);
   return null;
 }