@Override
  public boolean onItemUse(
      ItemStack par1ItemStack,
      EntityPlayer par2EntityPlayer,
      World par3World,
      int par4,
      int par5,
      int par6,
      int par7,
      float par8,
      float par9,
      float par10) {
    int amountOfCorrectBlocks = 0;

    if (par3World.isRemote) {
      return false;
    } else {
      float centerX = -1;
      float centerY = -1;
      float centerZ = -1;

      for (int i = -1; i < 2; i++) {
        for (int j = -1; j < 2; j++) {
          final int id = par3World.getBlockId(par4 + i, par5, par6 + j);

          if (id == GCCoreBlocks.landingPadFull.blockID) {
            amountOfCorrectBlocks = 9;

            centerX = par4 + i + 0.5F;
            centerY = par5 - 2.2F;
            centerZ = par6 + j + 0.5F;
          }
        }
      }

      if (amountOfCorrectBlocks == 9) {
        EntitySpaceshipBase rocket = null;

        if (par1ItemStack.getItemDamage() < 10) {
          rocket =
              new SCJupiterEntityRocketT5(
                  par3World,
                  centerX,
                  centerY + 4.2D,
                  centerZ,
                  EnumRocketType.values()[par1ItemStack.getItemDamage()]);
        }

        par3World.spawnEntityInWorld(rocket);

        if (!par2EntityPlayer.capabilities.isCreativeMode) {
          par1ItemStack.stackSize--;

          if (par1ItemStack.stackSize <= 0) {
            par1ItemStack = null;
          }
        }

        if (rocket instanceof IRocketType && ((IRocketType) rocket).getType().getPreFueled()) {
          if (rocket instanceof EntityTieredRocket) {
            ((EntityTieredRocket) rocket)
                .fuelTank.fill(
                    new FluidStack(GalacticraftCore.fluidFuel, rocket.getMaxFuel()), true);
          }
        }
      } else {
        return false;
      }
    }
    return true;
  }
Exemplo n.º 2
0
  @Override
  public void handleServerSide(EntityPlayer player) {
    GCEntityPlayerMP playerBase = PlayerUtil.getPlayerBaseServerFromPlayer(player, false);
    if (playerBase == null) {
      return;
    }

    switch (this.type) {
      case S_RESPAWN_PLAYER:
        playerBase.playerNetServerHandler.sendPacket(
            new S07PacketRespawn(
                player.dimension,
                player.worldObj.difficultySetting,
                player.worldObj.getWorldInfo().getTerrainType(),
                playerBase.theItemInWorldManager.getGameType()));
        break;
      case S_TELEPORT_ENTITY:
        try {
          final WorldProvider provider = WorldUtil.getProviderForName((String) this.data.get(0));
          final Integer dim = provider.dimensionId;
          GCLog.info(
              "Found matching world ("
                  + dim.toString()
                  + ") for name: "
                  + (String) this.data.get(0));

          if (playerBase.worldObj instanceof WorldServer) {
            final WorldServer world = (WorldServer) playerBase.worldObj;

            if (provider instanceof IOrbitDimension) {
              WorldUtil.transferEntityToDimension(playerBase, dim, world);
            } else {
              WorldUtil.transferEntityToDimension(playerBase, dim, world);
            }
          }

          playerBase.getPlayerStats().teleportCooldown = 300;
          GalacticraftCore.packetPipeline.sendTo(
              new PacketSimple(EnumSimplePacket.C_CLOSE_GUI, new Object[] {}), playerBase);
        } catch (final Exception e) {
          GCLog.severe(
              "Error occurred when attempting to transfer entity to dimension: "
                  + (String) this.data.get(0));
          e.printStackTrace();
        }
        break;
      case S_IGNITE_ROCKET:
        if (!player.worldObj.isRemote
            && !player.isDead
            && player.ridingEntity != null
            && !player.ridingEntity.isDead
            && player.ridingEntity instanceof EntityTieredRocket) {
          final EntityTieredRocket ship = (EntityTieredRocket) player.ridingEntity;

          if (!ship.landing) {
            if (ship.hasValidFuel()) {
              ItemStack stack2 = playerBase.getPlayerStats().extendedInventory.getStackInSlot(4);

              if (stack2 != null && stack2.getItem() instanceof ItemParaChute
                  || playerBase.getPlayerStats().launchAttempts > 0) {
                ship.igniteCheckingCooldown();
                playerBase.getPlayerStats().launchAttempts = 0;
              } else if (playerBase.getPlayerStats().chatCooldown == 0
                  && playerBase.getPlayerStats().launchAttempts == 0) {
                player.addChatMessage(
                    new ChatComponentText(GCCoreUtil.translate("gui.rocket.warning.noparachute")));
                playerBase.getPlayerStats().chatCooldown = 250;
                playerBase.getPlayerStats().launchAttempts = 1;
              }
            } else if (playerBase.getPlayerStats().chatCooldown == 0) {
              player.addChatMessage(
                  new ChatComponentText(GCCoreUtil.translate("gui.rocket.warning.nofuel")));
              playerBase.getPlayerStats().chatCooldown = 250;
            }
          }
        }
        break;
      case S_OPEN_SCHEMATIC_PAGE:
        if (player != null) {
          final ISchematicPage page =
              SchematicRegistry.getMatchingRecipeForID((Integer) this.data.get(0));

          player.openGui(
              GalacticraftCore.instance,
              page.getGuiID(),
              player.worldObj,
              (int) player.posX,
              (int) player.posY,
              (int) player.posZ);
        }
        break;
      case S_OPEN_FUEL_GUI:
        if (player.ridingEntity instanceof EntityBuggy) {
          GCCoreUtil.openBuggyInv(
              playerBase,
              (EntityBuggy) player.ridingEntity,
              ((EntityBuggy) player.ridingEntity).getType());
        } else if (player.ridingEntity instanceof EntitySpaceshipBase) {
          player.openGui(
              GalacticraftCore.instance,
              GuiIdsCore.ROCKET_INVENTORY,
              player.worldObj,
              (int) player.posX,
              (int) player.posY,
              (int) player.posZ);
        }
        break;
      case S_UPDATE_SHIP_YAW:
        if (player.ridingEntity instanceof EntitySpaceshipBase) {
          final EntitySpaceshipBase ship = (EntitySpaceshipBase) player.ridingEntity;

          if (ship != null) {
            ship.rotationYaw = (Float) this.data.get(0);
          }
        }
        break;
      case S_UPDATE_SHIP_PITCH:
        if (player.ridingEntity instanceof EntitySpaceshipBase) {
          final EntitySpaceshipBase ship = (EntitySpaceshipBase) player.ridingEntity;

          if (ship != null) {
            ship.rotationPitch = (Float) this.data.get(0);
          }
        }
        break;
      case S_SET_ENTITY_FIRE:
        Entity entity = player.worldObj.getEntityByID((Integer) this.data.get(0));

        if (entity instanceof EntityLiving) {
          ((EntityLiving) entity).setFire(3);
        }
        break;
      case S_OPEN_REFINERY_GUI:
        player.openGui(
            GalacticraftCore.instance,
            -1,
            player.worldObj,
            (Integer) this.data.get(0),
            (Integer) this.data.get(1),
            (Integer) this.data.get(2));
        break;
      case S_BIND_SPACE_STATION_ID:
        if ((playerBase.getPlayerStats().spaceStationDimensionID == -1
                || playerBase.getPlayerStats().spaceStationDimensionID == 0)
            && !ConfigManagerCore.disableSpaceStationCreation) {
          WorldUtil.bindSpaceStationToNewDimension(playerBase.worldObj, playerBase);

          WorldUtil.getSpaceStationRecipe((Integer) this.data.get(0)).matches(playerBase, true);
        }
        break;
      case S_UNLOCK_NEW_SCHEMATIC:
        final Container container = player.openContainer;

        if (container instanceof ContainerSchematic) {
          final ContainerSchematic schematicContainer = (ContainerSchematic) container;

          ItemStack stack = schematicContainer.craftMatrix.getStackInSlot(0);

          if (stack != null) {
            final ISchematicPage page = SchematicRegistry.getMatchingRecipeForItemStack(stack);

            if (page != null) {
              SchematicRegistry.unlockNewPage(playerBase, stack);

              if (--stack.stackSize <= 0) {
                stack = null;
              }

              schematicContainer.craftMatrix.setInventorySlotContents(0, stack);
              schematicContainer.craftMatrix.markDirty();

              GalacticraftCore.packetPipeline.sendTo(
                  new PacketSimple(
                      EnumSimplePacket.C_ADD_NEW_SCHEMATIC, new Object[] {page.getPageID()}),
                  playerBase);
            }
          }
        }
        break;
      case S_UPDATE_DISABLEABLE_BUTTON:
        final TileEntity tileAt =
            player.worldObj.getTileEntity(
                (Integer) this.data.get(0), (Integer) this.data.get(1), (Integer) this.data.get(2));

        if (tileAt instanceof IDisableableMachine) {
          final IDisableableMachine machine = (IDisableableMachine) tileAt;

          machine.setDisabled(
              (Integer) this.data.get(3), !machine.getDisabled((Integer) this.data.get(3)));
        }
        break;
      case S_ON_FAILED_CHEST_UNLOCK:
        if (playerBase.getPlayerStats().chatCooldown == 0) {
          player.addChatMessage(
              new ChatComponentText(
                  GCCoreUtil.translateWithFormat("gui.chest.warning.wrongkey", this.data.get(0))));
          playerBase.getPlayerStats().chatCooldown = 100;
        }
        break;
      case S_RENAME_SPACE_STATION:
        final SpaceStationWorldData ssdata =
            SpaceStationWorldData.getStationData(
                playerBase.worldObj, (Integer) this.data.get(1), playerBase);

        if (ssdata != null
            && ssdata.getOwner().equalsIgnoreCase(player.getGameProfile().getName())) {
          ssdata.setSpaceStationName((String) this.data.get(0));
          ssdata.setDirty(true);
        }
        break;
      case S_OPEN_EXTENDED_INVENTORY:
        player.openGui(
            GalacticraftCore.instance, GuiIdsCore.EXTENDED_INVENTORY, player.worldObj, 0, 0, 0);
        break;
      case S_ON_ADVANCED_GUI_CLICKED_INT:
        TileEntity tile1 =
            player.worldObj.getTileEntity(
                (Integer) this.data.get(1), (Integer) this.data.get(2), (Integer) this.data.get(3));

        switch ((Integer) this.data.get(0)) {
          case 0:
            if (tile1 instanceof TileEntityAirLockController) {
              TileEntityAirLockController launchController = (TileEntityAirLockController) tile1;
              launchController.redstoneActivation = (Integer) this.data.get(4) == 1;
            }
            break;
          case 1:
            if (tile1 instanceof TileEntityAirLockController) {
              TileEntityAirLockController launchController = (TileEntityAirLockController) tile1;
              launchController.playerDistanceActivation = (Integer) this.data.get(4) == 1;
            }
            break;
          case 2:
            if (tile1 instanceof TileEntityAirLockController) {
              TileEntityAirLockController launchController = (TileEntityAirLockController) tile1;
              launchController.playerDistanceSelection = (Integer) this.data.get(4);
            }
            break;
          case 3:
            if (tile1 instanceof TileEntityAirLockController) {
              TileEntityAirLockController launchController = (TileEntityAirLockController) tile1;
              launchController.playerNameMatches = (Integer) this.data.get(4) == 1;
            }
            break;
          case 4:
            if (tile1 instanceof TileEntityAirLockController) {
              TileEntityAirLockController launchController = (TileEntityAirLockController) tile1;
              launchController.invertSelection = (Integer) this.data.get(4) == 1;
            }
            break;
          case 5:
            if (tile1 instanceof TileEntityAirLockController) {
              TileEntityAirLockController launchController = (TileEntityAirLockController) tile1;
              launchController.lastHorizontalModeEnabled = launchController.horizontalModeEnabled;
              launchController.horizontalModeEnabled = (Integer) this.data.get(4) == 1;
            }
            break;
          case 6:
            if (tile1 instanceof IBubbleProvider) {
              IBubbleProvider distributor = (IBubbleProvider) tile1;
              distributor.setBubbleVisible((Integer) this.data.get(4) == 1);
            }
            break;
          default:
            break;
        }
        break;
      case S_ON_ADVANCED_GUI_CLICKED_STRING:
        TileEntity tile2 =
            player.worldObj.getTileEntity(
                (Integer) this.data.get(1), (Integer) this.data.get(2), (Integer) this.data.get(3));

        switch ((Integer) this.data.get(0)) {
          case 0:
            if (tile2 instanceof TileEntityAirLockController) {
              TileEntityAirLockController launchController = (TileEntityAirLockController) tile2;
              launchController.playerToOpenFor = (String) this.data.get(4);
            }
            break;
          default:
            break;
        }
        break;
      case S_UPDATE_SHIP_MOTION_Y:
        int entityID = (Integer) this.data.get(0);
        boolean up = (Boolean) this.data.get(1);

        Entity entity2 = player.worldObj.getEntityByID(entityID);

        if (entity2 instanceof EntityAutoRocket) {
          EntityAutoRocket autoRocket = (EntityAutoRocket) entity2;
          autoRocket.motionY += up ? 0.02F : -0.02F;
        }

        break;
      case S_START_NEW_SPACE_RACE:
        Integer teamID = (Integer) this.data.get(0);
        String teamName = (String) this.data.get(1);
        FlagData flagData = (FlagData) this.data.get(2);
        Vector3 teamColor = (Vector3) this.data.get(3);
        List<String> playerList = new ArrayList<String>();

        for (int i = 4; i < this.data.size(); i++) {
          playerList.add((String) this.data.get(i));
        }

        boolean previousData = SpaceRaceManager.getSpaceRaceFromID(teamID) != null;

        SpaceRace newRace = new SpaceRace(playerList, teamName, flagData, teamColor);

        if (teamID > 0) {
          newRace.setSpaceRaceID(teamID);
        }

        SpaceRaceManager.addSpaceRace(newRace);

        if (previousData) {
          SpaceRaceManager.sendSpaceRaceData(
              null, SpaceRaceManager.getSpaceRaceFromPlayer(playerBase.getGameProfile().getName()));
        }
        break;
      case S_REQUEST_FLAG_DATA:
        SpaceRaceManager.sendSpaceRaceData(
            playerBase, SpaceRaceManager.getSpaceRaceFromPlayer((String) this.data.get(0)));
        break;
      case S_INVITE_RACE_PLAYER:
        GCEntityPlayerMP playerInvited =
            PlayerUtil.getPlayerBaseServerFromPlayerUsername((String) this.data.get(0), true);
        if (playerInvited != null) {
          Integer teamInvitedTo = (Integer) this.data.get(1);
          SpaceRace race = SpaceRaceManager.getSpaceRaceFromID(teamInvitedTo);

          if (race != null) {
            playerInvited.getPlayerStats().spaceRaceInviteTeamID = teamInvitedTo;
            String dA = EnumColor.DARK_AQUA.code;
            String bG = EnumColor.BRIGHT_GREEN.code;
            String dB = EnumColor.PURPLE.code;
            String teamNameTotal = "";
            String[] teamNameSplit = race.getTeamName().split(" ");
            for (String teamNamePart : teamNameSplit) {
              teamNameTotal = teamNameTotal.concat(dB + teamNamePart + " ");
            }
            playerInvited.addChatMessage(
                new ChatComponentText(
                        "Received Space Race Team Invite from "
                            + bG
                            + player.getGameProfile().getName()
                            + dA
                            + ". To join "
                            + teamNameTotal
                            + dA
                            + "use command "
                            + EnumColor.AQUA
                            + "/joinrace")
                    .setChatStyle(new ChatStyle().setColor(EnumChatFormatting.DARK_AQUA)));
          }
        }
        break;
      case S_REMOVE_RACE_PLAYER:
        Integer teamInvitedTo = (Integer) this.data.get(1);
        SpaceRace race = SpaceRaceManager.getSpaceRaceFromID(teamInvitedTo);

        if (race != null) {
          String playerToRemove = (String) this.data.get(0);

          if (!race.getPlayerNames().remove(playerToRemove)) {
            player.addChatMessage(
                new ChatComponentText("Could not find player with name: " + playerToRemove));
          } else {
            SpaceRaceManager.onPlayerRemoval(playerToRemove, race);
          }
        }
        break;
      case S_ADD_RACE_PLAYER:
        Integer teamToAddPlayer = (Integer) this.data.get(1);
        SpaceRace spaceRaceToAddPlayer = SpaceRaceManager.getSpaceRaceFromID(teamToAddPlayer);

        if (spaceRaceToAddPlayer != null) {
          String playerToAdd = (String) this.data.get(0);

          if (!spaceRaceToAddPlayer.getPlayerNames().contains(playerToAdd)) {
            SpaceRace oldRace = null;
            while ((oldRace = SpaceRaceManager.getSpaceRaceFromPlayer(playerToAdd)) != null) {
              SpaceRaceManager.removeSpaceRace(oldRace);
            }

            spaceRaceToAddPlayer.getPlayerNames().add(playerToAdd);
            SpaceRaceManager.sendSpaceRaceData(null, spaceRaceToAddPlayer);

            for (String member : spaceRaceToAddPlayer.getPlayerNames()) {
              EntityPlayerMP memberObj =
                  MinecraftServer.getServer()
                      .getConfigurationManager()
                      .getPlayerForUsername(member);

              if (memberObj != null) {
                memberObj.addChatMessage(
                    new ChatComponentText(
                            EnumColor.BRIGHT_GREEN
                                + playerToAdd
                                + EnumColor.DARK_AQUA
                                + " has joined the Space Race!")
                        .setChatStyle(new ChatStyle().setColor(EnumChatFormatting.DARK_AQUA)));
              }
            }
          } else {
            player.addChatMessage(
                new ChatComponentText("You are already a part of this space race!")
                    .setChatStyle(new ChatStyle().setColor(EnumChatFormatting.DARK_RED)));
          }
        }
        break;
      default:
        break;
    }
  }
  @Override
  public void tickStart(EnumSet<TickType> type, Object... tickData) {
    final Minecraft minecraft = FMLClientHandler.instance().getClient();

    final WorldClient world = minecraft.theWorld;

    final EntityClientPlayerMP player = minecraft.thePlayer;

    if (type.equals(EnumSet.of(TickType.CLIENT))) {
      if (GCCoreTickHandlerClient.tickCount >= Long.MAX_VALUE) {
        GCCoreTickHandlerClient.tickCount = 0;
      }

      GCCoreTickHandlerClient.tickCount++;

      if (GCCoreTickHandlerClient.tickCount % 20 == 0) {
        if (player != null
            && player.inventory.armorItemInSlot(3) != null
            && player.inventory.armorItemInSlot(3).getItem() instanceof GCCoreItemSensorGlasses) {
          ClientProxyCore.valueableBlocks.clear();

          for (int i = -4; i < 5; i++) {
            for (int j = -4; j < 5; j++) {
              for (int k = -4; k < 5; k++) {
                int x = MathHelper.floor_double(player.posX + i);
                int y = MathHelper.floor_double(player.posY + j);
                int z = MathHelper.floor_double(player.posZ + k);

                final int id = player.worldObj.getBlockId(x, y, z);

                if (id != 0) {
                  final Block block = Block.blocksList[id];
                  int metadata = world.getBlockMetadata(x, y, z);
                  boolean isDetectable = false;

                  for (BlockMetaList blockMetaList : ClientProxyCore.detectableBlocks) {
                    if (blockMetaList.getBlockID() == id
                        && blockMetaList.getMetaList().contains(metadata)) {
                      isDetectable = true;
                      break;
                    }
                  }

                  if (isDetectable) {
                    if (!this.alreadyContainsBlock(x, y, z)) {
                      ClientProxyCore.valueableBlocks.add(new Vector3(x, y, z));
                    }
                  } else if (block instanceof IDetectableResource
                      && ((IDetectableResource) block).isValueable(metadata)) {
                    if (!this.alreadyContainsBlock(x, y, z)) {
                      ClientProxyCore.valueableBlocks.add(new Vector3(x, y, z));
                    }

                    List<Integer> metaList = Lists.newArrayList();
                    metaList.add(metadata);

                    for (BlockMetaList blockMetaList : ClientProxyCore.detectableBlocks) {
                      if (blockMetaList.getBlockID() == id) {
                        metaList.addAll(blockMetaList.getMetaList());
                        break;
                      }
                    }

                    ClientProxyCore.detectableBlocks.add(new BlockMetaList(id, metaList));
                  }
                }
              }
            }
          }
        }
      }

      if (GCCoreTickHandlerClient.addTabsNextTick) {
        if (minecraft.currentScreen.getClass().equals(GuiInventory.class)) {
          GCCoreTickHandlerClient.addTabsToInventory((GuiContainer) minecraft.currentScreen);
        }

        GCCoreTickHandlerClient.addTabsNextTick = false;
      }

      if (minecraft.currentScreen != null && minecraft.currentScreen instanceof GuiMainMenu) {
        GalacticraftCore.playersServer.clear();
        GalacticraftCore.playersClient.clear();
        ClientProxyCore.playerItemData.clear();

        if (GCCoreTickHandlerClient.missingRequirementThread == null) {
          GCCoreTickHandlerClient.missingRequirementThread =
              new GCCoreThreadRequirementMissing(FMLCommonHandler.instance().getEffectiveSide());
          GCCoreTickHandlerClient.missingRequirementThread.start();
        }
      }

      if (world != null && GCCoreTickHandlerClient.checkedVersion) {
        GCCoreUtil.checkVersion(Side.CLIENT);
        GCCoreTickHandlerClient.checkedVersion = false;
      }

      if (player != null
          && player.ridingEntity != null
          && player.ridingEntity instanceof EntitySpaceshipBase) {
        final Object[] toSend = {player.ridingEntity.rotationPitch};
        PacketDispatcher.sendPacketToServer(
            PacketUtil.createPacket(
                GalacticraftCore.CHANNEL, EnumPacketServer.UPDATE_SHIP_PITCH, toSend));
        final Object[] toSend2 = {player.ridingEntity.rotationYaw};
        PacketDispatcher.sendPacketToServer(
            PacketUtil.createPacket(
                GalacticraftCore.CHANNEL, EnumPacketServer.UPDATE_SHIP_YAW, toSend2));
      }

      if (world != null && world.provider instanceof WorldProviderSurface) {
        if (world.provider.getSkyRenderer() == null
            && player.ridingEntity != null
            && player.ridingEntity.posY >= 200) {
          world.provider.setSkyRenderer(new GCCoreSkyProviderOverworld());
        } else if (world.provider.getSkyRenderer() != null
            && world.provider.getSkyRenderer() instanceof GCCoreSkyProviderOverworld
            && (player.ridingEntity == null || player.ridingEntity.posY < 200)) {
          world.provider.setSkyRenderer(null);
        }
      }

      if (world != null && world.provider instanceof GCCoreWorldProviderSpaceStation) {
        if (world.provider.getSkyRenderer() == null) {
          world.provider.setSkyRenderer(
              new GCCoreSkyProviderOrbit(
                  new ResourceLocation(
                      GalacticraftCore.ASSET_DOMAIN, "textures/gui/planets/overworld.png"),
                  true,
                  true));
        }

        if (world.provider.getCloudRenderer() == null) {
          world.provider.setCloudRenderer(new GCCoreCloudRenderer());
        }
      }

      if (player != null
          && player.ridingEntity != null
          && player.ridingEntity instanceof EntitySpaceshipBase) {
        final EntitySpaceshipBase ship = (EntitySpaceshipBase) player.ridingEntity;

        if (minecraft.gameSettings.keyBindLeft.pressed) {
          ship.turnYaw(-1.0F);
          final Object[] toSend = {ship.rotationYaw};
          PacketDispatcher.sendPacketToServer(
              PacketUtil.createPacket(
                  GalacticraftCore.CHANNEL, EnumPacketServer.UPDATE_SHIP_YAW, toSend));
        }

        if (minecraft.gameSettings.keyBindRight.pressed) {
          ship.turnYaw(1.0F);
          final Object[] toSend = {ship.rotationYaw};
          PacketDispatcher.sendPacketToServer(
              PacketUtil.createPacket(
                  GalacticraftCore.CHANNEL, EnumPacketServer.UPDATE_SHIP_YAW, toSend));
        }

        if (minecraft.gameSettings.keyBindForward.pressed) {
          if (ship.getLaunched()) {
            ship.turnPitch(-0.7F);
            final Object[] toSend = {ship.rotationPitch};
            PacketDispatcher.sendPacketToServer(
                PacketUtil.createPacket(
                    GalacticraftCore.CHANNEL, EnumPacketServer.UPDATE_SHIP_PITCH, toSend));
          }
        }

        if (minecraft.gameSettings.keyBindBack.pressed) {
          if (ship.getLaunched()) {
            ship.turnPitch(0.7F);
            final Object[] toSend = {ship.rotationPitch};
            PacketDispatcher.sendPacketToServer(
                PacketUtil.createPacket(
                    GalacticraftCore.CHANNEL, EnumPacketServer.UPDATE_SHIP_PITCH, toSend));
          }
        }
      }

      if (world != null) {
        for (int i = 0; i < world.loadedEntityList.size(); i++) {
          final Entity e = (Entity) world.loadedEntityList.get(i);

          if (e != null) {
            if (e instanceof GCCoreEntityRocketT1) {
              final GCCoreEntityRocketT1 eship = (GCCoreEntityRocketT1) e;

              if (eship.rocketSoundUpdater == null) {
                eship.rocketSoundUpdater =
                    new GCCoreSoundUpdaterSpaceship(
                        FMLClientHandler.instance().getClient().sndManager,
                        eship,
                        FMLClientHandler.instance().getClient().thePlayer);
              }
            }
          }
        }
      }

      if (FMLClientHandler.instance().getClient().currentScreen instanceof GCCoreGuiChoosePlanet) {
        player.motionY = 0;
      }

      if (world != null && world.provider instanceof IGalacticraftWorldProvider) {
        world.setRainStrength(0.0F);
      }

      if (!minecraft.gameSettings.keyBindJump.pressed) {
        ClientProxyCore.lastSpacebarDown = false;
      }

      if (player != null
          && player.ridingEntity != null
          && minecraft.gameSettings.keyBindJump.pressed
          && !ClientProxyCore.lastSpacebarDown) {
        final Object[] toSend = {0};
        PacketDispatcher.sendPacketToServer(
            PacketUtil.createPacket(
                GalacticraftCore.CHANNEL, EnumPacketServer.IGNITE_ROCKET, toSend));
        ClientProxyCore.lastSpacebarDown = true;
      }
    }
  }