├── .gitignore ├── CONTRIBUTING.md ├── LGPL.txt ├── LICENCE.txt ├── README.md ├── maps.yml ├── pom.xml └── src ├── main ├── java │ ├── de │ │ └── minetick │ │ │ ├── AutoSaveJob.java │ │ │ ├── ChunkGenerationPolicy.java │ │ │ ├── MinetickChunkCoordComparator.java │ │ │ ├── MinetickEmptyChunk.java │ │ │ ├── MinetickMod.java │ │ │ ├── MinetickModConfig.java │ │ │ ├── MinetickThreadFactory.java │ │ │ ├── PlayerChunkBuffer.java │ │ │ ├── PlayerChunkManager.java │ │ │ ├── PlayerChunkSendQueue.java │ │ │ ├── PlayerMovement.java │ │ │ ├── WorldTicker.java │ │ │ ├── antixray │ │ │ └── AntiXRay.java │ │ │ ├── modcommands │ │ │ ├── AntiXRayCommand.java │ │ │ ├── LoadedChunksCommand.java │ │ │ ├── PacketCompressionCommand.java │ │ │ ├── PacketsPerTickCommand.java │ │ │ ├── ReloadSettingsCommand.java │ │ │ ├── SetEntityActivationRange.java │ │ │ ├── TPSCommand.java │ │ │ ├── ThreadListCommand.java │ │ │ ├── ThreadPoolsCommand.java │ │ │ └── WorldStatsCommand.java │ │ │ ├── packetbuilder │ │ │ ├── PacketBuilderBuffer.java │ │ │ ├── PacketBuilderChunkData.java │ │ │ ├── PacketBuilderChunkDataBulk.java │ │ │ ├── PacketBuilderJobInterface.java │ │ │ ├── PacketBuilderThread.java │ │ │ ├── PacketBuilderThreadPool.java │ │ │ └── jobs │ │ │ │ ├── PBJobPlayOutMapChunk.java │ │ │ │ └── PBJobPlayOutMapChunkBulk.java │ │ │ ├── pathsearch │ │ │ ├── MinetickNavigation.java │ │ │ ├── MinetickPathfinder.java │ │ │ ├── PathSearchJob.java │ │ │ ├── PathSearchJobEntity.java │ │ │ ├── PathSearchJobNavigationEntity.java │ │ │ ├── PathSearchJobNavigationPosition.java │ │ │ ├── PathSearchJobPosition.java │ │ │ ├── PathSearchThrottlerThread.java │ │ │ ├── PositionPathSearchType.java │ │ │ └── cache │ │ │ │ ├── SearchCacheEntry.java │ │ │ │ ├── SearchCacheEntryEntity.java │ │ │ │ └── SearchCacheEntryPosition.java │ │ │ └── profiler │ │ │ ├── Profile.java │ │ │ ├── ProfileCall.java │ │ │ ├── Profiler.java │ │ │ ├── ProfilingComperator.java │ │ │ └── WorldProfile.java │ ├── jline │ │ ├── AnsiWindowsTerminal.java │ │ └── internal │ │ │ └── TerminalLineSettings.java │ ├── net │ │ └── minecraft │ │ │ └── server │ │ │ ├── AABBPool.java │ │ │ ├── BiomeDecorator.java │ │ │ ├── Block.java │ │ │ ├── BlockBloodStone.java │ │ │ ├── BlockButtonAbstract.java │ │ │ ├── BlockCactus.java │ │ │ ├── BlockCake.java │ │ │ ├── BlockCocoa.java │ │ │ ├── BlockCommand.java │ │ │ ├── BlockCrops.java │ │ │ ├── BlockDaylightDetector.java │ │ │ ├── BlockDiodeAbstract.java │ │ │ ├── BlockDispenser.java │ │ │ ├── BlockDoor.java │ │ │ ├── BlockDragonEgg.java │ │ │ ├── BlockDropper.java │ │ │ ├── BlockEnderPortal.java │ │ │ ├── BlockFalling.java │ │ │ ├── BlockFire.java │ │ │ ├── BlockFlowerPot.java │ │ │ ├── BlockFlowing.java │ │ │ ├── BlockGrass.java │ │ │ ├── BlockHopper.java │ │ │ ├── BlockIce.java │ │ │ ├── BlockLeaves.java │ │ │ ├── BlockLever.java │ │ │ ├── BlockMinecartDetector.java │ │ │ ├── BlockMobSpawner.java │ │ │ ├── BlockMushroom.java │ │ │ ├── BlockMycel.java │ │ │ ├── BlockNetherWart.java │ │ │ ├── BlockOre.java │ │ │ ├── BlockPiston.java │ │ │ ├── BlockPistonExtension.java │ │ │ ├── BlockPortal.java │ │ │ ├── BlockPoweredRail.java │ │ │ ├── BlockPressurePlateAbstract.java │ │ │ ├── BlockPressurePlateBinary.java │ │ │ ├── BlockPressurePlateWeighted.java │ │ │ ├── BlockPumpkin.java │ │ │ ├── BlockRedstoneLamp.java │ │ │ ├── BlockRedstoneOre.java │ │ │ ├── BlockRedstoneTorch.java │ │ │ ├── BlockRedstoneWire.java │ │ │ ├── BlockReed.java │ │ │ ├── BlockSapling.java │ │ │ ├── BlockSign.java │ │ │ ├── BlockSkull.java │ │ │ ├── BlockSnow.java │ │ │ ├── BlockSoil.java │ │ │ ├── BlockStationary.java │ │ │ ├── BlockStem.java │ │ │ ├── BlockTrapdoor.java │ │ │ ├── BlockTripwire.java │ │ │ ├── BlockTripwireHook.java │ │ │ ├── BlockVine.java │ │ │ ├── Chunk.java │ │ │ ├── ChunkCoordIntPair.java │ │ │ ├── ChunkMap.java │ │ │ ├── ChunkProviderGenerate.java │ │ │ ├── ChunkProviderHell.java │ │ │ ├── ChunkProviderServer.java │ │ │ ├── ChunkProviderTheEnd.java │ │ │ ├── ChunkRegionLoader.java │ │ │ ├── ChunkSection.java │ │ │ ├── ClientCommandOrdinalWrapper.java │ │ │ ├── CommandBlockListenerAbstract.java │ │ │ ├── Container.java │ │ │ ├── ContainerAnvil.java │ │ │ ├── ContainerAnvilInventory.java │ │ │ ├── ContainerBeacon.java │ │ │ ├── ContainerBrewingStand.java │ │ │ ├── ContainerChest.java │ │ │ ├── ContainerDispenser.java │ │ │ ├── ContainerEnchantTable.java │ │ │ ├── ContainerEnchantTableInventory.java │ │ │ ├── ContainerFurnace.java │ │ │ ├── ContainerHopper.java │ │ │ ├── ContainerHorse.java │ │ │ ├── ContainerMerchant.java │ │ │ ├── ContainerPlayer.java │ │ │ ├── ContainerWorkbench.java │ │ │ ├── ControllerLook.java │ │ │ ├── ControllerMove.java │ │ │ ├── CraftingManager.java │ │ │ ├── CrashReport.java │ │ │ ├── DedicatedServer.java │ │ │ ├── DispenseBehaviorArmor.java │ │ │ ├── DispenseBehaviorBoat.java │ │ │ ├── DispenseBehaviorBonemeal.java │ │ │ ├── DispenseBehaviorEmptyBucket.java │ │ │ ├── DispenseBehaviorFilledBucket.java │ │ │ ├── DispenseBehaviorFireball.java │ │ │ ├── DispenseBehaviorFireworks.java │ │ │ ├── DispenseBehaviorFlintAndSteel.java │ │ │ ├── DispenseBehaviorItem.java │ │ │ ├── DispenseBehaviorMinecart.java │ │ │ ├── DispenseBehaviorMonsterEgg.java │ │ │ ├── DispenseBehaviorProjectile.java │ │ │ ├── DispenseBehaviorTNT.java │ │ │ ├── Enchantment.java │ │ │ ├── Entity.java │ │ │ ├── EntityAgeable.java │ │ │ ├── EntityArrow.java │ │ │ ├── EntityBlaze.java │ │ │ ├── EntityBoat.java │ │ │ ├── EntityChicken.java │ │ │ ├── EntityCow.java │ │ │ ├── EntityCreature.java │ │ │ ├── EntityCreeper.java │ │ │ ├── EntityDamageSourceIndirect.java │ │ │ ├── EntityEgg.java │ │ │ ├── EntityEnderCrystal.java │ │ │ ├── EntityEnderDragon.java │ │ │ ├── EntityEnderPearl.java │ │ │ ├── EntityEnderman.java │ │ │ ├── EntityExperienceOrb.java │ │ │ ├── EntityFallingBlock.java │ │ │ ├── EntityFireball.java │ │ │ ├── EntityFireworks.java │ │ │ ├── EntityFishingHook.java │ │ │ ├── EntityGhast.java │ │ │ ├── EntityHanging.java │ │ │ ├── EntityHorse.java │ │ │ ├── EntityHuman.java │ │ │ ├── EntityInsentient.java │ │ │ ├── EntityIronGolem.java │ │ │ ├── EntityItem.java │ │ │ ├── EntityItemFrame.java │ │ │ ├── EntityLargeFireball.java │ │ │ ├── EntityLeash.java │ │ │ ├── EntityLightning.java │ │ │ ├── EntityLiving.java │ │ │ ├── EntityMagmaCube.java │ │ │ ├── EntityMinecartAbstract.java │ │ │ ├── EntityMinecartCommandBlockListener.java │ │ │ ├── EntityMinecartContainer.java │ │ │ ├── EntityMonster.java │ │ │ ├── EntityMushroomCow.java │ │ │ ├── EntityOcelot.java │ │ │ ├── EntityPainting.java │ │ │ ├── EntityPig.java │ │ │ ├── EntityPigZombie.java │ │ │ ├── EntityPlayer.java │ │ │ ├── EntityPotion.java │ │ │ ├── EntityProjectile.java │ │ │ ├── EntitySheep.java │ │ │ ├── EntitySilverfish.java │ │ │ ├── EntitySkeleton.java │ │ │ ├── EntitySlime.java │ │ │ ├── EntitySmallFireball.java │ │ │ ├── EntitySnowman.java │ │ │ ├── EntitySpider.java │ │ │ ├── EntitySquid.java │ │ │ ├── EntityTNTPrimed.java │ │ │ ├── EntityThrownExpBottle.java │ │ │ ├── EntityTracker.java │ │ │ ├── EntityTrackerEntry.java │ │ │ ├── EntityWitch.java │ │ │ ├── EntityWither.java │ │ │ ├── EntityWitherSkull.java │ │ │ ├── EntityWolf.java │ │ │ ├── EntityZombie.java │ │ │ ├── Explosion.java │ │ │ ├── FoodMetaData.java │ │ │ ├── GroupDataZombie.java │ │ │ ├── HandshakeListener.java │ │ │ ├── IDataManager.java │ │ │ ├── IInventory.java │ │ │ ├── IRecipe.java │ │ │ ├── IntCache.java │ │ │ ├── IntHashMap.java │ │ │ ├── InventoryCraftResult.java │ │ │ ├── InventoryCrafting.java │ │ │ ├── InventoryEnderChest.java │ │ │ ├── InventoryHorseChest.java │ │ │ ├── InventoryLargeChest.java │ │ │ ├── InventoryMerchant.java │ │ │ ├── InventorySubcontainer.java │ │ │ ├── Item.java │ │ │ ├── ItemBed.java │ │ │ ├── ItemBlock.java │ │ │ ├── ItemBoat.java │ │ │ ├── ItemBow.java │ │ │ ├── ItemBucket.java │ │ │ ├── ItemDoor.java │ │ │ ├── ItemDye.java │ │ │ ├── ItemFireball.java │ │ │ ├── ItemFishingRod.java │ │ │ ├── ItemFlintAndSteel.java │ │ │ ├── ItemHanging.java │ │ │ ├── ItemHoe.java │ │ │ ├── ItemLeash.java │ │ │ ├── ItemMapEmpty.java │ │ │ ├── ItemMinecart.java │ │ │ ├── ItemMonsterEgg.java │ │ │ ├── ItemRedstone.java │ │ │ ├── ItemReed.java │ │ │ ├── ItemSeedFood.java │ │ │ ├── ItemSeeds.java │ │ │ ├── ItemSign.java │ │ │ ├── ItemSkull.java │ │ │ ├── ItemSnow.java │ │ │ ├── ItemStack.java │ │ │ ├── ItemStep.java │ │ │ ├── ItemWaterLily.java │ │ │ ├── ItemWorldMap.java │ │ │ ├── LoginListener.java │ │ │ ├── MethodProfiler.java │ │ │ ├── MinecraftServer.java │ │ │ ├── MobEffectList.java │ │ │ ├── MobSpawnerAbstract.java │ │ │ ├── NBTBase.java │ │ │ ├── NBTCompressedStreamTools.java │ │ │ ├── NBTTagCompound.java │ │ │ ├── NBTTagString.java │ │ │ ├── Navigation.java │ │ │ ├── NetworkManager.java │ │ │ ├── NoteDataList.java │ │ │ ├── Packet.java │ │ │ ├── PacketDataSerializer.java │ │ │ ├── PacketHandshakingInSetProtocol.java │ │ │ ├── PacketPlayInChat.java │ │ │ ├── PacketPlayInCloseWindow.java │ │ │ ├── PacketPlayInCustomPayload.java │ │ │ ├── PacketPlayOutBlockChange.java │ │ │ ├── PacketPlayOutMapChunk.java │ │ │ ├── PacketPlayOutMapChunkBulk.java │ │ │ ├── PacketPlayOutNamedEntitySpawn.java │ │ │ ├── PacketPlayOutSpawnPosition.java │ │ │ ├── PacketStatusListener.java │ │ │ ├── Path.java │ │ │ ├── Pathfinder.java │ │ │ ├── PathfinderGoalArrowAttack.java │ │ │ ├── PathfinderGoalBreakDoor.java │ │ │ ├── PathfinderGoalBreed.java │ │ │ ├── PathfinderGoalEatTile.java │ │ │ ├── PathfinderGoalFleeSun.java │ │ │ ├── PathfinderGoalJumpOnBlock.java │ │ │ ├── PathfinderGoalMakeLove.java │ │ │ ├── PathfinderGoalMeleeAttack.java │ │ │ ├── PathfinderGoalMoveIndoors.java │ │ │ ├── PathfinderGoalMoveThroughVillage.java │ │ │ ├── PathfinderGoalMoveTowardsRestriction.java │ │ │ ├── PathfinderGoalMoveTowardsTarget.java │ │ │ ├── PathfinderGoalNearestAttackableTarget.java │ │ │ ├── PathfinderGoalOcelotAttack.java │ │ │ ├── PathfinderGoalPanic.java │ │ │ ├── PathfinderGoalPlay.java │ │ │ ├── PathfinderGoalRandomStroll.java │ │ │ ├── PathfinderGoalSelector.java │ │ │ ├── PathfinderGoalSit.java │ │ │ ├── PathfinderGoalTame.java │ │ │ ├── PathfinderGoalTarget.java │ │ │ ├── PersistentCollection.java │ │ │ ├── PlayerAbilities.java │ │ │ ├── PlayerChunk.java │ │ │ ├── PlayerChunkMap.java │ │ │ ├── PlayerConnection.java │ │ │ ├── PlayerInteractManager.java │ │ │ ├── PlayerInventory.java │ │ │ ├── PlayerList.java │ │ │ ├── PlayerSelector.java │ │ │ ├── PortalCreator.java │ │ │ ├── PortalTravelAgent.java │ │ │ ├── PropertyManager.java │ │ │ ├── ProtocolOrdinalWrapper.java │ │ │ ├── QueuedPacket.java │ │ │ ├── RecipeArmorDye.java │ │ │ ├── RecipeBookClone.java │ │ │ ├── RecipeFireworks.java │ │ │ ├── RecipeMapClone.java │ │ │ ├── RecipesFurnace.java │ │ │ ├── RegionFile.java │ │ │ ├── RemoteControlCommandListener.java │ │ │ ├── ScoreboardServer.java │ │ │ ├── SecondaryWorldServer.java │ │ │ ├── ShapedRecipes.java │ │ │ ├── ShapelessRecipes.java │ │ │ ├── Slot.java │ │ │ ├── SlotFurnaceResult.java │ │ │ ├── SpawnerCreature.java │ │ │ ├── StatisticManager.java │ │ │ ├── ThreadCommandReader.java │ │ │ ├── ThreadPlayerLookupUUID.java │ │ │ ├── TileEntity.java │ │ │ ├── TileEntityBeacon.java │ │ │ ├── TileEntityBrewingStand.java │ │ │ ├── TileEntityChest.java │ │ │ ├── TileEntityCommandListener.java │ │ │ ├── TileEntityDispenser.java │ │ │ ├── TileEntityFurnace.java │ │ │ ├── TileEntityHopper.java │ │ │ ├── TileEntityNote.java │ │ │ ├── TileEntityPiston.java │ │ │ ├── TileEntityRecordPlayer.java │ │ │ ├── TileEntitySign.java │ │ │ ├── TileEntitySkull.java │ │ │ ├── Vec3D.java │ │ │ ├── Vec3DPool.java │ │ │ ├── Village.java │ │ │ ├── VillageSiege.java │ │ │ ├── World.java │ │ │ ├── WorldGenAcaciaTree.java │ │ │ ├── WorldGenBigTree.java │ │ │ ├── WorldGenForest.java │ │ │ ├── WorldGenForestTree.java │ │ │ ├── WorldGenGroundBush.java │ │ │ ├── WorldGenHugeMushroom.java │ │ │ ├── WorldGenJungleTree.java │ │ │ ├── WorldGenMegaTree.java │ │ │ ├── WorldGenMegaTreeAbstract.java │ │ │ ├── WorldGenSwampTree.java │ │ │ ├── WorldGenTaiga1.java │ │ │ ├── WorldGenTaiga2.java │ │ │ ├── WorldGenTrees.java │ │ │ ├── WorldGenerator.java │ │ │ ├── WorldManager.java │ │ │ ├── WorldMap.java │ │ │ ├── WorldMapHumanTracker.java │ │ │ ├── WorldNBTStorage.java │ │ │ └── WorldServer.java │ └── org │ │ ├── apache │ │ └── logging │ │ │ └── log4j │ │ │ └── core │ │ │ └── appender │ │ │ └── ConsoleAppender.java │ │ └── bukkit │ │ └── craftbukkit │ │ ├── CraftArt.java │ │ ├── CraftBanEntry.java │ │ ├── CraftBanList.java │ │ ├── CraftBlockChangeDelegate.java │ │ ├── CraftChunk.java │ │ ├── CraftChunkSnapshot.java │ │ ├── CraftCrashReport.java │ │ ├── CraftEffect.java │ │ ├── CraftOfflinePlayer.java │ │ ├── CraftServer.java │ │ ├── CraftSound.java │ │ ├── CraftStatistic.java │ │ ├── CraftTravelAgent.java │ │ ├── CraftWorld.java │ │ ├── LoggerOutputStream.java │ │ ├── Main.java │ │ ├── Overridden.java │ │ ├── TrigMath.java │ │ ├── block │ │ ├── CraftBeacon.java │ │ ├── CraftBlock.java │ │ ├── CraftBlockState.java │ │ ├── CraftBrewingStand.java │ │ ├── CraftChest.java │ │ ├── CraftCommandBlock.java │ │ ├── CraftCreatureSpawner.java │ │ ├── CraftDispenser.java │ │ ├── CraftDropper.java │ │ ├── CraftFurnace.java │ │ ├── CraftHopper.java │ │ ├── CraftJukebox.java │ │ ├── CraftNoteBlock.java │ │ ├── CraftSign.java │ │ └── CraftSkull.java │ │ ├── chunkio │ │ ├── ChunkIOExecutor.java │ │ ├── ChunkIOProvider.java │ │ └── QueuedChunk.java │ │ ├── command │ │ ├── ColouredConsoleSender.java │ │ ├── ConsoleCommandCompleter.java │ │ ├── CraftBlockCommandSender.java │ │ ├── CraftConsoleCommandSender.java │ │ ├── CraftRemoteConsoleCommandSender.java │ │ ├── ServerCommandSender.java │ │ └── VanillaCommandWrapper.java │ │ ├── conversations │ │ └── ConversationTracker.java │ │ ├── enchantments │ │ └── CraftEnchantment.java │ │ ├── entity │ │ ├── AbstractProjectile.java │ │ ├── CraftAgeable.java │ │ ├── CraftAmbient.java │ │ ├── CraftAnimals.java │ │ ├── CraftArrow.java │ │ ├── CraftBat.java │ │ ├── CraftBlaze.java │ │ ├── CraftBoat.java │ │ ├── CraftCaveSpider.java │ │ ├── CraftChicken.java │ │ ├── CraftComplexLivingEntity.java │ │ ├── CraftComplexPart.java │ │ ├── CraftCow.java │ │ ├── CraftCreature.java │ │ ├── CraftCreeper.java │ │ ├── CraftEgg.java │ │ ├── CraftEnderCrystal.java │ │ ├── CraftEnderDragon.java │ │ ├── CraftEnderDragonPart.java │ │ ├── CraftEnderPearl.java │ │ ├── CraftEnderSignal.java │ │ ├── CraftEnderman.java │ │ ├── CraftEntity.java │ │ ├── CraftExperienceOrb.java │ │ ├── CraftFallingSand.java │ │ ├── CraftFireball.java │ │ ├── CraftFirework.java │ │ ├── CraftFish.java │ │ ├── CraftFlying.java │ │ ├── CraftGhast.java │ │ ├── CraftGiant.java │ │ ├── CraftGolem.java │ │ ├── CraftHanging.java │ │ ├── CraftHorse.java │ │ ├── CraftHumanEntity.java │ │ ├── CraftIronGolem.java │ │ ├── CraftItem.java │ │ ├── CraftItemFrame.java │ │ ├── CraftLargeFireball.java │ │ ├── CraftLeash.java │ │ ├── CraftLightningStrike.java │ │ ├── CraftLivingEntity.java │ │ ├── CraftMagmaCube.java │ │ ├── CraftMinecart.java │ │ ├── CraftMinecartChest.java │ │ ├── CraftMinecartCommand.java │ │ ├── CraftMinecartFurnace.java │ │ ├── CraftMinecartHopper.java │ │ ├── CraftMinecartMobSpawner.java │ │ ├── CraftMinecartRideable.java │ │ ├── CraftMinecartTNT.java │ │ ├── CraftMonster.java │ │ ├── CraftMushroomCow.java │ │ ├── CraftOcelot.java │ │ ├── CraftPainting.java │ │ ├── CraftPig.java │ │ ├── CraftPigZombie.java │ │ ├── CraftPlayer.java │ │ ├── CraftProjectile.java │ │ ├── CraftSheep.java │ │ ├── CraftSilverfish.java │ │ ├── CraftSkeleton.java │ │ ├── CraftSlime.java │ │ ├── CraftSmallFireball.java │ │ ├── CraftSnowball.java │ │ ├── CraftSnowman.java │ │ ├── CraftSpider.java │ │ ├── CraftSquid.java │ │ ├── CraftTNTPrimed.java │ │ ├── CraftTameableAnimal.java │ │ ├── CraftThrownExpBottle.java │ │ ├── CraftThrownPotion.java │ │ ├── CraftVehicle.java │ │ ├── CraftVillager.java │ │ ├── CraftWaterMob.java │ │ ├── CraftWeather.java │ │ ├── CraftWitch.java │ │ ├── CraftWither.java │ │ ├── CraftWitherSkull.java │ │ ├── CraftWolf.java │ │ └── CraftZombie.java │ │ ├── event │ │ └── CraftEventFactory.java │ │ ├── generator │ │ ├── CustomChunkGenerator.java │ │ ├── InternalChunkGenerator.java │ │ ├── NetherChunkGenerator.java │ │ ├── NormalChunkGenerator.java │ │ └── SkyLandsChunkGenerator.java │ │ ├── help │ │ ├── CommandAliasHelpTopic.java │ │ ├── CustomHelpTopic.java │ │ ├── CustomIndexHelpTopic.java │ │ ├── HelpTopicAmendment.java │ │ ├── HelpYamlReader.java │ │ ├── MultipleCommandAliasHelpTopic.java │ │ ├── MultipleCommandAliasHelpTopicFactory.java │ │ └── SimpleHelpMap.java │ │ ├── inventory │ │ ├── CraftContainer.java │ │ ├── CraftEntityEquipment.java │ │ ├── CraftFurnaceRecipe.java │ │ ├── CraftInventory.java │ │ ├── CraftInventoryAnvil.java │ │ ├── CraftInventoryBeacon.java │ │ ├── CraftInventoryBrewer.java │ │ ├── CraftInventoryCrafting.java │ │ ├── CraftInventoryCustom.java │ │ ├── CraftInventoryDoubleChest.java │ │ ├── CraftInventoryEnchanting.java │ │ ├── CraftInventoryFurnace.java │ │ ├── CraftInventoryHorse.java │ │ ├── CraftInventoryMerchant.java │ │ ├── CraftInventoryPlayer.java │ │ ├── CraftInventoryView.java │ │ ├── CraftItemFactory.java │ │ ├── CraftItemStack.java │ │ ├── CraftMetaBook.java │ │ ├── CraftMetaCharge.java │ │ ├── CraftMetaEnchantedBook.java │ │ ├── CraftMetaFirework.java │ │ ├── CraftMetaItem.java │ │ ├── CraftMetaLeatherArmor.java │ │ ├── CraftMetaMap.java │ │ ├── CraftMetaPotion.java │ │ ├── CraftMetaSkull.java │ │ ├── CraftRecipe.java │ │ ├── CraftShapedRecipe.java │ │ ├── CraftShapelessRecipe.java │ │ ├── InventoryIterator.java │ │ └── RecipeIterator.java │ │ ├── map │ │ ├── CraftMapCanvas.java │ │ ├── CraftMapRenderer.java │ │ ├── CraftMapView.java │ │ └── RenderData.java │ │ ├── metadata │ │ ├── BlockMetadataStore.java │ │ ├── EntityMetadataStore.java │ │ ├── PlayerMetadataStore.java │ │ └── WorldMetadataStore.java │ │ ├── potion │ │ ├── CraftPotionBrewer.java │ │ └── CraftPotionEffectType.java │ │ ├── projectiles │ │ └── CraftBlockProjectileSource.java │ │ ├── scheduler │ │ ├── CraftAsyncDebugger.java │ │ ├── CraftAsyncTask.java │ │ ├── CraftFuture.java │ │ ├── CraftScheduler.java │ │ └── CraftTask.java │ │ ├── scoreboard │ │ ├── CraftCriteria.java │ │ ├── CraftObjective.java │ │ ├── CraftScore.java │ │ ├── CraftScoreboard.java │ │ ├── CraftScoreboardComponent.java │ │ ├── CraftScoreboardManager.java │ │ ├── CraftScoreboardTranslations.java │ │ └── CraftTeam.java │ │ ├── updater │ │ ├── ArtifactDetails.java │ │ ├── AutoUpdater.java │ │ └── BukkitDLUpdaterService.java │ │ └── util │ │ ├── AsynchronousExecutor.java │ │ ├── BlockStateListPopulator.java │ │ ├── CraftChatMessage.java │ │ ├── CraftDamageSource.java │ │ ├── CraftIconCache.java │ │ ├── CraftMagicNumbers.java │ │ ├── DatFileFilter.java │ │ ├── ForwardLogHandler.java │ │ ├── Java15Compat.java │ │ ├── LazyHashSet.java │ │ ├── LazyPlayerSet.java │ │ ├── LongHash.java │ │ ├── LongHashSet.java │ │ ├── LongObjectHashMap.java │ │ ├── ServerShutdownThread.java │ │ ├── ShortConsoleLogFormatter.java │ │ ├── StructureGrowDelegate.java │ │ ├── TerminalConsoleWriterThread.java │ │ ├── UnsafeList.java │ │ ├── Versioning.java │ │ ├── Waitable.java │ │ └── WeakCollection.java └── resources │ ├── configurations │ ├── bukkit.yml │ ├── commands.yml │ ├── help.yml │ └── minetickmod.yml │ └── log4j2.xml └── test └── java └── org └── bukkit ├── ArtTest.java ├── DyeColorsTest.java ├── MaterialTest.java ├── PerMaterialTest.java ├── SoundTest.java ├── StatisticsAndAchievementsTest.java ├── WorldTypeTest.java ├── craftbukkit ├── inventory │ ├── CompositeSerialization.java │ ├── FactoryItemMaterialTest.java │ ├── ItemFactoryTest.java │ ├── ItemMetaImplementationOverrideTest.java │ ├── ItemMetaTest.java │ ├── ItemStackBookTest.java │ ├── ItemStackEnchantStorageTest.java │ ├── ItemStackFireworkChargeTest.java │ ├── ItemStackFireworkTest.java │ ├── ItemStackLeatherTest.java │ ├── ItemStackLoreEnchantmentTest.java │ ├── ItemStackMapTest.java │ ├── ItemStackPotionsTest.java │ ├── ItemStackSkullTest.java │ ├── ItemStackTest.java │ └── NMSCraftItemStackTest.java └── updater │ └── BukkitDLUpdaterServiceTest.java ├── potion └── PotionTest.java └── support ├── AbstractTestingBase.java ├── DummyEnchantments.java ├── DummyPotions.java ├── DummyServer.java ├── Matchers.java └── Util.java /.gitignore: -------------------------------------------------------------------------------- 1 | # Eclipse stuff 2 | /.classpath 3 | /.project 4 | /.settings 5 | 6 | # netbeans 7 | /nbproject 8 | 9 | # we use maven! 10 | /build.xml 11 | 12 | # maven 13 | /target 14 | 15 | # vim 16 | .*.sw[a-p] 17 | 18 | # various other potential build files 19 | /build 20 | /bin 21 | /dist 22 | /manifest.mf 23 | 24 | /world 25 | 26 | # Mac filesystem dust 27 | .DS_Store 28 | 29 | # intellij 30 | *.iml 31 | *.ipr 32 | *.iws 33 | .idea/ 34 | 35 | /src/main/resources/achievement 36 | /src/main/resources/lang 37 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/ChunkGenerationPolicy.java: -------------------------------------------------------------------------------- 1 | package de.minetick; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | import org.bukkit.WorldType; 7 | 8 | public class ChunkGenerationPolicy { 9 | 10 | private static HashMap rateMap = new HashMap(); 11 | 12 | private int generatedChunks; 13 | private int ticks; 14 | 15 | public ChunkGenerationPolicy() { 16 | this.reset(); 17 | } 18 | 19 | public void generatedChunk() { 20 | this.generatedChunks++; 21 | } 22 | 23 | public boolean isChunkGenerationCurrentlyAllowed(WorldType type) { 24 | if(this.ticks > 0) { 25 | Double entry = rateMap.get(type); 26 | double maxRate; 27 | if(entry == null) { 28 | maxRate = getDefaultRate(type); 29 | } else { 30 | maxRate = entry.doubleValue(); 31 | } 32 | 33 | double currentRate = (double) this.generatedChunks / (double) this.ticks; 34 | if(currentRate < maxRate) { 35 | return true; 36 | } 37 | } 38 | return false; 39 | } 40 | 41 | public void reset() { 42 | this.generatedChunks = 0; 43 | this.ticks = 0; 44 | } 45 | 46 | public void newTick() { 47 | if(this.ticks >= 20 * 5) { 48 | this.reset(); 49 | } 50 | this.ticks++; 51 | } 52 | 53 | public static void setRatesFromConfig(Map rates) { 54 | rateMap.putAll(rates); 55 | } 56 | 57 | public static double getDefaultRate(WorldType type) { 58 | return type.equals(WorldType.FLAT) ? 1.0D : 0.5D; 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/MinetickThreadFactory.java: -------------------------------------------------------------------------------- 1 | package de.minetick; 2 | 3 | import java.util.concurrent.Executors; 4 | import java.util.concurrent.ThreadFactory; 5 | 6 | public class MinetickThreadFactory implements ThreadFactory { 7 | 8 | private int priority; 9 | private int idCounter = 0; 10 | private String name = "MinetickModThread"; 11 | 12 | public MinetickThreadFactory(int priority) { 13 | this.priority = Math.max(priority, Thread.MIN_PRIORITY); 14 | this.priority = Math.min(priority, Thread.MAX_PRIORITY); 15 | } 16 | 17 | public MinetickThreadFactory(int priority, String name) { 18 | this(priority); 19 | this.name = name; 20 | } 21 | 22 | public MinetickThreadFactory(String name) { 23 | this(Thread.NORM_PRIORITY); 24 | this.name = name; 25 | } 26 | 27 | @Override 28 | public Thread newThread(Runnable arg0) { 29 | Thread t = Executors.defaultThreadFactory().newThread(arg0); 30 | t.setPriority(this.priority); 31 | t.setName(this.name + "-" + idCounter); 32 | idCounter++; 33 | return t; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/PlayerMovement.java: -------------------------------------------------------------------------------- 1 | package de.minetick; 2 | 3 | public class PlayerMovement { 4 | 5 | private int centerX; 6 | private int centerZ; 7 | private int movementX; 8 | private int movementZ; 9 | 10 | public PlayerMovement(int centerX, int centerZ, int movementX, int movementZ) { 11 | this.centerX = centerX; 12 | this.centerZ = centerZ; 13 | this.movementX = movementX; 14 | this.movementZ = movementZ; 15 | } 16 | 17 | public PlayerMovement(int[] center, int[] movement) { 18 | this.centerX = center[0]; 19 | this.centerZ = center[1]; 20 | this.movementX = movement[0]; 21 | this.movementZ = movement[1]; 22 | } 23 | 24 | public void addMovement(PlayerMovement previousmovement, boolean updateCenter) { 25 | this.movementX += previousmovement.getMovementX(); 26 | this.movementZ += previousmovement.getMovementZ(); 27 | if(updateCenter) { 28 | this.centerX = previousmovement.getCenterX(); 29 | this.centerZ = previousmovement.getCenterZ(); 30 | } 31 | } 32 | 33 | public int getMovementX() { 34 | return this.movementX; 35 | } 36 | 37 | public int getMovementZ() { 38 | return this.movementZ; 39 | } 40 | 41 | public int getCenterX() { 42 | return this.centerX; 43 | } 44 | 45 | public int getCenterZ() { 46 | return this.centerZ; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/packetbuilder/PacketBuilderBuffer.java: -------------------------------------------------------------------------------- 1 | package de.minetick.packetbuilder; 2 | 3 | import java.lang.ref.WeakReference; 4 | import java.util.ArrayList; 5 | 6 | public class PacketBuilderBuffer { 7 | 8 | private ArrayList> sendBufferCache = new ArrayList>(); 9 | 10 | public PacketBuilderBuffer() {} 11 | 12 | public void offerSendBuffer(byte[] array) { 13 | synchronized(this.sendBufferCache) { 14 | this.sendBufferCache.add(new WeakReference(array)); 15 | } 16 | } 17 | 18 | public byte[] requestSendBuffer(int length) { 19 | synchronized(this.sendBufferCache) { 20 | return this.checkInList(this.sendBufferCache, length); 21 | } 22 | } 23 | 24 | public void clear() { 25 | synchronized(this.sendBufferCache) { 26 | this.sendBufferCache.clear(); 27 | } 28 | } 29 | 30 | private byte[] checkInList(ArrayList> list, int length) { 31 | WeakReference ref; 32 | byte[] array; 33 | int size = list.size(); 34 | for(int i = size - 1; i >= 0; i--) { 35 | ref = list.get(i); 36 | array = ref.get(); 37 | if(array == null) { 38 | list.remove(i); 39 | } else if(array.length >= length) { 40 | list.remove(i); 41 | return array; 42 | } 43 | } 44 | return new byte[length]; 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/packetbuilder/PacketBuilderChunkData.java: -------------------------------------------------------------------------------- 1 | package de.minetick.packetbuilder; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | import net.minecraft.server.Chunk; 7 | import net.minecraft.server.Packet; 8 | import net.minecraft.server.PlayerConnection; 9 | import net.minecraft.server.TileEntity; 10 | 11 | public class PacketBuilderChunkData { 12 | 13 | private Chunk chunk; 14 | private List tileEntites; 15 | private boolean sendAllFlag; 16 | private int sectionBitmask; 17 | 18 | public PacketBuilderChunkData(Chunk chunk, boolean sendAllFlag, int sectionBitmask) { 19 | this.chunk = chunk; 20 | this.sendAllFlag = sendAllFlag; 21 | this.sectionBitmask = sectionBitmask; 22 | this.tileEntites = new ArrayList(this.chunk.tileEntities.values()); 23 | } 24 | 25 | public Chunk getChunk() { 26 | return this.chunk; 27 | } 28 | 29 | public boolean getSendAllFlag() { 30 | return this.sendAllFlag; 31 | } 32 | 33 | public int getSectionBitmask() { 34 | return this.sectionBitmask; 35 | } 36 | 37 | public void sendTileEntities(PlayerConnection playerconnection) { 38 | if(this.sectionBitmask == 0) { 39 | return; 40 | } 41 | for(TileEntity tileEntity: this.tileEntites) { 42 | int sectionId = tileEntity.z >> 4; 43 | if((this.sectionBitmask & (1 << sectionId)) != 0) { 44 | Packet packet = tileEntity.getUpdatePacket(); 45 | if(packet != null) { 46 | playerconnection.sendPacket(packet); 47 | } 48 | } 49 | } 50 | } 51 | 52 | public void clear() { 53 | this.tileEntites.clear(); 54 | this.chunk = null; 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/packetbuilder/PacketBuilderJobInterface.java: -------------------------------------------------------------------------------- 1 | package de.minetick.packetbuilder; 2 | 3 | public interface PacketBuilderJobInterface extends Runnable { 4 | 5 | public void assignBuildBuffer(PacketBuilderBuffer pbb); 6 | } 7 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/packetbuilder/PacketBuilderThread.java: -------------------------------------------------------------------------------- 1 | package de.minetick.packetbuilder; 2 | 3 | import java.util.concurrent.ExecutorService; 4 | import java.util.concurrent.Executors; 5 | 6 | import de.minetick.MinetickThreadFactory; 7 | 8 | public class PacketBuilderThread { 9 | 10 | private int id; 11 | private static volatile int threadCounter = 0; 12 | private ExecutorService thread; 13 | private PacketBuilderBuffer buildBuffer; 14 | 15 | public PacketBuilderThread() { 16 | this.id = threadCounter++; 17 | this.thread = Executors.newSingleThreadExecutor(new MinetickThreadFactory(Thread.NORM_PRIORITY - 2, "MinetickMod_PacketBuilder-" + this.id)); 18 | this.buildBuffer = new PacketBuilderBuffer(); 19 | } 20 | 21 | public boolean addJob(PacketBuilderJobInterface job) { 22 | if(!this.thread.isShutdown()) { 23 | job.assignBuildBuffer(this.buildBuffer); 24 | this.thread.submit(job); 25 | return true; 26 | } 27 | return false; 28 | } 29 | 30 | public void shutdown() { 31 | this.thread.shutdown(); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/pathsearch/PathSearchJobEntity.java: -------------------------------------------------------------------------------- 1 | package de.minetick.pathsearch; 2 | 3 | import net.minecraft.server.Entity; 4 | import net.minecraft.server.EntityCreature; 5 | import net.minecraft.server.PathEntity; 6 | 7 | public class PathSearchJobEntity extends PathSearchJob { 8 | 9 | private Entity target; 10 | 11 | public PathSearchJobEntity(EntityCreature entity, Entity target, float range, boolean b1, boolean b2, boolean b3, boolean b4) { 12 | super(entity, range, b1, b2, b3, b4); 13 | this.target = target; 14 | } 15 | 16 | @Override 17 | public void run() { 18 | if(!this.issued) { 19 | this.issued = true; 20 | PathEntity pathentity = (new MinetickPathfinder(this.chunkCache, this.b1, this.b2, this.b3, this.b4)).a(entity, this.target, this.range); 21 | ((EntityCreature)this.entity).setPathEntityByTarget(this.target, pathentity); 22 | this.cleanup(); 23 | } 24 | } 25 | 26 | @Override 27 | public void cleanup() { 28 | super.cleanup(); 29 | this.target = null; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/pathsearch/PathSearchJobNavigationEntity.java: -------------------------------------------------------------------------------- 1 | package de.minetick.pathsearch; 2 | 3 | import java.util.UUID; 4 | 5 | import de.minetick.pathsearch.cache.SearchCacheEntry; 6 | import de.minetick.pathsearch.cache.SearchCacheEntryEntity; 7 | 8 | import net.minecraft.server.ChunkCache; 9 | import net.minecraft.server.Entity; 10 | import net.minecraft.server.EntityCreature; 11 | import net.minecraft.server.EntityInsentient; 12 | import net.minecraft.server.PathEntity; 13 | 14 | public class PathSearchJobNavigationEntity extends PathSearchJob { 15 | 16 | private Entity target; 17 | 18 | public PathSearchJobNavigationEntity(EntityInsentient entity, Entity target, float range, boolean b1, boolean b2, boolean b3, boolean b4) { 19 | super(entity, range, b1, b2, b3, b4); 20 | this.target = target; 21 | } 22 | 23 | @Override 24 | public void run() { 25 | if(!this.issued) { 26 | this.issued = true; 27 | this.pathEntity = (new MinetickPathfinder(this.chunkCache, this.b1, this.b2, this.b3, this.b4)).a(entity, this.target, this.range); 28 | this.entity.getNavigation().setPathEntity(this); 29 | this.cleanup(); 30 | } 31 | } 32 | 33 | @Override 34 | public void cleanup() { 35 | super.cleanup(); 36 | this.target = null; 37 | } 38 | 39 | public UUID getCacheEntryKey() { 40 | return this.target.getUniqueID(); 41 | } 42 | 43 | public SearchCacheEntry getCacheEntryValue() { 44 | return new SearchCacheEntryEntity(this.entity, this.target, this.pathEntity); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/pathsearch/PathSearchJobPosition.java: -------------------------------------------------------------------------------- 1 | package de.minetick.pathsearch; 2 | 3 | import net.minecraft.server.EntityCreature; 4 | import net.minecraft.server.EntityInsentient; 5 | import net.minecraft.server.PathEntity; 6 | import net.minecraft.server.Pathfinder; 7 | 8 | public class PathSearchJobPosition extends PathSearchJob { 9 | 10 | private int x, y, z; 11 | 12 | public PathSearchJobPosition(EntityCreature entity, int x, int y, int z, float range, boolean b1, boolean b2, boolean b3, boolean b4) { 13 | super(entity, range, b1, b2, b3, b4); 14 | this.x = x; 15 | this.y = y; 16 | this.z = z; 17 | } 18 | 19 | @Override 20 | public void run() { 21 | if(!this.issued) { 22 | this.issued = true; 23 | this.pathEntity = (new MinetickPathfinder(this.chunkCache, this.b1, this.b2, this.b3, this.b4)).a(entity, this.x, this.y, this.z, this.range); 24 | ((EntityCreature)this.entity).setPathEntityByPosition(this.pathEntity); 25 | this.cleanup(); 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/pathsearch/PositionPathSearchType.java: -------------------------------------------------------------------------------- 1 | package de.minetick.pathsearch; 2 | 3 | public enum PositionPathSearchType { 4 | ANYOTHER, 5 | FLEESUN, 6 | JUMPONBLOCK, 7 | MOVEINDOORS, 8 | MOVETHROUGHVILLAGE, 9 | MOVETOWARDSRESTRICTION, 10 | MOVETOWARDSTARGET, 11 | PANIC, 12 | PLAY, 13 | RANDOMSTROLL, 14 | TAME; 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/pathsearch/cache/SearchCacheEntryEntity.java: -------------------------------------------------------------------------------- 1 | package de.minetick.pathsearch.cache; 2 | 3 | import org.bukkit.util.BlockVector; 4 | 5 | import net.minecraft.server.Entity; 6 | import net.minecraft.server.EntityInsentient; 7 | import net.minecraft.server.PathEntity; 8 | 9 | public class SearchCacheEntryEntity extends SearchCacheEntry { 10 | 11 | private Entity target; 12 | 13 | public SearchCacheEntryEntity(EntityInsentient entity, Entity target, PathEntity path) { 14 | super(entity, path); 15 | this.target = target; 16 | this.positionTarget = this.getEntityPosition(this.target); 17 | } 18 | 19 | @Override 20 | public boolean isStillValid() { 21 | if(this.getCurrentTick() - this.tick > 20) { 22 | return false; 23 | } 24 | BlockVector bvStart = this.getEntityPosition(this.entity); 25 | BlockVector bvTarget = this.getEntityPosition(this.target); 26 | if(!bvStart.equals(this.positionStart) || !bvTarget.equals(this.positionTarget)) { 27 | return false; 28 | } 29 | return true; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/pathsearch/cache/SearchCacheEntryPosition.java: -------------------------------------------------------------------------------- 1 | package de.minetick.pathsearch.cache; 2 | 3 | import net.minecraft.server.Entity; 4 | import net.minecraft.server.EntityInsentient; 5 | import net.minecraft.server.PathEntity; 6 | 7 | import org.bukkit.util.BlockVector; 8 | 9 | public class SearchCacheEntryPosition extends SearchCacheEntry { 10 | 11 | public SearchCacheEntryPosition(EntityInsentient entity, int x, int y, int z, PathEntity path) { 12 | super(entity, path); 13 | this.positionTarget = this.getTargetPosition(x, y, z); 14 | } 15 | 16 | @Override 17 | public boolean isStillValid() { 18 | if(this.getCurrentTick() - this.tick > 20) { 19 | return false; 20 | } 21 | BlockVector bvStart = this.getEntityPosition(this.entity); 22 | if(!bvStart.equals(this.positionStart)) { 23 | return false; 24 | } 25 | return true; 26 | } 27 | 28 | public boolean targetEquals(BlockVector bv) { 29 | return this.positionTarget.equals(bv); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/profiler/ProfileCall.java: -------------------------------------------------------------------------------- 1 | package de.minetick.profiler; 2 | 3 | public class ProfileCall { 4 | 5 | private long time; 6 | private int count; 7 | private int playerNumber; 8 | private int generatedChunks; 9 | 10 | ProfileCall() { 11 | this.reset(); 12 | } 13 | 14 | public int getCount() { 15 | return this.count; 16 | } 17 | 18 | public long getTime() { 19 | return this.time; 20 | } 21 | 22 | public void reset() { 23 | this.time = 0L; 24 | this.count = 0; 25 | this.playerNumber = 0; 26 | this.generatedChunks = 0; 27 | } 28 | 29 | public void add(long t) { 30 | this.time += t; 31 | this.count++; 32 | } 33 | 34 | public void setTime(long t) { 35 | this.time = t; 36 | this.count++; 37 | } 38 | 39 | public void setPlayerNumber(int i) { 40 | this.playerNumber = i; 41 | } 42 | 43 | public int getPlayerNumber() { 44 | return this.playerNumber; 45 | } 46 | 47 | public void setGeneratedChunks(int count) { 48 | this.generatedChunks += count; 49 | } 50 | 51 | public int getGeneratedChunks() { 52 | return this.generatedChunks; 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /src/main/java/de/minetick/profiler/ProfilingComperator.java: -------------------------------------------------------------------------------- 1 | package de.minetick.profiler; 2 | 3 | import java.util.Comparator; 4 | 5 | import net.minecraft.server.WorldServer; 6 | 7 | public class ProfilingComperator implements Comparator { 8 | 9 | @Override 10 | public int compare(WorldServer o1, WorldServer o2) { 11 | long a = o1.getLastTickAvg(); 12 | long b = o2.getLastTickAvg(); 13 | /* 14 | * If the last average tick time of a world is greater, it shall be closer 15 | * to the head of the priority queue 16 | */ 17 | if(a > b) { 18 | return -1; 19 | } 20 | if(a < b) { 21 | return 1; 22 | } 23 | return 0; 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/BlockBloodStone.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import org.bukkit.event.block.BlockRedstoneEvent; // CraftBukkit 4 | 5 | public class BlockBloodStone extends Block { 6 | 7 | public BlockBloodStone() { 8 | super(Material.STONE); 9 | this.a(CreativeModeTab.b); 10 | } 11 | 12 | public MaterialMapColor f(int i) { 13 | return MaterialMapColor.K; 14 | } 15 | 16 | // CraftBukkit start 17 | public void doPhysics(World world, int i, int j, int k, int l) { 18 | if (net.minecraft.server.Block.e(l) != null && net.minecraft.server.Block.e(l).isPowerSource()) { 19 | org.bukkit.block.Block block = world.getWorld().getBlockAt(i, j, k); 20 | int power = block.getBlockPower(); 21 | 22 | BlockRedstoneEvent event = new BlockRedstoneEvent(block, power, power); 23 | world.getServer().getPluginManager().callEvent(event); 24 | } 25 | } 26 | // CraftBukkit end 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/BlockMobSpawner.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import java.util.Random; 4 | 5 | public class BlockMobSpawner extends BlockContainer { 6 | 7 | protected BlockMobSpawner() { 8 | super(Material.STONE); 9 | } 10 | 11 | public TileEntity a(World world, int i) { 12 | return new TileEntityMobSpawner(); 13 | } 14 | 15 | public Item getDropType(int i, Random random, int j) { 16 | return null; 17 | } 18 | 19 | public int a(Random random) { 20 | return 0; 21 | } 22 | 23 | public void dropNaturally(World world, int i, int j, int k, int l, float f, int i1) { 24 | super.dropNaturally(world, i, j, k, l, f, i1); 25 | /* CraftBukkit start - Delegate to getExpDrop 26 | int j1 = 15 + world.random.nextInt(15) + world.random.nextInt(15); 27 | 28 | this.dropExperience(world, i, j, k, j1)*/ 29 | } 30 | 31 | public int getExpDrop(World world, int data, int enchantmentLevel) { 32 | int j1 = 15 + world.random.nextInt(15) + world.random.nextInt(15); 33 | 34 | return j1; 35 | // CraftBukkit end 36 | } 37 | 38 | public boolean c() { 39 | return false; 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/BlockNetherWart.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import java.util.Random; 4 | 5 | public class BlockNetherWart extends BlockPlant { 6 | 7 | protected BlockNetherWart() { 8 | this.a(true); 9 | float f = 0.5F; 10 | 11 | this.a(0.5F - f, 0.0F, 0.5F - f, 0.5F + f, 0.25F, 0.5F + f); 12 | this.a((CreativeModeTab) null); 13 | } 14 | 15 | protected boolean a(Block block) { 16 | return block == Blocks.SOUL_SAND; 17 | } 18 | 19 | public boolean j(World world, int i, int j, int k) { 20 | return this.a(world.getType(i, j - 1, k)); 21 | } 22 | 23 | public void a(World world, int i, int j, int k, Random random) { 24 | int l = world.getData(i, j, k); 25 | 26 | if (l < 3 && random.nextInt(10) == 0) { 27 | ++l; 28 | org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockGrowEvent(world, i, j, k, this, l); // CraftBukkit 29 | } 30 | 31 | super.a(world, i, j, k, random); 32 | } 33 | 34 | public int b() { 35 | return 6; 36 | } 37 | 38 | public void dropNaturally(World world, int i, int j, int k, int l, float f, int i1) { 39 | if (!world.isStatic) { 40 | int j1 = 1; 41 | 42 | if (l >= 3) { 43 | j1 = 2 + world.random.nextInt(3); 44 | if (i1 > 0) { 45 | j1 += world.random.nextInt(i1 + 1); 46 | } 47 | } 48 | 49 | for (int k1 = 0; k1 < j1; ++k1) { 50 | this.a(world, i, j, k, new ItemStack(Items.NETHER_STALK)); 51 | } 52 | } 53 | } 54 | 55 | public Item getDropType(int i, Random random, int j) { 56 | return null; 57 | } 58 | 59 | public int a(Random random) { 60 | return 0; 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ChunkCoordIntPair.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class ChunkCoordIntPair { 4 | 5 | public final int x; 6 | public final int z; 7 | 8 | public ChunkCoordIntPair(int i, int j) { 9 | this.x = i; 10 | this.z = j; 11 | } 12 | 13 | public static long a(int i, int j) { 14 | return (long) i & 4294967295L | ((long) j & 4294967295L) << 32; 15 | } 16 | 17 | public int hashCode() { 18 | int i = 1664525 * this.x + 1013904223; 19 | int j = 1664525 * (this.z ^ -559038737) + 1013904223; 20 | 21 | return i ^ j; 22 | } 23 | 24 | public boolean equals(Object object) { 25 | if (this == object) { 26 | return true; 27 | } else if (!(object instanceof ChunkCoordIntPair)) { 28 | return false; 29 | } else { 30 | ChunkCoordIntPair chunkcoordintpair = (ChunkCoordIntPair) object; 31 | 32 | return this.x == chunkcoordintpair.x && this.z == chunkcoordintpair.z; 33 | } 34 | } 35 | 36 | public int a() { 37 | return (this.x << 4) + 8; 38 | } 39 | 40 | public int b() { 41 | return (this.z << 4) + 8; 42 | } 43 | 44 | public ChunkPosition a(int i) { 45 | return new ChunkPosition(this.a(), i, this.b()); 46 | } 47 | 48 | public String toString() { 49 | return "[" + this.x + ", " + this.z + "]"; 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ChunkMap.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class ChunkMap { 4 | 5 | public byte[] a; 6 | public int b; 7 | public int c; 8 | public int dataSize; // Poweruser 9 | 10 | public ChunkMap() {} 11 | } 12 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ClientCommandOrdinalWrapper.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | // CraftBukkit - import package private class 4 | class ClientCommandOrdinalWrapper { 5 | 6 | static final int[] a = new int[EnumClientCommand.values().length]; 7 | 8 | static { 9 | try { 10 | a[EnumClientCommand.PERFORM_RESPAWN.ordinal()] = 1; 11 | } catch (NoSuchFieldError nosuchfielderror) { 12 | ; 13 | } 14 | 15 | try { 16 | a[EnumClientCommand.REQUEST_STATS.ordinal()] = 2; 17 | } catch (NoSuchFieldError nosuchfielderror1) { 18 | ; 19 | } 20 | 21 | try { 22 | a[EnumClientCommand.OPEN_INVENTORY_ACHIEVEMENT.ordinal()] = 3; 23 | } catch (NoSuchFieldError nosuchfielderror2) { 24 | ; 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ContainerAnvilInventory.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | // CraftBukkit start 4 | import java.util.List; 5 | import org.bukkit.craftbukkit.entity.CraftHumanEntity; 6 | import org.bukkit.entity.HumanEntity; 7 | // CraftBukkit end 8 | 9 | public class ContainerAnvilInventory extends InventorySubcontainer { // CraftBukkit - public 10 | 11 | final ContainerAnvil a; 12 | 13 | // CraftBukkit start 14 | public List transaction = new java.util.ArrayList(); 15 | public org.bukkit.entity.Player player; 16 | private int maxStack = MAX_STACK; 17 | 18 | public ItemStack[] getContents() { 19 | return this.items; 20 | } 21 | 22 | public void onOpen(CraftHumanEntity who) { 23 | transaction.add(who); 24 | } 25 | 26 | public void onClose(CraftHumanEntity who) { 27 | transaction.remove(who); 28 | } 29 | 30 | public List getViewers() { 31 | return transaction; 32 | } 33 | 34 | public org.bukkit.inventory.InventoryHolder getOwner() { 35 | return this.player; 36 | } 37 | 38 | public void setMaxStackSize(int size) { 39 | maxStack = size; 40 | } 41 | // CraftBukkit end 42 | 43 | ContainerAnvilInventory(ContainerAnvil containeranvil, String s, boolean flag, int i) { 44 | super(s, flag, i); 45 | this.a = containeranvil; 46 | } 47 | 48 | // CraftBukkit start - override inherited maxStack from InventorySubcontainer 49 | public int getMaxStackSize() { 50 | return maxStack; 51 | } 52 | // CraftBukkit end 53 | 54 | public void update() { 55 | super.update(); 56 | this.a.a((IInventory) this); 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ContainerEnchantTableInventory.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | // CraftBukkit start 4 | import java.util.List; 5 | import org.bukkit.craftbukkit.entity.CraftHumanEntity; 6 | import org.bukkit.entity.HumanEntity; 7 | // CraftBukkit end 8 | 9 | public class ContainerEnchantTableInventory extends InventorySubcontainer { // CraftBukkit -> public 10 | 11 | final ContainerEnchantTable enchantTable; 12 | 13 | // CraftBukkit start 14 | public List transaction = new java.util.ArrayList(); 15 | public org.bukkit.entity.Player player; 16 | private int maxStack = MAX_STACK; 17 | 18 | public ItemStack[] getContents() { 19 | return this.items; 20 | } 21 | 22 | public void onOpen(CraftHumanEntity who) { 23 | transaction.add(who); 24 | } 25 | 26 | public void onClose(CraftHumanEntity who) { 27 | transaction.remove(who); 28 | } 29 | 30 | public List getViewers() { 31 | return transaction; 32 | } 33 | 34 | public org.bukkit.inventory.InventoryHolder getOwner() { 35 | return this.player; 36 | } 37 | 38 | public void setMaxStackSize(int size) { 39 | maxStack = size; 40 | } 41 | // CraftBukkit end 42 | 43 | ContainerEnchantTableInventory(ContainerEnchantTable containerenchanttable, String s, boolean flag, int i) { 44 | super(s, flag, i); 45 | this.enchantTable = containerenchanttable; 46 | this.setMaxStackSize(1); // CraftBukkit 47 | } 48 | 49 | public int getMaxStackSize() { 50 | return maxStack; // CraftBukkit 51 | } 52 | 53 | public void update() { 54 | super.update(); 55 | this.enchantTable.a((IInventory) this); 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/EntityDamageSourceIndirect.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class EntityDamageSourceIndirect extends EntityDamageSource { 4 | 5 | private Entity owner; 6 | 7 | public EntityDamageSourceIndirect(String s, Entity entity, Entity entity1) { 8 | super(s, entity); 9 | this.owner = entity1; 10 | } 11 | 12 | public Entity i() { 13 | return this.p; 14 | } 15 | 16 | public Entity getEntity() { 17 | return this.owner; 18 | } 19 | 20 | public IChatBaseComponent getLocalizedDeathMessage(EntityLiving entityliving) { 21 | IChatBaseComponent ichatbasecomponent = this.owner == null ? this.p.getScoreboardDisplayName() : this.owner.getScoreboardDisplayName(); 22 | ItemStack itemstack = this.owner instanceof EntityLiving ? ((EntityLiving) this.owner).be() : null; 23 | String s = "death.attack." + this.translationIndex; 24 | String s1 = s + ".item"; 25 | 26 | return itemstack != null && itemstack.hasName() && LocaleI18n.c(s1) ? new ChatMessage(s1, new Object[] { entityliving.getScoreboardDisplayName(), ichatbasecomponent, itemstack.E()}) : new ChatMessage(s, new Object[] { entityliving.getScoreboardDisplayName(), ichatbasecomponent}); 27 | } 28 | 29 | // CraftBukkit start 30 | public Entity getProximateDamageSource() { 31 | return super.getEntity(); 32 | } 33 | // CraftBukkit end 34 | } 35 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/EntityMinecartCommandBlockListener.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | // CraftBukkit - package-private -> public 4 | public class EntityMinecartCommandBlockListener extends CommandBlockListenerAbstract { 5 | 6 | final EntityMinecartCommandBlock a; 7 | 8 | EntityMinecartCommandBlockListener(EntityMinecartCommandBlock entityminecartcommandblock) { 9 | this.a = entityminecartcommandblock; 10 | this.sender = (org.bukkit.craftbukkit.entity.CraftMinecartCommand) entityminecartcommandblock.getBukkitEntity(); // CraftBukkit - Set the sender 11 | } 12 | 13 | public void e() { 14 | this.a.getDataWatcher().watch(23, this.i()); 15 | this.a.getDataWatcher().watch(24, ChatSerializer.a(this.h())); 16 | } 17 | 18 | public ChunkCoordinates getChunkCoordinates() { 19 | return new ChunkCoordinates(MathHelper.floor(this.a.locX), MathHelper.floor(this.a.locY + 0.5D), MathHelper.floor(this.a.locZ)); 20 | } 21 | 22 | public World getWorld() { 23 | return this.a.world; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/GroupDataZombie.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | // CraftBukkit - package-private import 4 | class GroupDataZombie implements GroupDataEntity { 5 | 6 | public boolean a; 7 | public boolean b; 8 | final EntityZombie c; 9 | 10 | private GroupDataZombie(EntityZombie entityzombie, boolean flag, boolean flag1) { 11 | this.c = entityzombie; 12 | this.a = false; 13 | this.b = false; 14 | this.a = flag; 15 | this.b = flag1; 16 | } 17 | 18 | GroupDataZombie(EntityZombie entityzombie, boolean flag, boolean flag1, EmptyClassZombie emptyclasszombie) { 19 | this(entityzombie, flag, flag1); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/IDataManager.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import java.io.File; 4 | 5 | public interface IDataManager { 6 | 7 | WorldData getWorldData(); 8 | 9 | void checkSession() throws ExceptionWorldConflict; // CraftBukkit - throws ExceptionWorldConflict 10 | 11 | IChunkLoader createChunkLoader(WorldProvider worldprovider); 12 | 13 | void saveWorldData(WorldData worlddata, NBTTagCompound nbttagcompound); 14 | 15 | void saveWorldData(WorldData worlddata); 16 | 17 | IPlayerFileData getPlayerFileData(); 18 | 19 | void a(); 20 | 21 | File getDirectory(); 22 | 23 | File getDataFile(String s); 24 | 25 | String g(); 26 | 27 | java.util.UUID getUUID(); // CraftBukkit 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/IInventory.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import org.bukkit.craftbukkit.entity.CraftHumanEntity; // CraftBukkit 4 | 5 | public interface IInventory { 6 | 7 | int getSize(); 8 | 9 | ItemStack getItem(int i); 10 | 11 | ItemStack splitStack(int i, int j); 12 | 13 | ItemStack splitWithoutUpdate(int i); 14 | 15 | void setItem(int i, ItemStack itemstack); 16 | 17 | String getInventoryName(); 18 | 19 | boolean k_(); 20 | 21 | int getMaxStackSize(); 22 | 23 | void update(); 24 | 25 | boolean a(EntityHuman entityhuman); 26 | 27 | void startOpen(); 28 | 29 | void l_(); 30 | 31 | boolean b(int i, ItemStack itemstack); 32 | 33 | // CraftBukkit start 34 | ItemStack[] getContents(); 35 | 36 | void onOpen(CraftHumanEntity who); 37 | 38 | void onClose(CraftHumanEntity who); 39 | 40 | java.util.List getViewers(); 41 | 42 | org.bukkit.inventory.InventoryHolder getOwner(); 43 | 44 | void setMaxStackSize(int size); 45 | 46 | int MAX_STACK = 64; 47 | // CraftBukkit end 48 | } 49 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/IRecipe.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public interface IRecipe { 4 | 5 | boolean a(InventoryCrafting inventorycrafting, World world); 6 | 7 | ItemStack a(InventoryCrafting inventorycrafting); 8 | 9 | int a(); 10 | 11 | ItemStack b(); 12 | 13 | org.bukkit.inventory.Recipe toBukkitRecipe(); // CraftBukkit 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/InventoryHorseChest.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | // CraftBukkit start 4 | import java.util.List; 5 | import org.bukkit.craftbukkit.entity.CraftHumanEntity; 6 | import org.bukkit.entity.HumanEntity; 7 | // CraftBukkit end 8 | 9 | public class InventoryHorseChest extends InventorySubcontainer { 10 | 11 | public InventoryHorseChest(String s, int i) { 12 | super(s, false, i); 13 | } 14 | 15 | // CraftBukkit start 16 | public List transaction = new java.util.ArrayList(); 17 | private EntityHorse horse; 18 | private int maxStack = MAX_STACK; 19 | 20 | public InventoryHorseChest(String s, int i, EntityHorse horse) { 21 | this(s, i); 22 | this.horse = horse; 23 | } 24 | 25 | @Override 26 | public ItemStack[] getContents() { 27 | return this.items; 28 | } 29 | 30 | @Override 31 | public void onOpen(CraftHumanEntity who) { 32 | transaction.add(who); 33 | } 34 | 35 | @Override 36 | public void onClose(CraftHumanEntity who) { 37 | transaction.remove(who); 38 | } 39 | 40 | @Override 41 | public List getViewers() { 42 | return transaction; 43 | } 44 | 45 | @Override 46 | public org.bukkit.inventory.InventoryHolder getOwner() { 47 | return (org.bukkit.entity.Horse) this.horse.getBukkitEntity(); 48 | } 49 | 50 | @Override 51 | public void setMaxStackSize(int size) { 52 | maxStack = size; 53 | } 54 | 55 | @Override 56 | public int getMaxStackSize() { 57 | return maxStack; 58 | } 59 | // CraftBukkit end 60 | } 61 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ItemFishingRod.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import org.bukkit.event.player.PlayerFishEvent; // CraftBukkit 4 | 5 | public class ItemFishingRod extends Item { 6 | 7 | public ItemFishingRod() { 8 | this.setMaxDurability(64); 9 | this.e(1); 10 | this.a(CreativeModeTab.i); 11 | } 12 | 13 | public ItemStack a(ItemStack itemstack, World world, EntityHuman entityhuman) { 14 | if (entityhuman.hookedFish != null) { 15 | int i = entityhuman.hookedFish.e(); 16 | 17 | itemstack.damage(i, entityhuman); 18 | entityhuman.ba(); 19 | } else { 20 | // CraftBukkit start 21 | EntityFishingHook hook = new EntityFishingHook(world, entityhuman); 22 | PlayerFishEvent playerFishEvent = new PlayerFishEvent((org.bukkit.entity.Player) entityhuman.getBukkitEntity(), null, (org.bukkit.entity.Fish) hook.getBukkitEntity(), PlayerFishEvent.State.FISHING); 23 | world.getServer().getPluginManager().callEvent(playerFishEvent); 24 | 25 | if (playerFishEvent.isCancelled()) { 26 | return itemstack; 27 | } 28 | // CraftBukkit end 29 | world.makeSound(entityhuman, "random.bow", 0.5F, 0.4F / (g.nextFloat() * 0.4F + 0.8F)); 30 | if (!world.isStatic) { 31 | world.addEntity(hook); // CraftBukkit - moved creation up 32 | } 33 | 34 | entityhuman.ba(); 35 | } 36 | 37 | return itemstack; 38 | } 39 | 40 | public boolean e_(ItemStack itemstack) { 41 | return super.e_(itemstack); 42 | } 43 | 44 | public int c() { 45 | return 1; 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ItemMapEmpty.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class ItemMapEmpty extends ItemWorldMapBase { 4 | 5 | protected ItemMapEmpty() { 6 | this.a(CreativeModeTab.f); 7 | } 8 | 9 | public ItemStack a(ItemStack itemstack, World world, EntityHuman entityhuman) { 10 | World worldMain = world.getServer().getServer().worlds.get(0); // CraftBukkit - store reference to primary world 11 | ItemStack itemstack1 = new ItemStack(Items.MAP, 1, worldMain.b("map")); // CraftBukkit - use primary world for maps 12 | String s = "map_" + itemstack1.getData(); 13 | WorldMap worldmap = new WorldMap(s); 14 | 15 | worldMain.a(s, (PersistentBase) worldmap); // CraftBukkit - use primary world for maps 16 | worldmap.scale = 0; 17 | int i = 128 * (1 << worldmap.scale); 18 | 19 | worldmap.centerX = (int) (Math.round(entityhuman.locX / (double) i) * (long) i); 20 | worldmap.centerZ = (int) (Math.round(entityhuman.locZ / (double) i) * (long) i); 21 | worldmap.map = (byte) ((WorldServer) world).dimension; // CraftBukkit - use bukkit dimension 22 | worldmap.c(); 23 | 24 | org.bukkit.craftbukkit.event.CraftEventFactory.callEvent(new org.bukkit.event.server.MapInitializeEvent(worldmap.mapView)); // CraftBukkit 25 | 26 | --itemstack.count; 27 | if (itemstack.count <= 0) { 28 | return itemstack1; 29 | } else { 30 | if (!entityhuman.inventory.pickup(itemstack1.cloneItemStack())) { 31 | entityhuman.drop(itemstack1, false); 32 | } 33 | 34 | return itemstack; 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ItemMinecart.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class ItemMinecart extends Item { 4 | 5 | private static final IDispenseBehavior b = new DispenseBehaviorMinecart(); 6 | public int a; 7 | 8 | public ItemMinecart(int i) { 9 | this.maxStackSize = 1; 10 | this.a = i; 11 | this.a(CreativeModeTab.e); 12 | BlockDispenser.a.a(this, b); 13 | } 14 | 15 | public boolean interactWith(ItemStack itemstack, EntityHuman entityhuman, World world, int i, int j, int k, int l, float f, float f1, float f2) { 16 | if (BlockMinecartTrackAbstract.a(world.getType(i, j, k))) { 17 | if (!world.isStatic) { 18 | // CraftBukkit start - Minecarts 19 | org.bukkit.event.player.PlayerInteractEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerInteractEvent(entityhuman, org.bukkit.event.block.Action.RIGHT_CLICK_BLOCK, i, j, k, l, itemstack); 20 | 21 | if (event.isCancelled()) { 22 | return false; 23 | } 24 | // CraftBukkit end 25 | EntityMinecartAbstract entityminecartabstract = EntityMinecartAbstract.a(world, (double) ((float) i + 0.5F), (double) ((float) j + 0.5F), (double) ((float) k + 0.5F), this.a); 26 | 27 | if (itemstack.hasName()) { 28 | entityminecartabstract.a(itemstack.getName()); 29 | } 30 | 31 | world.addEntity(entityminecartabstract); 32 | } 33 | 34 | --itemstack.count; 35 | return true; 36 | } else { 37 | return false; 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ItemRedstone.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class ItemRedstone extends Item { 4 | 5 | public ItemRedstone() { 6 | this.a(CreativeModeTab.d); 7 | } 8 | 9 | public boolean interactWith(ItemStack itemstack, EntityHuman entityhuman, World world, int i, int j, int k, int l, float f, float f1, float f2) { 10 | final int clickedX = i, clickedY = j, clickedZ = k; // CraftBukkit 11 | if (world.getType(i, j, k) != Blocks.SNOW) { 12 | if (l == 0) { 13 | --j; 14 | } 15 | 16 | if (l == 1) { 17 | ++j; 18 | } 19 | 20 | if (l == 2) { 21 | --k; 22 | } 23 | 24 | if (l == 3) { 25 | ++k; 26 | } 27 | 28 | if (l == 4) { 29 | --i; 30 | } 31 | 32 | if (l == 5) { 33 | ++i; 34 | } 35 | 36 | if (!world.isEmpty(i, j, k)) { 37 | return false; 38 | } 39 | } 40 | 41 | if (!entityhuman.a(i, j, k, l, itemstack)) { 42 | return false; 43 | } else { 44 | if (Blocks.REDSTONE_WIRE.canPlace(world, i, j, k)) { 45 | // CraftBukkit start 46 | // --itemstack.count; 47 | // world.setTypeUpdate(i, j, k, Blocks.REDSTONE_WIRE); 48 | if (!ItemBlock.processBlockPlace(world, entityhuman, itemstack, i, j, k, Blocks.REDSTONE_WIRE, 0, clickedX, clickedY, clickedZ)) { 49 | return false; 50 | } 51 | // CraftBukkit end 52 | } 53 | 54 | return true; 55 | } 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ItemSeedFood.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class ItemSeedFood extends ItemFood { 4 | 5 | private Block b; 6 | private Block c; 7 | 8 | public ItemSeedFood(int i, float f, Block block, Block block1) { 9 | super(i, f, false); 10 | this.b = block; 11 | this.c = block1; 12 | } 13 | 14 | public boolean interactWith(ItemStack itemstack, EntityHuman entityhuman, World world, int i, int j, int k, int l, float f, float f1, float f2) { 15 | final int clickedX = i, clickedY = j, clickedZ = k; // CraftBukkit 16 | if (l != 1) { 17 | return false; 18 | } else if (entityhuman.a(i, j, k, l, itemstack) && entityhuman.a(i, j + 1, k, l, itemstack)) { 19 | if (world.getType(i, j, k) == this.c && world.isEmpty(i, j + 1, k)) { 20 | // CraftBukkit start 21 | // world.setTypeUpdate(i, j + 1, k, this.b); 22 | if (!ItemBlock.processBlockPlace(world, entityhuman, null, i, j + 1, k, this.b, 0, clickedX, clickedY, clickedZ)) { 23 | return false; 24 | } 25 | // CraftBukkit end 26 | --itemstack.count; 27 | return true; 28 | } else { 29 | return false; 30 | } 31 | } else { 32 | return false; 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ItemSeeds.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class ItemSeeds extends Item { 4 | 5 | private Block block; 6 | private Block b; 7 | 8 | public ItemSeeds(Block block, Block block1) { 9 | this.block = block; 10 | this.b = block1; 11 | this.a(CreativeModeTab.l); 12 | } 13 | 14 | public boolean interactWith(ItemStack itemstack, EntityHuman entityhuman, World world, int i, int j, int k, int l, float f, float f1, float f2) { 15 | final int clickedX = i, clickedY = j, clickedZ = k; // CraftBukkit 16 | if (l != 1) { 17 | return false; 18 | } else if (entityhuman.a(i, j, k, l, itemstack) && entityhuman.a(i, j + 1, k, l, itemstack)) { 19 | if (world.getType(i, j, k) == this.b && world.isEmpty(i, j + 1, k)) { 20 | // CraftBukkit start - Seeds 21 | // world.setTypeUpdate(i, j + 1, k, this.block); 22 | if (!ItemBlock.processBlockPlace(world, entityhuman, null, i, j + 1, k, this.block, 0, clickedX, clickedY, clickedZ)) { 23 | return false; 24 | } 25 | // CraftBukkit end 26 | --itemstack.count; 27 | return true; 28 | } else { 29 | return false; 30 | } 31 | } else { 32 | return false; 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ItemSnow.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class ItemSnow extends ItemBlockWithAuxData { 4 | 5 | public ItemSnow(Block block, Block block1) { 6 | super(block, block1); 7 | } 8 | 9 | public boolean interactWith(ItemStack itemstack, EntityHuman entityhuman, World world, int i, int j, int k, int l, float f, float f1, float f2) { 10 | final int clickedX = i, clickedY = j, clickedZ = k; // CraftBukkit 11 | if (itemstack.count == 0) { 12 | return false; 13 | } else if (!entityhuman.a(i, j, k, l, itemstack)) { 14 | return false; 15 | } else { 16 | Block block = world.getType(i, j, k); 17 | 18 | if (block == Blocks.SNOW) { 19 | int i1 = world.getData(i, j, k); 20 | int j1 = i1 & 7; 21 | 22 | // CraftBukkit start - Redirect to common handler 23 | if (j1 <= 6 && world.b(this.block.a(world, i, j, k)) && ItemBlock.processBlockPlace(world, entityhuman, itemstack, i, j, k, block, j1 + 1 | i1 & -8, clickedX, clickedY, clickedZ)) { 24 | return true; 25 | } 26 | /* 27 | if (j1 <= 6 && world.b(this.block.a(world, i, j, k)) && world.setData(i, j, k, j1 + 1 | i1 & -8, 2)) { 28 | world.makeSound((double) ((float) i + 0.5F), (double) ((float) j + 0.5F), (double) ((float) k + 0.5F), this.block.stepSound.getPlaceSound(), (this.block.stepSound.getVolume1() + 1.0F) / 2.0F, this.block.stepSound.getVolume2() * 0.8F); 29 | --itemstack.count; 30 | return true; 31 | } 32 | // CraftBukkit end */ 33 | } 34 | 35 | return super.interactWith(itemstack, entityhuman, world, i, j, k, l, f, f1, f2); 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/MethodProfiler.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Collections; 5 | import java.util.HashMap; 6 | import java.util.Iterator; 7 | import java.util.List; 8 | import java.util.Map; 9 | 10 | import org.apache.logging.log4j.LogManager; 11 | import org.apache.logging.log4j.Logger; 12 | 13 | // CraftBukkit start - Strip down to empty methods, performance cost 14 | public class MethodProfiler { 15 | public boolean a = false; 16 | 17 | public final void a() { } 18 | public final void a(String s) { } 19 | public final void b() { } 20 | public final List b(String s) { return null; } 21 | public final void c(String s) { } 22 | public final String c() { return null; } 23 | } 24 | // CraftBukkit end 25 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/NBTTagString.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import java.io.DataInput; 4 | import java.io.DataOutput; 5 | import java.io.IOException; 6 | 7 | public class NBTTagString extends NBTBase { 8 | 9 | private String data; 10 | 11 | public NBTTagString() { 12 | this.data = ""; 13 | } 14 | 15 | public NBTTagString(String s) { 16 | this.data = s; 17 | if (s == null) { 18 | throw new IllegalArgumentException("Empty string not allowed"); 19 | } 20 | } 21 | 22 | void write(DataOutput dataoutput) throws IOException { // Poweruser - added throws IOException 23 | dataoutput.writeUTF(this.data); 24 | } 25 | 26 | void load(DataInput datainput, int i) throws IOException { // Poweruser - added throws IOException 27 | //this.data = datainput.readUTF(), true; 28 | this.data = getStoredString(datainput.readUTF(), true); // Poweruser 29 | } 30 | 31 | public byte getTypeId() { 32 | return (byte) 8; 33 | } 34 | 35 | public String toString() { 36 | return "\"" + this.data + "\""; 37 | } 38 | 39 | public NBTBase clone() { 40 | return new NBTTagString(this.data); 41 | } 42 | 43 | public boolean equals(Object object) { 44 | if (!super.equals(object)) { 45 | return false; 46 | } else { 47 | NBTTagString nbttagstring = (NBTTagString) object; 48 | 49 | return this.data == null && nbttagstring.data == null || this.data != null && this.data.equals(nbttagstring.data); 50 | } 51 | } 52 | 53 | public int hashCode() { 54 | return super.hashCode() ^ this.data.hashCode(); 55 | } 56 | 57 | public String a_() { 58 | return this.data; 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/NoteDataList.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import java.util.ArrayList; 4 | 5 | // CraftBukkit - imported class because the constructor is package private 6 | class NoteDataList extends ArrayList { 7 | 8 | private NoteDataList() {} 9 | 10 | NoteDataList(EmptyClass2 emptyclass2) { 11 | this(); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/PacketHandshakingInSetProtocol.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import java.io.IOException; // CraftBukkit 4 | 5 | public class PacketHandshakingInSetProtocol extends Packet { 6 | 7 | private int a; 8 | public String b; // CraftBukkit private -> public 9 | public int c; // CraftBukkit private -> public 10 | private EnumProtocol d; 11 | 12 | public PacketHandshakingInSetProtocol() {} 13 | 14 | public void a(PacketDataSerializer packetdataserializer) throws IOException { // CraftBukkit - added throws 15 | this.a = packetdataserializer.a(); 16 | this.b = packetdataserializer.c(255); 17 | this.c = packetdataserializer.readUnsignedShort(); 18 | this.d = EnumProtocol.a(packetdataserializer.a()); 19 | } 20 | 21 | public void b(PacketDataSerializer packetdataserializer) throws IOException { // CraftBukkit - added throws 22 | packetdataserializer.b(this.a); 23 | packetdataserializer.a(this.b); 24 | packetdataserializer.writeShort(this.c); 25 | packetdataserializer.b(this.d.c()); 26 | } 27 | 28 | public void a(PacketHandshakingInListener packethandshakinginlistener) { 29 | packethandshakinginlistener.a(this); 30 | } 31 | 32 | public boolean a() { 33 | return true; 34 | } 35 | 36 | public EnumProtocol c() { 37 | return this.d; 38 | } 39 | 40 | public int d() { 41 | return this.a; 42 | } 43 | 44 | public void handle(PacketListener packetlistener) { 45 | this.a((PacketHandshakingInListener) packetlistener); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/PacketPlayInChat.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import java.io.IOException; // CraftBukkit 4 | 5 | public class PacketPlayInChat extends Packet { 6 | 7 | private String message; 8 | 9 | public PacketPlayInChat() {} 10 | 11 | public PacketPlayInChat(String s) { 12 | if (s.length() > 100) { 13 | s = s.substring(0, 100); 14 | } 15 | 16 | this.message = s; 17 | } 18 | 19 | public void a(PacketDataSerializer packetdataserializer) throws IOException { // CraftBukkit - added throws 20 | this.message = packetdataserializer.c(100); 21 | } 22 | 23 | public void b(PacketDataSerializer packetdataserializer) throws IOException { // CraftBukkit - added throws 24 | packetdataserializer.a(this.message); 25 | } 26 | 27 | public void a(PacketPlayInListener packetplayinlistener) { 28 | packetplayinlistener.a(this); 29 | } 30 | 31 | public String b() { 32 | return String.format("message=\'%s\'", new Object[] { this.message}); 33 | } 34 | 35 | public String c() { 36 | return this.message; 37 | } 38 | 39 | // CraftBukkit start - make chat async 40 | @Override 41 | public boolean a() { 42 | return !this.message.startsWith("/"); 43 | } 44 | // CraftBukkit end 45 | 46 | public void handle(PacketListener packetlistener) { 47 | this.a((PacketPlayInListener) packetlistener); 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/PacketPlayInCloseWindow.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class PacketPlayInCloseWindow extends Packet { 4 | 5 | private int a; 6 | 7 | public PacketPlayInCloseWindow() {} 8 | 9 | // CraftBukkit start - Add constructor 10 | public PacketPlayInCloseWindow(int id) { 11 | this.a = id; 12 | } 13 | // CraftBukkit end 14 | public void a(PacketPlayInListener packetplayinlistener) { 15 | packetplayinlistener.a(this); 16 | } 17 | 18 | public void a(PacketDataSerializer packetdataserializer) { 19 | this.a = packetdataserializer.readByte(); 20 | } 21 | 22 | public void b(PacketDataSerializer packetdataserializer) { 23 | packetdataserializer.writeByte(this.a); 24 | } 25 | 26 | public void handle(PacketListener packetlistener) { 27 | this.a((PacketPlayInListener) packetlistener); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/PacketPlayInCustomPayload.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import java.io.IOException; // CraftBukkit 4 | 5 | public class PacketPlayInCustomPayload extends Packet { 6 | 7 | private String tag; 8 | public int length; // CraftBukkit - private -> public 9 | private byte[] data; 10 | 11 | public PacketPlayInCustomPayload() {} 12 | 13 | public void a(PacketDataSerializer packetdataserializer) throws IOException { // CraftBukkit - added throws 14 | this.tag = packetdataserializer.c(20); 15 | this.length = packetdataserializer.readShort(); 16 | if (this.length > 0 && this.length < 32767) { 17 | this.data = new byte[this.length]; 18 | packetdataserializer.readBytes(this.data); 19 | } 20 | } 21 | 22 | public void b(PacketDataSerializer packetdataserializer) throws IOException { // CraftBukkit - added throws 23 | packetdataserializer.a(this.tag); 24 | packetdataserializer.writeShort((short) this.length); 25 | if (this.data != null) { 26 | packetdataserializer.writeBytes(this.data); 27 | } 28 | } 29 | 30 | public void a(PacketPlayInListener packetplayinlistener) { 31 | packetplayinlistener.a(this); 32 | } 33 | 34 | public String c() { 35 | return this.tag; 36 | } 37 | 38 | public byte[] e() { 39 | return this.data; 40 | } 41 | 42 | public void handle(PacketListener packetlistener) { 43 | this.a((PacketPlayInListener) packetlistener); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/PacketPlayOutSpawnPosition.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class PacketPlayOutSpawnPosition extends Packet { 4 | 5 | public int x; // CraftBukkit - private -> public 6 | public int y; // CraftBukkit - private -> public 7 | public int z; // CraftBukkit - private -> public 8 | 9 | public PacketPlayOutSpawnPosition() {} 10 | 11 | public PacketPlayOutSpawnPosition(int i, int j, int k) { 12 | this.x = i; 13 | this.y = j; 14 | this.z = k; 15 | } 16 | 17 | public void a(PacketDataSerializer packetdataserializer) { 18 | this.x = packetdataserializer.readInt(); 19 | this.y = packetdataserializer.readInt(); 20 | this.z = packetdataserializer.readInt(); 21 | } 22 | 23 | public void b(PacketDataSerializer packetdataserializer) { 24 | packetdataserializer.writeInt(this.x); 25 | packetdataserializer.writeInt(this.y); 26 | packetdataserializer.writeInt(this.z); 27 | } 28 | 29 | public void a(PacketPlayOutListener packetplayoutlistener) { 30 | packetplayoutlistener.a(this); 31 | } 32 | 33 | public boolean a() { 34 | return false; 35 | } 36 | 37 | public String b() { 38 | return String.format("x=%d, y=%d, z=%d", new Object[] { Integer.valueOf(this.x), Integer.valueOf(this.y), Integer.valueOf(this.z)}); 39 | } 40 | 41 | public void handle(PacketListener packetlistener) { 42 | this.a((PacketPlayOutListener) packetlistener); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/PathfinderGoalMoveTowardsRestriction.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import de.minetick.pathsearch.PositionPathSearchType; // Poweruser 4 | 5 | public class PathfinderGoalMoveTowardsRestriction extends PathfinderGoal { 6 | 7 | private EntityCreature a; 8 | private double b; 9 | private double c; 10 | private double d; 11 | private double e; 12 | 13 | public PathfinderGoalMoveTowardsRestriction(EntityCreature entitycreature, double d0) { 14 | this.a = entitycreature; 15 | this.e = d0; 16 | this.a(1); 17 | } 18 | 19 | public boolean a() { 20 | if (this.a.bS()) { 21 | return false; 22 | } else { 23 | ChunkCoordinates chunkcoordinates = this.a.bT(); 24 | Vec3D vec3d = RandomPositionGenerator.a(this.a, 16, 7, this.a.world.getVec3DPool().create((double) chunkcoordinates.x, (double) chunkcoordinates.y, (double) chunkcoordinates.z)); 25 | 26 | if (vec3d == null) { 27 | return false; 28 | } else { 29 | this.b = vec3d.c; 30 | this.c = vec3d.d; 31 | this.d = vec3d.e; 32 | return true; 33 | } 34 | } 35 | } 36 | 37 | public boolean b() { 38 | return !this.a.getNavigation().g(); 39 | } 40 | 41 | public void c() { 42 | //this.a.getNavigation().a(this.b, this.c, this.d, this.e); 43 | this.a.getNavigation().a(PositionPathSearchType.MOVETOWARDSRESTRICTION, this.b, this.c, this.d, this.e); // Poweruser 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/PathfinderGoalMoveTowardsTarget.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import de.minetick.pathsearch.PositionPathSearchType; // Poweruser 4 | 5 | public class PathfinderGoalMoveTowardsTarget extends PathfinderGoal { 6 | 7 | private EntityCreature a; 8 | private EntityLiving b; 9 | private double c; 10 | private double d; 11 | private double e; 12 | private double f; 13 | private float g; 14 | 15 | public PathfinderGoalMoveTowardsTarget(EntityCreature entitycreature, double d0, float f) { 16 | this.a = entitycreature; 17 | this.f = d0; 18 | this.g = f; 19 | this.a(1); 20 | } 21 | 22 | public boolean a() { 23 | this.b = this.a.getGoalTarget(); 24 | if (this.b == null) { 25 | return false; 26 | } else if (this.b.e(this.a) > (double) (this.g * this.g)) { 27 | return false; 28 | } else { 29 | Vec3D vec3d = RandomPositionGenerator.a(this.a, 16, 7, this.a.world.getVec3DPool().create(this.b.locX, this.b.locY, this.b.locZ)); 30 | 31 | if (vec3d == null) { 32 | return false; 33 | } else { 34 | this.c = vec3d.c; 35 | this.d = vec3d.d; 36 | this.e = vec3d.e; 37 | return true; 38 | } 39 | } 40 | } 41 | 42 | public boolean b() { 43 | return !this.a.getNavigation().g() && this.b.isAlive() && this.b.e(this.a) < (double) (this.g * this.g); 44 | } 45 | 46 | public void d() { 47 | this.b = null; 48 | } 49 | 50 | public void c() { 51 | //this.a.getNavigation().a(this.c, this.d, this.e, this.f); 52 | this.a.getNavigation().a(PositionPathSearchType.MOVETOWARDSTARGET, this.c, this.d, this.e, this.f); // Poweruser 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/PathfinderGoalPanic.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import de.minetick.pathsearch.PositionPathSearchType; // Poweruser 4 | 5 | public class PathfinderGoalPanic extends PathfinderGoal { 6 | 7 | private EntityCreature a; 8 | private double b; 9 | private double c; 10 | private double d; 11 | private double e; 12 | 13 | public PathfinderGoalPanic(EntityCreature entitycreature, double d0) { 14 | this.a = entitycreature; 15 | this.b = d0; 16 | this.a(1); 17 | } 18 | 19 | public boolean a() { 20 | if (this.a.getLastDamager() == null && !this.a.isBurning()) { 21 | return false; 22 | } else { 23 | Vec3D vec3d = RandomPositionGenerator.a(this.a, 5, 4); 24 | 25 | if (vec3d == null) { 26 | return false; 27 | } else { 28 | this.c = vec3d.c; 29 | this.d = vec3d.d; 30 | this.e = vec3d.e; 31 | return true; 32 | } 33 | } 34 | } 35 | 36 | public void c() { 37 | //this.a.getNavigation().a(this.c, this.d, this.e, this.b); 38 | this.a.getNavigation().a(PositionPathSearchType.PANIC, this.c, this.d, this.e, this.b); // Poweruser 39 | } 40 | 41 | public boolean b() { 42 | // CraftBukkit start - introduce a temporary timeout hack until this is fixed properly 43 | if ((this.a.ticksLived - this.a.aK()) > 100) { 44 | this.a.b((EntityLiving) null); 45 | return false; 46 | } 47 | // CraftBukkit end 48 | return !this.a.getNavigation().g(); 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/PathfinderGoalRandomStroll.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import de.minetick.pathsearch.PositionPathSearchType; // Poweruser 4 | 5 | public class PathfinderGoalRandomStroll extends PathfinderGoal { 6 | 7 | private EntityCreature a; 8 | private double b; 9 | private double c; 10 | private double d; 11 | private double e; 12 | private boolean setActive = false; // Poweruser 13 | 14 | public PathfinderGoalRandomStroll(EntityCreature entitycreature, double d0) { 15 | this.a = entitycreature; 16 | this.e = d0; 17 | this.a(1); 18 | } 19 | 20 | public boolean a() { 21 | // Poweruser start 22 | if (this.setActive) { 23 | return true; 24 | } else 25 | // Poweruser end 26 | if (this.a.aN() >= 100) { 27 | return false; 28 | } else if (this.a.aI().nextInt(120) != 0) { 29 | return false; 30 | } else { 31 | Vec3D vec3d = RandomPositionGenerator.a(this.a, 10, 7); 32 | 33 | if (vec3d == null) { 34 | return false; 35 | } else { 36 | this.b = vec3d.c; 37 | this.c = vec3d.d; 38 | this.d = vec3d.e; 39 | this.setActive = true; // Poweruser 40 | return true; 41 | } 42 | } 43 | } 44 | 45 | public boolean b() { 46 | return !this.a.getNavigation().g(); 47 | } 48 | 49 | public void c() { 50 | //this.a.getNavigation().a(this.b, this.c, this.d, this.e); 51 | // Poweruser start 52 | if(this.a.getNavigation().a(PositionPathSearchType.RANDOMSTROLL, this.b, this.c, this.d, this.e)) { 53 | this.setActive = false; 54 | } 55 | // Poweruser end 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/PathfinderGoalSit.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class PathfinderGoalSit extends PathfinderGoal { 4 | 5 | private EntityTameableAnimal entity; 6 | private boolean willSit; 7 | 8 | public PathfinderGoalSit(EntityTameableAnimal entitytameableanimal) { 9 | this.entity = entitytameableanimal; 10 | this.a(5); 11 | } 12 | 13 | public boolean a() { 14 | if (!this.entity.isTamed()) { 15 | return this.willSit && this.entity.getGoalTarget() == null; // CraftBukkit - Allow sitting for wild animals 16 | } else if (this.entity.M()) { 17 | return false; 18 | } else if (!this.entity.onGround) { 19 | return false; 20 | } else { 21 | EntityLiving entityliving = this.entity.getOwner(); 22 | 23 | return entityliving == null ? true : (this.entity.e(entityliving) < 144.0D && entityliving.getLastDamager() != null ? false : this.willSit); 24 | } 25 | } 26 | 27 | public void c() { 28 | this.entity.getNavigation().h(); 29 | this.entity.setSitting(true); 30 | } 31 | 32 | public void d() { 33 | this.entity.setSitting(false); 34 | } 35 | 36 | public void setSitting(boolean flag) { 37 | this.willSit = flag; 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ProtocolOrdinalWrapper.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | // CraftBukkit - import package private class 4 | class ProtocolOrdinalWrapper { 5 | 6 | static final int[] a = new int[EnumProtocol.values().length]; 7 | 8 | static { 9 | try { 10 | a[EnumProtocol.LOGIN.ordinal()] = 1; 11 | } catch (NoSuchFieldError nosuchfielderror) { 12 | ; 13 | } 14 | 15 | try { 16 | a[EnumProtocol.STATUS.ordinal()] = 2; 17 | } catch (NoSuchFieldError nosuchfielderror1) { 18 | ; 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/QueuedPacket.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import net.minecraft.util.io.netty.util.concurrent.GenericFutureListener; 4 | 5 | // CraftBukkit - imported class because the methods are package private 6 | class QueuedPacket { 7 | 8 | private final Packet a; 9 | private final GenericFutureListener[] b; 10 | 11 | public QueuedPacket(Packet packet, GenericFutureListener... agenericfuturelistener) { 12 | this.a = packet; 13 | this.b = agenericfuturelistener; 14 | } 15 | 16 | static Packet a(QueuedPacket queuedpacket) { 17 | return queuedpacket.a; 18 | } 19 | 20 | static GenericFutureListener[] b(QueuedPacket queuedpacket) { 21 | return queuedpacket.b; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/RemoteControlCommandListener.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class RemoteControlCommandListener implements ICommandListener { 4 | 5 | public static final RemoteControlCommandListener instance = new RemoteControlCommandListener(); 6 | private StringBuffer b = new StringBuffer(); 7 | 8 | public RemoteControlCommandListener() {} 9 | 10 | public void e() { 11 | this.b.setLength(0); 12 | } 13 | 14 | public String f() { 15 | return this.b.toString(); 16 | } 17 | 18 | public String getName() { 19 | return "Rcon"; 20 | } 21 | 22 | public IChatBaseComponent getScoreboardDisplayName() { 23 | return new ChatComponentText(this.getName()); 24 | } 25 | 26 | // CraftBukkit start - Send a String 27 | public void sendMessage(String message) { 28 | this.b.append(message); 29 | } 30 | // CraftBukkit end 31 | 32 | public void sendMessage(IChatBaseComponent ichatbasecomponent) { 33 | this.b.append(ichatbasecomponent.c()); 34 | } 35 | 36 | public boolean a(int i, String s) { 37 | return true; 38 | } 39 | 40 | public ChunkCoordinates getChunkCoordinates() { 41 | return new ChunkCoordinates(0, 0, 0); 42 | } 43 | 44 | public World getWorld() { 45 | return MinecraftServer.getServer().getWorld(); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/SecondaryWorldServer.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class SecondaryWorldServer extends WorldServer { 4 | // CraftBukkit start - Add Environment and ChunkGenerator arguments 5 | public SecondaryWorldServer(MinecraftServer minecraftserver, IDataManager idatamanager, String s, int i, WorldSettings worldsettings, WorldServer worldserver, MethodProfiler methodprofiler, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen) { 6 | super(minecraftserver, idatamanager, s, i, worldsettings, methodprofiler, env, gen); 7 | // CraftBukkit end 8 | this.worldMaps = worldserver.worldMaps; 9 | this.scoreboard = worldserver.getScoreboard(); 10 | // this.worldData = new SecondaryWorldData(worldserver.getWorldData()); // CraftBukkit - use unique worlddata 11 | } 12 | 13 | // protected void a() {} // CraftBukkit - save world data! 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/ThreadCommandReader.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.IOException; 5 | import java.io.InputStreamReader; 6 | 7 | import static org.bukkit.craftbukkit.Main.*; // CraftBukkit 8 | 9 | class ThreadCommandReader extends Thread { 10 | 11 | final DedicatedServer server; 12 | 13 | ThreadCommandReader(DedicatedServer dedicatedserver, String s) { 14 | super(s); 15 | this.server = dedicatedserver; 16 | } 17 | 18 | public void run() { 19 | // CraftBukkit start 20 | if (!useConsole) { 21 | return; 22 | } 23 | // CraftBukkit end 24 | 25 | jline.console.ConsoleReader bufferedreader = this.server.reader; // CraftBukkit 26 | String s; 27 | 28 | try { 29 | // CraftBukkit start - JLine disabling compatibility 30 | while (!this.server.isStopped() && this.server.isRunning()) { 31 | if (useJline) { 32 | s = bufferedreader.readLine(">", null); 33 | } else { 34 | s = bufferedreader.readLine(); 35 | } 36 | if (s != null) { 37 | this.server.issueCommand(s, this.server); 38 | } 39 | // CraftBukkit end 40 | } 41 | } catch (IOException ioexception) { 42 | DedicatedServer.az().error("Exception handling console input", ioexception); 43 | } 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/TileEntityCommandListener.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | // CraftBukkit - package-private -> public 4 | public class TileEntityCommandListener extends CommandBlockListenerAbstract { 5 | 6 | final TileEntityCommand a; 7 | 8 | TileEntityCommandListener(TileEntityCommand tileentitycommand) { 9 | this.a = tileentitycommand; 10 | sender = new org.bukkit.craftbukkit.command.CraftBlockCommandSender(this); // CraftBukkit - add sender 11 | } 12 | 13 | public ChunkCoordinates getChunkCoordinates() { 14 | return new ChunkCoordinates(this.a.x, this.a.y, this.a.z); 15 | } 16 | 17 | public World getWorld() { 18 | return this.a.getWorld(); 19 | } 20 | 21 | public void a(String s) { 22 | super.a(s); 23 | this.a.update(); 24 | } 25 | 26 | public void e() { 27 | this.a.getWorld().notify(this.a.x, this.a.y, this.a.z); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/TileEntityRecordPlayer.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class TileEntityRecordPlayer extends TileEntity { 4 | 5 | private ItemStack record; 6 | 7 | public TileEntityRecordPlayer() {} 8 | 9 | public void a(NBTTagCompound nbttagcompound) { 10 | super.a(nbttagcompound); 11 | if (nbttagcompound.hasKeyOfType("RecordItem", 10)) { 12 | this.setRecord(ItemStack.createStack(nbttagcompound.getCompound("RecordItem"))); 13 | } else if (nbttagcompound.getInt("Record") > 0) { 14 | this.setRecord(new ItemStack(Item.d(nbttagcompound.getInt("Record")), 1, 0)); 15 | } 16 | } 17 | 18 | public void b(NBTTagCompound nbttagcompound) { 19 | super.b(nbttagcompound); 20 | if (this.getRecord() != null) { 21 | nbttagcompound.set("RecordItem", this.getRecord().save(new NBTTagCompound())); 22 | nbttagcompound.setInt("Record", Item.b(this.getRecord().getItem())); 23 | } 24 | } 25 | 26 | public ItemStack getRecord() { 27 | return this.record; 28 | } 29 | 30 | public void setRecord(ItemStack itemstack) { 31 | // CraftBukkit start - There can only be one 32 | if (itemstack != null) { 33 | itemstack.count = 1; 34 | } 35 | // CraftBukkit end 36 | 37 | this.record = itemstack; 38 | this.update(); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/TileEntitySkull.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | public class TileEntitySkull extends TileEntity { 4 | 5 | private int a; 6 | private int i; 7 | private String j = ""; 8 | 9 | public TileEntitySkull() {} 10 | 11 | public void b(NBTTagCompound nbttagcompound) { 12 | super.b(nbttagcompound); 13 | nbttagcompound.setByte("SkullType", (byte) (this.a & 255)); 14 | nbttagcompound.setByte("Rot", (byte) (this.i & 255)); 15 | nbttagcompound.setString("ExtraType", this.j); 16 | } 17 | 18 | public void a(NBTTagCompound nbttagcompound) { 19 | super.a(nbttagcompound); 20 | this.a = nbttagcompound.getByte("SkullType"); 21 | this.i = nbttagcompound.getByte("Rot"); 22 | if (nbttagcompound.hasKeyOfType("ExtraType", 8)) { 23 | this.j = nbttagcompound.getString("ExtraType"); 24 | } 25 | } 26 | 27 | public Packet getUpdatePacket() { 28 | NBTTagCompound nbttagcompound = new NBTTagCompound(); 29 | 30 | this.b(nbttagcompound); 31 | return new PacketPlayOutTileEntityData(this.x, this.y, this.z, 4, nbttagcompound); 32 | } 33 | 34 | public void setSkullType(int i, String s) { 35 | this.a = i; 36 | this.j = s; 37 | } 38 | 39 | public int getSkullType() { 40 | return this.a; 41 | } 42 | 43 | public void setRotation(int i) { 44 | this.i = i; 45 | } 46 | 47 | // CraftBukkit start 48 | public int getRotation() { 49 | return this.i; 50 | } 51 | // CraftBukkit end 52 | 53 | public String getExtraType() { 54 | return this.j; 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /src/main/java/net/minecraft/server/WorldGenerator.java: -------------------------------------------------------------------------------- 1 | package net.minecraft.server; 2 | 3 | import java.util.Random; 4 | 5 | import org.bukkit.craftbukkit.CraftBlockChangeDelegate; // CraftBukkit 6 | 7 | public abstract class WorldGenerator { 8 | 9 | private final boolean a; 10 | 11 | public WorldGenerator() { 12 | this.a = false; 13 | } 14 | 15 | public WorldGenerator(boolean flag) { 16 | this.a = flag; 17 | } 18 | 19 | public abstract boolean a(World world, Random random, int i, int j, int k); 20 | 21 | public void a(double d0, double d1, double d2) {} 22 | 23 | protected void setType(World world, int i, int j, int k, Block block) { 24 | this.setTypeAndData(world, i, j, k, block, 0); 25 | } 26 | 27 | // CraftBukkit start - Duplicate method to add support for CraftBlockChangeDelegate 28 | protected void setType(CraftBlockChangeDelegate world, int i, int j, int k, Block block) { 29 | this.setTypeAndData(world, i, j, k, block, 0); 30 | } 31 | // CraftBukkit end 32 | 33 | protected void setTypeAndData(World world, int i, int j, int k, Block block, int l) { 34 | if (this.a) { 35 | world.setTypeAndData(i, j, k, block, l, 3); 36 | } else { 37 | world.setTypeAndData(i, j, k, block, l, 2); 38 | } 39 | } 40 | 41 | // CraftBukkit start - Duplicate method to add support for CraftBlockChangeDelegate 42 | protected void setTypeAndData(CraftBlockChangeDelegate world, int i, int j, int k, Block block, int l) { 43 | if (this.a) { 44 | world.setTypeAndData(i, j, k, block, l, 3); 45 | } else { 46 | world.setTypeAndData(i, j, k, block, l, 2); 47 | } 48 | } 49 | // CraftBukkit end 50 | } 51 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/CraftBlockChangeDelegate.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit; 2 | 3 | import net.minecraft.server.Block; 4 | import net.minecraft.server.World; 5 | 6 | import org.bukkit.BlockChangeDelegate; 7 | 8 | public class CraftBlockChangeDelegate { 9 | private final BlockChangeDelegate delegate; 10 | 11 | public CraftBlockChangeDelegate(BlockChangeDelegate delegate) { 12 | this.delegate = delegate; 13 | } 14 | 15 | public BlockChangeDelegate getDelegate() { 16 | return delegate; 17 | } 18 | 19 | public Block getType(int x, int y, int z) { 20 | return Block.e(this.delegate.getTypeId(x, y, z)); 21 | } 22 | 23 | public void setTypeAndData(int x, int y, int z, Block block, int data, int updateFlag) { 24 | // Layering violation :( 25 | if (delegate instanceof World) { 26 | ((World) delegate).setTypeAndData(x, y, z, block, data, 2); 27 | } else { 28 | delegate.setRawTypeIdAndData(x, y, z, Block.b(block), data); 29 | } 30 | } 31 | 32 | public boolean isEmpty(int x, int y, int z) { 33 | return delegate.isEmpty(x, y, z); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/LoggerOutputStream.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit; 2 | 3 | import java.io.ByteArrayOutputStream; 4 | import java.io.IOException; 5 | import org.apache.logging.log4j.Level; 6 | import org.apache.logging.log4j.Logger; 7 | 8 | public class LoggerOutputStream extends ByteArrayOutputStream { 9 | private final String separator = System.getProperty("line.separator"); 10 | private final Logger logger; 11 | private final Level level; 12 | 13 | public LoggerOutputStream(Logger logger, Level level) { 14 | super(); 15 | this.logger = logger; 16 | this.level = level; 17 | } 18 | 19 | @Override 20 | public void flush() throws IOException { 21 | synchronized (this) { 22 | super.flush(); 23 | String record = this.toString(); 24 | super.reset(); 25 | 26 | if ((record.length() > 0) && (!record.equals(separator))) { 27 | logger.log(level, record); 28 | } 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/Overridden.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit; 2 | 3 | import java.lang.annotation.ElementType; 4 | import java.lang.annotation.Retention; 5 | import java.lang.annotation.RetentionPolicy; 6 | import java.lang.annotation.Target; 7 | 8 | /** 9 | * Indicates a method needs to be overridden in sub classes 10 | */ 11 | @Target({ElementType.CONSTRUCTOR, ElementType.METHOD}) 12 | @Retention(RetentionPolicy.RUNTIME) 13 | public @interface Overridden { 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/block/CraftBeacon.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.block; 2 | 3 | import net.minecraft.server.TileEntityBeacon; 4 | 5 | import org.bukkit.block.Block; 6 | import org.bukkit.block.Beacon; 7 | import org.bukkit.craftbukkit.CraftWorld; 8 | import org.bukkit.craftbukkit.inventory.CraftInventoryBeacon; 9 | import org.bukkit.inventory.Inventory; 10 | 11 | public class CraftBeacon extends CraftBlockState implements Beacon { 12 | private final CraftWorld world; 13 | private final TileEntityBeacon beacon; 14 | 15 | public CraftBeacon(final Block block) { 16 | super(block); 17 | 18 | world = (CraftWorld) block.getWorld(); 19 | beacon = (TileEntityBeacon) world.getTileEntityAt(getX(), getY(), getZ()); 20 | } 21 | 22 | public Inventory getInventory() { 23 | return new CraftInventoryBeacon(beacon); 24 | } 25 | 26 | @Override 27 | public boolean update(boolean force, boolean applyPhysics) { 28 | boolean result = super.update(force, applyPhysics); 29 | 30 | if (result) { 31 | beacon.update(); 32 | } 33 | 34 | return result; 35 | } 36 | } 37 | 38 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/block/CraftBrewingStand.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.block; 2 | 3 | import net.minecraft.server.TileEntityBrewingStand; 4 | import org.bukkit.block.Block; 5 | import org.bukkit.block.BrewingStand; 6 | import org.bukkit.craftbukkit.CraftWorld; 7 | import org.bukkit.craftbukkit.inventory.CraftInventoryBrewer; 8 | import org.bukkit.inventory.BrewerInventory; 9 | 10 | public class CraftBrewingStand extends CraftBlockState implements BrewingStand { 11 | private final TileEntityBrewingStand brewingStand; 12 | 13 | public CraftBrewingStand(Block block) { 14 | super(block); 15 | 16 | brewingStand = (TileEntityBrewingStand) ((CraftWorld) block.getWorld()).getTileEntityAt(getX(), getY(), getZ()); 17 | } 18 | 19 | public BrewerInventory getInventory() { 20 | return new CraftInventoryBrewer(brewingStand); 21 | } 22 | 23 | @Override 24 | public boolean update(boolean force, boolean applyPhysics) { 25 | boolean result = super.update(force, applyPhysics); 26 | 27 | if (result) { 28 | brewingStand.update(); 29 | } 30 | 31 | return result; 32 | } 33 | 34 | public int getBrewingTime() { 35 | return brewingStand.brewTime; 36 | } 37 | 38 | public void setBrewingTime(int brewTime) { 39 | brewingStand.brewTime = brewTime; 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/block/CraftCommandBlock.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.block; 2 | 3 | import net.minecraft.server.TileEntityCommand; 4 | import org.bukkit.block.Block; 5 | import org.bukkit.block.CommandBlock; 6 | import org.bukkit.craftbukkit.CraftWorld; 7 | 8 | public class CraftCommandBlock extends CraftBlockState implements CommandBlock { 9 | private final TileEntityCommand commandBlock; 10 | private String command; 11 | private String name; 12 | 13 | public CraftCommandBlock(Block block) { 14 | super(block); 15 | 16 | CraftWorld world = (CraftWorld) block.getWorld(); 17 | commandBlock = (TileEntityCommand) world.getTileEntityAt(getX(), getY(), getZ()); 18 | command = commandBlock.a().e; 19 | name = commandBlock.a().getName(); 20 | } 21 | 22 | public String getCommand() { 23 | return command; 24 | } 25 | 26 | public void setCommand(String command) { 27 | this.command = command != null ? command : ""; 28 | } 29 | 30 | public String getName() { 31 | return name; 32 | } 33 | 34 | public void setName(String name) { 35 | this.name = name != null ? name : "@"; 36 | } 37 | 38 | public boolean update(boolean force, boolean applyPhysics) { 39 | boolean result = super.update(force, applyPhysics); 40 | 41 | if (result) { 42 | commandBlock.a().a(command); 43 | commandBlock.a().b(name); 44 | } 45 | 46 | return result; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/block/CraftDropper.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.block; 2 | 3 | import net.minecraft.server.BlockDropper; 4 | import net.minecraft.server.Blocks; 5 | import net.minecraft.server.TileEntityDropper; 6 | 7 | import org.bukkit.Material; 8 | import org.bukkit.block.Block; 9 | import org.bukkit.block.Dropper; 10 | import org.bukkit.craftbukkit.CraftWorld; 11 | import org.bukkit.craftbukkit.inventory.CraftInventory; 12 | import org.bukkit.inventory.Inventory; 13 | 14 | public class CraftDropper extends CraftBlockState implements Dropper { 15 | private final CraftWorld world; 16 | private final TileEntityDropper dropper; 17 | 18 | public CraftDropper(final Block block) { 19 | super(block); 20 | 21 | world = (CraftWorld) block.getWorld(); 22 | dropper = (TileEntityDropper) world.getTileEntityAt(getX(), getY(), getZ()); 23 | } 24 | 25 | public Inventory getInventory() { 26 | return new CraftInventory(dropper); 27 | } 28 | 29 | public void drop() { 30 | Block block = getBlock(); 31 | 32 | if (block.getType() == Material.DROPPER) { 33 | BlockDropper drop = (BlockDropper) Blocks.DROPPER; 34 | 35 | drop.dispense(world.getHandle(), getX(), getY(), getZ()); 36 | } 37 | } 38 | 39 | @Override 40 | public boolean update(boolean force, boolean applyPhysics) { 41 | boolean result = super.update(force, applyPhysics); 42 | 43 | if (result) { 44 | dropper.update(); 45 | } 46 | 47 | return result; 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/block/CraftFurnace.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.block; 2 | 3 | import net.minecraft.server.TileEntityFurnace; 4 | import org.bukkit.block.Block; 5 | import org.bukkit.block.Furnace; 6 | import org.bukkit.craftbukkit.CraftWorld; 7 | import org.bukkit.craftbukkit.inventory.CraftInventoryFurnace; 8 | import org.bukkit.inventory.FurnaceInventory; 9 | 10 | public class CraftFurnace extends CraftBlockState implements Furnace { 11 | private final TileEntityFurnace furnace; 12 | 13 | public CraftFurnace(final Block block) { 14 | super(block); 15 | 16 | furnace = (TileEntityFurnace) ((CraftWorld) block.getWorld()).getTileEntityAt(getX(), getY(), getZ()); 17 | } 18 | 19 | public FurnaceInventory getInventory() { 20 | return new CraftInventoryFurnace(furnace); 21 | } 22 | 23 | @Override 24 | public boolean update(boolean force, boolean applyPhysics) { 25 | boolean result = super.update(force, applyPhysics); 26 | 27 | if (result) { 28 | furnace.update(); 29 | } 30 | 31 | return result; 32 | } 33 | 34 | public short getBurnTime() { 35 | return (short) furnace.burnTime; 36 | } 37 | 38 | public void setBurnTime(short burnTime) { 39 | furnace.burnTime = burnTime; 40 | } 41 | 42 | public short getCookTime() { 43 | return (short) furnace.cookTime; 44 | } 45 | 46 | public void setCookTime(short cookTime) { 47 | furnace.cookTime = cookTime; 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/block/CraftHopper.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.block; 2 | 3 | import net.minecraft.server.TileEntityHopper; 4 | import org.bukkit.block.Block; 5 | import org.bukkit.block.Hopper; 6 | import org.bukkit.craftbukkit.CraftWorld; 7 | import org.bukkit.craftbukkit.inventory.CraftInventory; 8 | import org.bukkit.inventory.Inventory; 9 | 10 | public class CraftHopper extends CraftBlockState implements Hopper { 11 | private final TileEntityHopper hopper; 12 | 13 | public CraftHopper(final Block block) { 14 | super(block); 15 | 16 | hopper = (TileEntityHopper) ((CraftWorld) block.getWorld()).getTileEntityAt(getX(), getY(), getZ()); 17 | } 18 | 19 | public Inventory getInventory() { 20 | return new CraftInventory(hopper); 21 | } 22 | 23 | @Override 24 | public boolean update(boolean force, boolean applyPhysics) { 25 | boolean result = super.update(force, applyPhysics); 26 | 27 | if (result) { 28 | hopper.update(); 29 | } 30 | 31 | return result; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/block/CraftSign.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.block; 2 | 3 | import net.minecraft.server.TileEntitySign; 4 | import org.bukkit.block.Block; 5 | import org.bukkit.block.Sign; 6 | import org.bukkit.craftbukkit.CraftWorld; 7 | 8 | public class CraftSign extends CraftBlockState implements Sign { 9 | private final TileEntitySign sign; 10 | private final String[] lines; 11 | 12 | public CraftSign(final Block block) { 13 | super(block); 14 | 15 | CraftWorld world = (CraftWorld) block.getWorld(); 16 | sign = (TileEntitySign) world.getTileEntityAt(getX(), getY(), getZ()); 17 | lines = new String[sign.lines.length]; 18 | System.arraycopy(sign.lines, 0, lines, 0, lines.length); 19 | } 20 | 21 | public String[] getLines() { 22 | return lines; 23 | } 24 | 25 | public String getLine(int index) throws IndexOutOfBoundsException { 26 | return lines[index]; 27 | } 28 | 29 | public void setLine(int index, String line) throws IndexOutOfBoundsException { 30 | lines[index] = line; 31 | } 32 | 33 | @Override 34 | public boolean update(boolean force, boolean applyPhysics) { 35 | boolean result = super.update(force, applyPhysics); 36 | 37 | if (result) { 38 | for(int i = 0; i < 4; i++) { 39 | if(lines[i] != null) { 40 | sign.lines[i] = lines[i]; 41 | } else { 42 | sign.lines[i] = ""; 43 | } 44 | } 45 | sign.update(); 46 | } 47 | 48 | return result; 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/chunkio/ChunkIOExecutor.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.chunkio; 2 | 3 | import net.minecraft.server.Chunk; 4 | import net.minecraft.server.ChunkProviderServer; 5 | import net.minecraft.server.ChunkRegionLoader; 6 | import net.minecraft.server.World; 7 | import org.bukkit.craftbukkit.util.AsynchronousExecutor; 8 | 9 | public class ChunkIOExecutor { 10 | //static final int BASE_THREADS = 1; 11 | static final int BASE_THREADS = 2; // Poweruser 12 | static final int PLAYERS_PER_THREAD = 50; 13 | static final Object lockObject = new Object(); // Poweruser 14 | 15 | private static final AsynchronousExecutor instance = new AsynchronousExecutor(new ChunkIOProvider(), BASE_THREADS); 16 | 17 | public static Chunk syncChunkLoad(World world, ChunkRegionLoader loader, ChunkProviderServer provider, int x, int z) { 18 | synchronized(lockObject) { // Poweruser - MinetickMod got several world threads that call these methods 19 | return instance.getSkipQueue(new QueuedChunk(x, z, loader, world, provider)); 20 | } 21 | } 22 | 23 | public static void queueChunkLoad(World world, ChunkRegionLoader loader, ChunkProviderServer provider, int x, int z, Runnable runnable) { 24 | synchronized(lockObject) { // Poweruser - MinetickMod got several world threads that call these methods 25 | instance.add(new QueuedChunk(x, z, loader, world, provider), runnable); 26 | } 27 | } 28 | 29 | public static void adjustPoolSize(int players) { 30 | int size = Math.max(BASE_THREADS, (int) Math.ceil(players / PLAYERS_PER_THREAD)); 31 | instance.setActiveThreads(size); 32 | } 33 | 34 | public static void tick() { 35 | instance.finishActive(); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/chunkio/QueuedChunk.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.chunkio; 2 | 3 | import net.minecraft.server.ChunkProviderServer; 4 | import net.minecraft.server.ChunkRegionLoader; 5 | import net.minecraft.server.NBTTagCompound; 6 | import net.minecraft.server.World; 7 | 8 | class QueuedChunk { 9 | final int x; 10 | final int z; 11 | final ChunkRegionLoader loader; 12 | final World world; 13 | final ChunkProviderServer provider; 14 | NBTTagCompound compound; 15 | 16 | public QueuedChunk(int x, int z, ChunkRegionLoader loader, World world, ChunkProviderServer provider) { 17 | this.x = x; 18 | this.z = z; 19 | this.loader = loader; 20 | this.world = world; 21 | this.provider = provider; 22 | } 23 | 24 | @Override 25 | public int hashCode() { 26 | return (x * 31 + z * 29) ^ world.hashCode(); 27 | } 28 | 29 | @Override 30 | public boolean equals(Object object) { 31 | if (object instanceof QueuedChunk) { 32 | QueuedChunk other = (QueuedChunk) object; 33 | return x == other.x && z == other.z && world == other.world; 34 | } 35 | 36 | return false; 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.command; 2 | 3 | import java.util.List; 4 | import java.util.concurrent.ExecutionException; 5 | import java.util.logging.Level; 6 | 7 | import org.bukkit.craftbukkit.CraftServer; 8 | import org.bukkit.craftbukkit.util.Waitable; 9 | 10 | import jline.console.completer.Completer; 11 | 12 | public class ConsoleCommandCompleter implements Completer { 13 | private final CraftServer server; 14 | 15 | public ConsoleCommandCompleter(CraftServer server) { 16 | this.server = server; 17 | } 18 | 19 | public int complete(final String buffer, final int cursor, final List candidates) { 20 | Waitable> waitable = new Waitable>() { 21 | @Override 22 | protected List evaluate() { 23 | return server.getCommandMap().tabComplete(server.getConsoleSender(), buffer); 24 | } 25 | }; 26 | this.server.getServer().processQueue.add(waitable); 27 | try { 28 | List offers = waitable.get(); 29 | if (offers == null) { 30 | return cursor; 31 | } 32 | candidates.addAll(offers); 33 | 34 | final int lastSpace = buffer.lastIndexOf(' '); 35 | if (lastSpace == -1) { 36 | return cursor - buffer.length(); 37 | } else { 38 | return cursor - (buffer.length() - lastSpace - 1); 39 | } 40 | } catch (ExecutionException e) { 41 | this.server.getLogger().log(Level.WARNING, "Unhandled exception when tab completing", e); 42 | } catch (InterruptedException e) { 43 | Thread.currentThread().interrupt(); 44 | } 45 | return cursor; 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/command/CraftBlockCommandSender.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.command; 2 | 3 | import net.minecraft.server.ICommandListener; 4 | import net.minecraft.server.TileEntityCommandListener; 5 | 6 | import org.bukkit.block.Block; 7 | import org.bukkit.command.BlockCommandSender; 8 | 9 | /** 10 | * Represents input from a command block 11 | */ 12 | public class CraftBlockCommandSender extends ServerCommandSender implements BlockCommandSender { 13 | private final TileEntityCommandListener commandBlock; 14 | 15 | public CraftBlockCommandSender(TileEntityCommandListener commandBlockListenerAbstract) { 16 | super(); 17 | this.commandBlock = commandBlockListenerAbstract; 18 | } 19 | 20 | public Block getBlock() { 21 | return commandBlock.getWorld().getWorld().getBlockAt(commandBlock.getChunkCoordinates().x, commandBlock.getChunkCoordinates().y, commandBlock.getChunkCoordinates().z); 22 | } 23 | 24 | public void sendMessage(String message) { 25 | } 26 | 27 | public void sendMessage(String[] messages) { 28 | } 29 | 30 | public String getName() { 31 | return commandBlock.getName(); 32 | } 33 | 34 | public boolean isOp() { 35 | return true; 36 | } 37 | 38 | public void setOp(boolean value) { 39 | throw new UnsupportedOperationException("Cannot change operator status of a block"); 40 | } 41 | 42 | public ICommandListener getTileEntity() { 43 | return commandBlock; 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.command; 2 | 3 | import net.minecraft.server.RemoteControlCommandListener; 4 | import org.bukkit.command.RemoteConsoleCommandSender; 5 | 6 | public class CraftRemoteConsoleCommandSender extends ServerCommandSender implements RemoteConsoleCommandSender { 7 | public CraftRemoteConsoleCommandSender() { 8 | super(); 9 | } 10 | 11 | @Override 12 | public void sendMessage(String message) { 13 | RemoteControlCommandListener.instance.sendMessage(message + "\n"); // Send a newline after each message, to preserve formatting. 14 | } 15 | 16 | @Override 17 | public void sendMessage(String[] messages) { 18 | for (String message : messages) { 19 | sendMessage(message); 20 | } 21 | } 22 | 23 | @Override 24 | public String getName() { 25 | return "Rcon"; 26 | } 27 | 28 | @Override 29 | public boolean isOp() { 30 | return true; 31 | } 32 | 33 | @Override 34 | public void setOp(boolean value) { 35 | throw new UnsupportedOperationException("Cannot change operator status of remote controller."); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/AbstractProjectile.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import org.bukkit.craftbukkit.CraftServer; 4 | import org.bukkit.entity.Projectile; 5 | 6 | public abstract class AbstractProjectile extends CraftEntity implements Projectile { 7 | 8 | private boolean doesBounce; 9 | 10 | public AbstractProjectile(CraftServer server, net.minecraft.server.Entity entity) { 11 | super(server, entity); 12 | doesBounce = false; 13 | } 14 | 15 | public boolean doesBounce() { 16 | return doesBounce; 17 | } 18 | 19 | public void setBounce(boolean doesBounce) { 20 | this.doesBounce = doesBounce; 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftAgeable.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityAgeable; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.Ageable; 7 | 8 | public class CraftAgeable extends CraftCreature implements Ageable { 9 | public CraftAgeable(CraftServer server, EntityAgeable entity) { 10 | super(server, entity); 11 | } 12 | 13 | public int getAge() { 14 | return getHandle().getAge(); 15 | } 16 | 17 | public void setAge(int age) { 18 | getHandle().setAge(age); 19 | } 20 | 21 | public void setAgeLock(boolean lock) { 22 | getHandle().ageLocked = lock; 23 | } 24 | 25 | public boolean getAgeLock() { 26 | return getHandle().ageLocked; 27 | } 28 | 29 | public void setBaby() { 30 | if (isAdult()) { 31 | setAge(-24000); 32 | } 33 | } 34 | 35 | public void setAdult() { 36 | if (!isAdult()) { 37 | setAge(0); 38 | } 39 | } 40 | 41 | public boolean isAdult() { 42 | return getAge() >= 0; 43 | } 44 | 45 | 46 | public boolean canBreed() { 47 | return getAge() == 0; 48 | } 49 | 50 | public void setBreed(boolean breed) { 51 | if (breed) { 52 | setAge(0); 53 | } else if (isAdult()) { 54 | setAge(6000); 55 | } 56 | } 57 | 58 | @Override 59 | public EntityAgeable getHandle() { 60 | return (EntityAgeable) entity; 61 | } 62 | 63 | @Override 64 | public String toString() { 65 | return "CraftAgeable"; 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftAmbient.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityAmbient; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.Ambient; 6 | import org.bukkit.entity.EntityType; 7 | 8 | public class CraftAmbient extends CraftLivingEntity implements Ambient { 9 | public CraftAmbient(CraftServer server, EntityAmbient entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntityAmbient getHandle() { 15 | return (EntityAmbient) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftAmbient"; 21 | } 22 | 23 | public EntityType getType() { 24 | return EntityType.UNKNOWN; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftAnimals.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityAnimal; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.Animals; 6 | 7 | public class CraftAnimals extends CraftAgeable implements Animals { 8 | 9 | public CraftAnimals(CraftServer server, EntityAnimal entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntityAnimal getHandle() { 15 | return (EntityAnimal) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftAnimals"; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftBat.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityBat; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.Bat; 6 | import org.bukkit.entity.EntityType; 7 | 8 | public class CraftBat extends CraftAmbient implements Bat { 9 | public CraftBat(CraftServer server, EntityBat entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntityBat getHandle() { 15 | return (EntityBat) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftBat"; 21 | } 22 | 23 | public EntityType getType() { 24 | return EntityType.BAT; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftBlaze.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityBlaze; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.Blaze; 7 | import org.bukkit.entity.EntityType; 8 | 9 | public class CraftBlaze extends CraftMonster implements Blaze { 10 | public CraftBlaze(CraftServer server, EntityBlaze entity) { 11 | super(server, entity); 12 | } 13 | 14 | @Override 15 | public EntityBlaze getHandle() { 16 | return (EntityBlaze) entity; 17 | } 18 | 19 | @Override 20 | public String toString() { 21 | return "CraftBlaze"; 22 | } 23 | 24 | public EntityType getType() { 25 | return EntityType.BLAZE; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftBoat.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityBoat; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.Boat; 6 | import org.bukkit.entity.EntityType; 7 | 8 | public class CraftBoat extends CraftVehicle implements Boat { 9 | 10 | public CraftBoat(CraftServer server, EntityBoat entity) { 11 | super(server, entity); 12 | } 13 | 14 | public double getMaxSpeed() { 15 | return getHandle().maxSpeed; 16 | } 17 | 18 | public void setMaxSpeed(double speed) { 19 | if (speed >= 0D) { 20 | getHandle().maxSpeed = speed; 21 | } 22 | } 23 | 24 | public double getOccupiedDeceleration() { 25 | return getHandle().occupiedDeceleration; 26 | } 27 | 28 | public void setOccupiedDeceleration(double speed) { 29 | if (speed >= 0D) { 30 | getHandle().occupiedDeceleration = speed; 31 | } 32 | } 33 | 34 | public double getUnoccupiedDeceleration() { 35 | return getHandle().unoccupiedDeceleration; 36 | } 37 | 38 | public void setUnoccupiedDeceleration(double speed) { 39 | getHandle().unoccupiedDeceleration = speed; 40 | } 41 | 42 | public boolean getWorkOnLand() { 43 | return getHandle().landBoats; 44 | } 45 | 46 | public void setWorkOnLand(boolean workOnLand) { 47 | getHandle().landBoats = workOnLand; 48 | } 49 | 50 | @Override 51 | public EntityBoat getHandle() { 52 | return (EntityBoat) entity; 53 | } 54 | 55 | @Override 56 | public String toString() { 57 | return "CraftBoat"; 58 | } 59 | 60 | public EntityType getType() { 61 | return EntityType.BOAT; 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftCaveSpider.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityCaveSpider; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.CaveSpider; 7 | import org.bukkit.entity.EntityType; 8 | 9 | public class CraftCaveSpider extends CraftSpider implements CaveSpider { 10 | public CraftCaveSpider(CraftServer server, EntityCaveSpider entity) { 11 | super(server, entity); 12 | } 13 | 14 | @Override 15 | public EntityCaveSpider getHandle() { 16 | return (EntityCaveSpider) entity; 17 | } 18 | 19 | @Override 20 | public String toString() { 21 | return "CraftCaveSpider"; 22 | } 23 | 24 | public EntityType getType() { 25 | return EntityType.CAVE_SPIDER; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftChicken.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityChicken; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.Chicken; 7 | import org.bukkit.entity.EntityType; 8 | 9 | public class CraftChicken extends CraftAnimals implements Chicken { 10 | 11 | public CraftChicken(CraftServer server, EntityChicken entity) { 12 | super(server, entity); 13 | } 14 | 15 | @Override 16 | public EntityChicken getHandle() { 17 | return (EntityChicken) entity; 18 | } 19 | 20 | @Override 21 | public String toString() { 22 | return "CraftChicken"; 23 | } 24 | 25 | public EntityType getType() { 26 | return EntityType.CHICKEN; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftComplexLivingEntity.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityLiving; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.ComplexLivingEntity; 6 | 7 | public abstract class CraftComplexLivingEntity extends CraftLivingEntity implements ComplexLivingEntity { 8 | public CraftComplexLivingEntity(CraftServer server, EntityLiving entity) { 9 | super(server, entity); 10 | } 11 | 12 | @Override 13 | public EntityLiving getHandle() { 14 | return (EntityLiving) entity; 15 | } 16 | 17 | @Override 18 | public String toString() { 19 | return "CraftComplexLivingEntity"; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftComplexPart.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityComplexPart; 4 | import net.minecraft.server.EntityEnderDragon; 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.ComplexEntityPart; 7 | import org.bukkit.entity.ComplexLivingEntity; 8 | import org.bukkit.entity.EntityType; 9 | import org.bukkit.event.entity.EntityDamageEvent; 10 | 11 | public class CraftComplexPart extends CraftEntity implements ComplexEntityPart { 12 | public CraftComplexPart(CraftServer server, EntityComplexPart entity) { 13 | super(server, entity); 14 | } 15 | 16 | public ComplexLivingEntity getParent() { 17 | return (ComplexLivingEntity) ((EntityEnderDragon) getHandle().owner).getBukkitEntity(); 18 | } 19 | 20 | @Override 21 | public void setLastDamageCause(EntityDamageEvent cause) { 22 | getParent().setLastDamageCause(cause); 23 | } 24 | 25 | @Override 26 | public EntityDamageEvent getLastDamageCause() { 27 | return getParent().getLastDamageCause(); 28 | } 29 | 30 | @Override 31 | public EntityComplexPart getHandle() { 32 | return (EntityComplexPart) entity; 33 | } 34 | 35 | @Override 36 | public String toString() { 37 | return "CraftComplexPart"; 38 | } 39 | 40 | public EntityType getType() { 41 | return EntityType.COMPLEX_PART; 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftCow.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityCow; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.Cow; 7 | import org.bukkit.entity.EntityType; 8 | 9 | public class CraftCow extends CraftAnimals implements Cow { 10 | 11 | public CraftCow(CraftServer server, EntityCow entity) { 12 | super(server, entity); 13 | } 14 | 15 | @Override 16 | public EntityCow getHandle() { 17 | return (EntityCow) entity; 18 | } 19 | 20 | @Override 21 | public String toString() { 22 | return "CraftCow"; 23 | } 24 | 25 | public EntityType getType() { 26 | return EntityType.COW; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftCreature.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityCreature; 4 | import net.minecraft.server.EntityLiving; 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.Creature; 7 | import org.bukkit.entity.LivingEntity; 8 | 9 | public class CraftCreature extends CraftLivingEntity implements Creature { 10 | public CraftCreature(CraftServer server, EntityCreature entity) { 11 | super(server, entity); 12 | } 13 | 14 | public void setTarget(LivingEntity target) { 15 | EntityCreature entity = getHandle(); 16 | if (target == null) { 17 | entity.target = null; 18 | entity.setGoalTarget(null); 19 | } else if (target instanceof CraftLivingEntity) { 20 | entity.target = ((CraftLivingEntity) target).getHandle(); 21 | entity.pathEntity = entity.world.findPath(entity, entity.target, 16.0F, true, false, false, true); 22 | entity.setGoalTarget(((CraftLivingEntity) target).getHandle()); 23 | } 24 | } 25 | 26 | public CraftLivingEntity getTarget() { 27 | if (getHandle().target == null) return null; 28 | if (!(getHandle().target instanceof EntityLiving)) return null; 29 | 30 | return (CraftLivingEntity) getHandle().target.getBukkitEntity(); 31 | } 32 | 33 | @Override 34 | public EntityCreature getHandle() { 35 | return (EntityCreature) entity; 36 | } 37 | 38 | @Override 39 | public String toString() { 40 | return "CraftCreature"; 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityCreeper; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.Creeper; 7 | import org.bukkit.entity.EntityType; 8 | import org.bukkit.event.entity.CreeperPowerEvent; 9 | 10 | public class CraftCreeper extends CraftMonster implements Creeper { 11 | 12 | public CraftCreeper(CraftServer server, EntityCreeper entity) { 13 | super(server, entity); 14 | } 15 | 16 | public boolean isPowered() { 17 | return getHandle().isPowered(); 18 | } 19 | 20 | public void setPowered(boolean powered) { 21 | CraftServer server = this.server; 22 | Creeper entity = (Creeper) this.getHandle().getBukkitEntity(); 23 | 24 | if (powered) { 25 | CreeperPowerEvent event = new CreeperPowerEvent(entity, CreeperPowerEvent.PowerCause.SET_ON); 26 | server.getPluginManager().callEvent(event); 27 | 28 | if (!event.isCancelled()) { 29 | getHandle().setPowered(true); 30 | } 31 | } else { 32 | CreeperPowerEvent event = new CreeperPowerEvent(entity, CreeperPowerEvent.PowerCause.SET_OFF); 33 | server.getPluginManager().callEvent(event); 34 | 35 | if (!event.isCancelled()) { 36 | getHandle().setPowered(false); 37 | } 38 | } 39 | } 40 | 41 | @Override 42 | public EntityCreeper getHandle() { 43 | return (EntityCreeper) entity; 44 | } 45 | 46 | @Override 47 | public String toString() { 48 | return "CraftCreeper"; 49 | } 50 | 51 | public EntityType getType() { 52 | return EntityType.CREEPER; 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftEgg.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityEgg; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.Egg; 6 | import org.bukkit.entity.EntityType; 7 | 8 | public class CraftEgg extends CraftProjectile implements Egg { 9 | public CraftEgg(CraftServer server, EntityEgg entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntityEgg getHandle() { 15 | return (EntityEgg) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftEgg"; 21 | } 22 | 23 | public EntityType getType() { 24 | return EntityType.EGG; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftEnderCrystal.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityEnderCrystal; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.EnderCrystal; 6 | import org.bukkit.entity.EntityType; 7 | 8 | public class CraftEnderCrystal extends CraftEntity implements EnderCrystal { 9 | public CraftEnderCrystal(CraftServer server, EntityEnderCrystal entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntityEnderCrystal getHandle() { 15 | return (EntityEnderCrystal) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftEnderCrystal"; 21 | } 22 | 23 | public EntityType getType() { 24 | return EntityType.ENDER_CRYSTAL; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftEnderDragon.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import com.google.common.collect.ImmutableSet; 4 | import com.google.common.collect.ImmutableSet.Builder; 5 | 6 | import java.util.Set; 7 | 8 | import net.minecraft.server.EntityComplexPart; 9 | import net.minecraft.server.EntityEnderDragon; 10 | 11 | import org.bukkit.craftbukkit.CraftServer; 12 | import org.bukkit.entity.ComplexEntityPart; 13 | import org.bukkit.entity.EnderDragon; 14 | import org.bukkit.entity.EntityType; 15 | 16 | public class CraftEnderDragon extends CraftComplexLivingEntity implements EnderDragon { 17 | public CraftEnderDragon(CraftServer server, EntityEnderDragon entity) { 18 | super(server, entity); 19 | } 20 | 21 | public Set getParts() { 22 | Builder builder = ImmutableSet.builder(); 23 | 24 | for (EntityComplexPart part : getHandle().children) { 25 | builder.add((ComplexEntityPart) part.getBukkitEntity()); 26 | } 27 | 28 | return builder.build(); 29 | } 30 | 31 | @Override 32 | public EntityEnderDragon getHandle() { 33 | return (EntityEnderDragon) entity; 34 | } 35 | 36 | @Override 37 | public String toString() { 38 | return "CraftEnderDragon"; 39 | } 40 | 41 | public EntityType getType() { 42 | return EntityType.ENDER_DRAGON; 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftEnderPearl.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityEnderPearl; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.EnderPearl; 6 | import org.bukkit.entity.EntityType; 7 | 8 | public class CraftEnderPearl extends CraftProjectile implements EnderPearl { 9 | public CraftEnderPearl(CraftServer server, EntityEnderPearl entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntityEnderPearl getHandle() { 15 | return (EntityEnderPearl) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftEnderPearl"; 21 | } 22 | 23 | public EntityType getType() { 24 | return EntityType.ENDER_PEARL; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftEnderSignal.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityEnderSignal; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.EnderSignal; 6 | import org.bukkit.entity.EntityType; 7 | 8 | public class CraftEnderSignal extends CraftEntity implements EnderSignal { 9 | public CraftEnderSignal(CraftServer server, EntityEnderSignal entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntityEnderSignal getHandle() { 15 | return (EntityEnderSignal) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftEnderSignal"; 21 | } 22 | 23 | public EntityType getType() { 24 | return EntityType.ENDER_SIGNAL; 25 | } 26 | } -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftEnderman.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityEnderman; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.craftbukkit.util.CraftMagicNumbers; 7 | import org.bukkit.entity.Enderman; 8 | import org.bukkit.entity.EntityType; 9 | import org.bukkit.material.MaterialData; 10 | 11 | public class CraftEnderman extends CraftMonster implements Enderman { 12 | public CraftEnderman(CraftServer server, EntityEnderman entity) { 13 | super(server, entity); 14 | } 15 | 16 | public MaterialData getCarriedMaterial() { 17 | return CraftMagicNumbers.getMaterial(getHandle().getCarried()).getNewData((byte) getHandle().getCarriedData()); 18 | } 19 | 20 | public void setCarriedMaterial(MaterialData data) { 21 | getHandle().setCarried(CraftMagicNumbers.getBlock(data.getItemTypeId())); 22 | getHandle().setCarriedData(data.getData()); 23 | } 24 | 25 | @Override 26 | public EntityEnderman getHandle() { 27 | return (EntityEnderman) entity; 28 | } 29 | 30 | @Override 31 | public String toString() { 32 | return "CraftEnderman"; 33 | } 34 | 35 | public EntityType getType() { 36 | return EntityType.ENDERMAN; 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityExperienceOrb; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.EntityType; 6 | import org.bukkit.entity.ExperienceOrb; 7 | 8 | public class CraftExperienceOrb extends CraftEntity implements ExperienceOrb { 9 | public CraftExperienceOrb(CraftServer server, EntityExperienceOrb entity) { 10 | super(server, entity); 11 | } 12 | 13 | public int getExperience() { 14 | return getHandle().value; 15 | } 16 | 17 | public void setExperience(int value) { 18 | getHandle().value = value; 19 | } 20 | 21 | @Override 22 | public EntityExperienceOrb getHandle() { 23 | return (EntityExperienceOrb) entity; 24 | } 25 | 26 | @Override 27 | public String toString() { 28 | return "CraftExperienceOrb"; 29 | } 30 | 31 | public EntityType getType() { 32 | return EntityType.EXPERIENCE_ORB; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftFallingSand.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityFallingBlock; 4 | 5 | import org.bukkit.Material; 6 | import org.bukkit.craftbukkit.CraftServer; 7 | import org.bukkit.craftbukkit.util.CraftMagicNumbers; 8 | import org.bukkit.entity.EntityType; 9 | import org.bukkit.entity.FallingSand; 10 | 11 | public class CraftFallingSand extends CraftEntity implements FallingSand { 12 | 13 | public CraftFallingSand(CraftServer server, EntityFallingBlock entity) { 14 | super(server, entity); 15 | } 16 | 17 | @Override 18 | public EntityFallingBlock getHandle() { 19 | return (EntityFallingBlock) entity; 20 | } 21 | 22 | @Override 23 | public String toString() { 24 | return "CraftFallingSand"; 25 | } 26 | 27 | public EntityType getType() { 28 | return EntityType.FALLING_BLOCK; 29 | } 30 | 31 | public Material getMaterial() { 32 | return Material.getMaterial(getBlockId()); 33 | } 34 | 35 | public int getBlockId() { 36 | return CraftMagicNumbers.getId(getHandle().id); 37 | } 38 | 39 | public byte getBlockData() { 40 | return (byte) getHandle().data; 41 | } 42 | 43 | public boolean getDropItem() { 44 | return getHandle().dropItem; 45 | } 46 | 47 | public void setDropItem(boolean drop) { 48 | getHandle().dropItem = drop; 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftFlying.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityFlying; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.Flying; 6 | 7 | public class CraftFlying extends CraftLivingEntity implements Flying { 8 | 9 | public CraftFlying(CraftServer server, EntityFlying entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntityFlying getHandle() { 15 | return (EntityFlying) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftFlying"; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftGhast.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityGhast; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.Ghast; 8 | 9 | public class CraftGhast extends CraftFlying implements Ghast { 10 | 11 | public CraftGhast(CraftServer server, EntityGhast entity) { 12 | super(server, entity); 13 | } 14 | 15 | @Override 16 | public EntityGhast getHandle() { 17 | return (EntityGhast) entity; 18 | } 19 | 20 | @Override 21 | public String toString() { 22 | return "CraftGhast"; 23 | } 24 | 25 | public EntityType getType() { 26 | return EntityType.GHAST; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftGiant.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityGiantZombie; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.Giant; 8 | 9 | public class CraftGiant extends CraftMonster implements Giant { 10 | 11 | public CraftGiant(CraftServer server, EntityGiantZombie entity) { 12 | super(server, entity); 13 | } 14 | 15 | @Override 16 | public EntityGiantZombie getHandle() { 17 | return (EntityGiantZombie) entity; 18 | } 19 | 20 | @Override 21 | public String toString() { 22 | return "CraftGiant"; 23 | } 24 | 25 | public EntityType getType() { 26 | return EntityType.GIANT; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftGolem.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityGolem; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.Golem; 6 | 7 | public class CraftGolem extends CraftCreature implements Golem { 8 | public CraftGolem(CraftServer server, EntityGolem entity) { 9 | super(server, entity); 10 | } 11 | 12 | @Override 13 | public EntityGolem getHandle() { 14 | return (EntityGolem) entity; 15 | } 16 | 17 | @Override 18 | public String toString() { 19 | return "CraftGolem"; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftIronGolem.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityIronGolem; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.EntityType; 6 | import org.bukkit.entity.IronGolem; 7 | 8 | public class CraftIronGolem extends CraftGolem implements IronGolem { 9 | public CraftIronGolem(CraftServer server, EntityIronGolem entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntityIronGolem getHandle() { 15 | return (EntityIronGolem) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftIronGolem"; 21 | } 22 | 23 | public boolean isPlayerCreated() { 24 | return getHandle().isPlayerCreated(); 25 | } 26 | 27 | public void setPlayerCreated(boolean playerCreated) { 28 | getHandle().setPlayerCreated(playerCreated); 29 | } 30 | 31 | @Override 32 | public EntityType getType() { 33 | return EntityType.IRON_GOLEM; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.Entity; 4 | import net.minecraft.server.EntityItem; 5 | 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.Item; 8 | import org.bukkit.inventory.ItemStack; 9 | import org.bukkit.craftbukkit.inventory.CraftItemStack; 10 | import org.bukkit.craftbukkit.CraftServer; 11 | 12 | public class CraftItem extends CraftEntity implements Item { 13 | private final EntityItem item; 14 | 15 | public CraftItem(CraftServer server, Entity entity, EntityItem item) { 16 | super(server, entity); 17 | this.item = item; 18 | } 19 | 20 | public CraftItem(CraftServer server, EntityItem entity) { 21 | this(server, entity, entity); 22 | } 23 | 24 | public ItemStack getItemStack() { 25 | return CraftItemStack.asCraftMirror(item.getItemStack()); 26 | } 27 | 28 | public void setItemStack(ItemStack stack) { 29 | item.setItemStack(CraftItemStack.asNMSCopy(stack)); 30 | } 31 | 32 | public int getPickupDelay() { 33 | return item.pickupDelay; 34 | } 35 | 36 | public void setPickupDelay(int delay) { 37 | item.pickupDelay = delay; 38 | } 39 | 40 | @Override 41 | public String toString() { 42 | return "CraftItem"; 43 | } 44 | 45 | public EntityType getType() { 46 | return EntityType.DROPPED_ITEM; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftLargeFireball.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityLargeFireball; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.EntityType; 6 | import org.bukkit.entity.LargeFireball; 7 | 8 | public class CraftLargeFireball extends CraftFireball implements LargeFireball { 9 | public CraftLargeFireball(CraftServer server, EntityLargeFireball entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public void setYield(float yield) { 15 | super.setYield(yield); 16 | getHandle().yield = (int) yield; 17 | } 18 | 19 | @Override 20 | public EntityLargeFireball getHandle() { 21 | return (EntityLargeFireball) entity; 22 | } 23 | 24 | @Override 25 | public String toString() { 26 | return "CraftLargeFireball"; 27 | } 28 | 29 | public EntityType getType() { 30 | return EntityType.FIREBALL; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftLeash.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityLeash; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.LeashHitch; 8 | 9 | public class CraftLeash extends CraftHanging implements LeashHitch { 10 | public CraftLeash(CraftServer server, EntityLeash entity) { 11 | super(server, entity); 12 | } 13 | 14 | @Override 15 | public EntityLeash getHandle() { 16 | return (EntityLeash) entity; 17 | } 18 | 19 | @Override 20 | public String toString() { 21 | return "CraftLeash"; 22 | } 23 | 24 | public EntityType getType() { 25 | return EntityType.LEASH_HITCH; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftLightningStrike.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityLightning; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.EntityType; 6 | import org.bukkit.entity.LightningStrike; 7 | 8 | public class CraftLightningStrike extends CraftEntity implements LightningStrike { 9 | public CraftLightningStrike(final CraftServer server, final EntityLightning entity) { 10 | super(server, entity); 11 | } 12 | 13 | public boolean isEffect() { 14 | return ((EntityLightning) super.getHandle()).isEffect; 15 | } 16 | 17 | @Override 18 | public EntityLightning getHandle() { 19 | return (EntityLightning) entity; 20 | } 21 | 22 | @Override 23 | public String toString() { 24 | return "CraftLightningStrike"; 25 | } 26 | 27 | public EntityType getType() { 28 | return EntityType.LIGHTNING; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftMagmaCube.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityMagmaCube; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.MagmaCube; 8 | 9 | public class CraftMagmaCube extends CraftSlime implements MagmaCube { 10 | 11 | public CraftMagmaCube(CraftServer server, EntityMagmaCube entity) { 12 | super(server, entity); 13 | } 14 | 15 | public EntityMagmaCube getHandle() { 16 | return (EntityMagmaCube) entity; 17 | } 18 | 19 | @Override 20 | public String toString() { 21 | return "CraftMagmaCube"; 22 | } 23 | 24 | public EntityType getType() { 25 | return EntityType.MAGMA_CUBE; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartChest.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityMinecartChest; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.craftbukkit.inventory.CraftInventory; 7 | import org.bukkit.entity.EntityType; 8 | import org.bukkit.entity.StorageMinecart; 9 | import org.bukkit.inventory.Inventory; 10 | 11 | @SuppressWarnings("deprecation") 12 | public class CraftMinecartChest extends CraftMinecart implements StorageMinecart { 13 | private final CraftInventory inventory; 14 | 15 | public CraftMinecartChest(CraftServer server, EntityMinecartChest entity) { 16 | super(server, entity); 17 | inventory = new CraftInventory(entity); 18 | } 19 | 20 | public Inventory getInventory() { 21 | return inventory; 22 | } 23 | 24 | @Override 25 | public String toString() { 26 | return "CraftMinecartChest{" + "inventory=" + inventory + '}'; 27 | } 28 | 29 | public EntityType getType() { 30 | return EntityType.MINECART_CHEST; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartFurnace.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityMinecartFurnace; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.PoweredMinecart; 8 | 9 | @SuppressWarnings("deprecation") 10 | public class CraftMinecartFurnace extends CraftMinecart implements PoweredMinecart { 11 | public CraftMinecartFurnace(CraftServer server, EntityMinecartFurnace entity) { 12 | super(server, entity); 13 | } 14 | 15 | @Override 16 | public String toString() { 17 | return "CraftMinecartFurnace"; 18 | } 19 | 20 | public EntityType getType() { 21 | return EntityType.MINECART_FURNACE; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartHopper.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityMinecartHopper; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.craftbukkit.inventory.CraftInventory; 7 | import org.bukkit.entity.EntityType; 8 | import org.bukkit.entity.minecart.HopperMinecart; 9 | import org.bukkit.inventory.Inventory; 10 | 11 | final class CraftMinecartHopper extends CraftMinecart implements HopperMinecart { 12 | private final CraftInventory inventory; 13 | 14 | CraftMinecartHopper(CraftServer server, EntityMinecartHopper entity) { 15 | super(server, entity); 16 | inventory = new CraftInventory(entity); 17 | } 18 | 19 | @Override 20 | public String toString() { 21 | return "CraftMinecartHopper{" + "inventory=" + inventory + '}'; 22 | } 23 | 24 | public EntityType getType() { 25 | return EntityType.MINECART_HOPPER; 26 | } 27 | 28 | public Inventory getInventory() { 29 | return inventory; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartMobSpawner.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityMinecartMobSpawner; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.minecart.SpawnerMinecart; 8 | 9 | final class CraftMinecartMobSpawner extends CraftMinecart implements SpawnerMinecart { 10 | CraftMinecartMobSpawner(CraftServer server, EntityMinecartMobSpawner entity) { 11 | super(server, entity); 12 | } 13 | 14 | @Override 15 | public String toString() { 16 | return "CraftMinecartMobSpawner"; 17 | } 18 | 19 | public EntityType getType() { 20 | return EntityType.MINECART_MOB_SPAWNER; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartRideable.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityMinecartAbstract; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.minecart.RideableMinecart; 8 | 9 | public class CraftMinecartRideable extends CraftMinecart implements RideableMinecart { 10 | public CraftMinecartRideable(CraftServer server, EntityMinecartAbstract entity) { 11 | super(server, entity); 12 | } 13 | 14 | @Override 15 | public String toString() { 16 | return "CraftMinecartRideable"; 17 | } 18 | 19 | public EntityType getType() { 20 | return EntityType.MINECART; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartTNT.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityMinecartTNT; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.minecart.ExplosiveMinecart; 8 | 9 | final class CraftMinecartTNT extends CraftMinecart implements ExplosiveMinecart { 10 | CraftMinecartTNT(CraftServer server, EntityMinecartTNT entity) { 11 | super(server, entity); 12 | } 13 | 14 | @Override 15 | public String toString() { 16 | return "CraftMinecartTNT"; 17 | } 18 | 19 | public EntityType getType() { 20 | return EntityType.MINECART_TNT; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftMonster.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityMonster; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.Monster; 7 | 8 | public class CraftMonster extends CraftCreature implements Monster { 9 | 10 | public CraftMonster(CraftServer server, EntityMonster entity) { 11 | super(server, entity); 12 | } 13 | 14 | @Override 15 | public EntityMonster getHandle() { 16 | return (EntityMonster) entity; 17 | } 18 | 19 | @Override 20 | public String toString() { 21 | return "CraftMonster"; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftMushroomCow.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityMushroomCow; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.MushroomCow; 8 | 9 | public class CraftMushroomCow extends CraftCow implements MushroomCow { 10 | public CraftMushroomCow(CraftServer server, EntityMushroomCow entity) { 11 | super(server, entity); 12 | } 13 | 14 | @Override 15 | public EntityMushroomCow getHandle() { 16 | return (EntityMushroomCow) entity; 17 | } 18 | 19 | @Override 20 | public String toString() { 21 | return "CraftMushroomCow"; 22 | } 23 | 24 | public EntityType getType() { 25 | return EntityType.MUSHROOM_COW; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftOcelot.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityOcelot; 4 | import org.apache.commons.lang.Validate; 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.Ocelot; 8 | 9 | public class CraftOcelot extends CraftTameableAnimal implements Ocelot { 10 | public CraftOcelot(CraftServer server, EntityOcelot wolf) { 11 | super(server, wolf); 12 | } 13 | 14 | @Override 15 | public EntityOcelot getHandle() { 16 | return (EntityOcelot) entity; 17 | } 18 | 19 | public Type getCatType() { 20 | return Type.getType(getHandle().getCatType()); 21 | } 22 | 23 | public void setCatType(Type type) { 24 | Validate.notNull(type, "Cat type cannot be null"); 25 | getHandle().setCatType(type.getId()); 26 | } 27 | 28 | @Override 29 | public EntityType getType() { 30 | return EntityType.OCELOT; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftPig.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityPig; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.Pig; 8 | 9 | public class CraftPig extends CraftAnimals implements Pig { 10 | public CraftPig(CraftServer server, EntityPig entity) { 11 | super(server, entity); 12 | } 13 | 14 | public boolean hasSaddle() { 15 | return getHandle().hasSaddle(); 16 | } 17 | 18 | public void setSaddle(boolean saddled) { 19 | getHandle().setSaddle(saddled); 20 | } 21 | 22 | public EntityPig getHandle() { 23 | return (EntityPig) entity; 24 | } 25 | 26 | @Override 27 | public String toString() { 28 | return "CraftPig"; 29 | } 30 | 31 | public EntityType getType() { 32 | return EntityType.PIG; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftPigZombie.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityPigZombie; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.PigZombie; 8 | 9 | public class CraftPigZombie extends CraftZombie implements PigZombie { 10 | 11 | public CraftPigZombie(CraftServer server, EntityPigZombie entity) { 12 | super(server, entity); 13 | } 14 | 15 | public int getAnger() { 16 | return getHandle().angerLevel; 17 | } 18 | 19 | public void setAnger(int level) { 20 | getHandle().angerLevel = level; 21 | } 22 | 23 | public void setAngry(boolean angry) { 24 | setAnger(angry ? 400 : 0); 25 | } 26 | 27 | public boolean isAngry() { 28 | return getAnger() > 0; 29 | } 30 | 31 | @Override 32 | public EntityPigZombie getHandle() { 33 | return (EntityPigZombie) entity; 34 | } 35 | 36 | @Override 37 | public String toString() { 38 | return "CraftPigZombie"; 39 | } 40 | 41 | public EntityType getType() { 42 | return EntityType.PIG_ZOMBIE; 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftSheep.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntitySheep; 4 | 5 | import org.bukkit.DyeColor; 6 | import org.bukkit.craftbukkit.CraftServer; 7 | import org.bukkit.entity.EntityType; 8 | import org.bukkit.entity.Sheep; 9 | 10 | public class CraftSheep extends CraftAnimals implements Sheep { 11 | public CraftSheep(CraftServer server, EntitySheep entity) { 12 | super(server, entity); 13 | } 14 | 15 | public DyeColor getColor() { 16 | return DyeColor.getByWoolData((byte) getHandle().getColor()); 17 | } 18 | 19 | public void setColor(DyeColor color) { 20 | getHandle().setColor(color.getWoolData()); 21 | } 22 | 23 | public boolean isSheared() { 24 | return getHandle().isSheared(); 25 | } 26 | 27 | public void setSheared(boolean flag) { 28 | getHandle().setSheared(flag); 29 | } 30 | 31 | @Override 32 | public EntitySheep getHandle() { 33 | return (EntitySheep) entity; 34 | } 35 | 36 | @Override 37 | public String toString() { 38 | return "CraftSheep"; 39 | } 40 | 41 | public EntityType getType() { 42 | return EntityType.SHEEP; 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftSilverfish.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntitySilverfish; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.Silverfish; 8 | 9 | public class CraftSilverfish extends CraftMonster implements Silverfish { 10 | public CraftSilverfish(CraftServer server, EntitySilverfish entity) { 11 | super(server, entity); 12 | } 13 | 14 | @Override 15 | public EntitySilverfish getHandle() { 16 | return (EntitySilverfish) entity; 17 | } 18 | 19 | @Override 20 | public String toString() { 21 | return "CraftSilverfish"; 22 | } 23 | 24 | public EntityType getType() { 25 | return EntityType.SILVERFISH; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftSkeleton.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntitySkeleton; 4 | 5 | import org.apache.commons.lang.Validate; 6 | import org.bukkit.craftbukkit.CraftServer; 7 | import org.bukkit.entity.EntityType; 8 | import org.bukkit.entity.Skeleton; 9 | 10 | public class CraftSkeleton extends CraftMonster implements Skeleton { 11 | 12 | public CraftSkeleton(CraftServer server, EntitySkeleton entity) { 13 | super(server, entity); 14 | } 15 | 16 | @Override 17 | public EntitySkeleton getHandle() { 18 | return (EntitySkeleton) entity; 19 | } 20 | 21 | @Override 22 | public String toString() { 23 | return "CraftSkeleton"; 24 | } 25 | 26 | public EntityType getType() { 27 | return EntityType.SKELETON; 28 | } 29 | 30 | public SkeletonType getSkeletonType() { 31 | return SkeletonType.getType(getHandle().getSkeletonType()); 32 | } 33 | 34 | public void setSkeletonType(SkeletonType type) { 35 | Validate.notNull(type); 36 | getHandle().setSkeletonType(type.getId()); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftSlime.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntitySlime; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.Slime; 8 | 9 | public class CraftSlime extends CraftLivingEntity implements Slime { 10 | 11 | public CraftSlime(CraftServer server, EntitySlime entity) { 12 | super(server, entity); 13 | } 14 | 15 | public int getSize() { 16 | return getHandle().getSize(); 17 | } 18 | 19 | public void setSize(int size) { 20 | getHandle().setSize(size); 21 | } 22 | 23 | @Override 24 | public EntitySlime getHandle() { 25 | return (EntitySlime) entity; 26 | } 27 | 28 | @Override 29 | public String toString() { 30 | return "CraftSlime"; 31 | } 32 | 33 | public EntityType getType() { 34 | return EntityType.SLIME; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftSmallFireball.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntitySmallFireball; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.EntityType; 6 | import org.bukkit.entity.SmallFireball; 7 | 8 | public class CraftSmallFireball extends CraftFireball implements SmallFireball { 9 | public CraftSmallFireball(CraftServer server, EntitySmallFireball entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntitySmallFireball getHandle() { 15 | return (EntitySmallFireball) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftSmallFireball"; 21 | } 22 | 23 | public EntityType getType() { 24 | return EntityType.SMALL_FIREBALL; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftSnowball.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntitySnowball; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.EntityType; 6 | import org.bukkit.entity.Snowball; 7 | 8 | public class CraftSnowball extends CraftProjectile implements Snowball { 9 | public CraftSnowball(CraftServer server, EntitySnowball entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntitySnowball getHandle() { 15 | return (EntitySnowball) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftSnowball"; 21 | } 22 | 23 | public EntityType getType() { 24 | return EntityType.SNOWBALL; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftSnowman.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntitySnowman; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.EntityType; 6 | import org.bukkit.entity.Snowman; 7 | 8 | public class CraftSnowman extends CraftGolem implements Snowman { 9 | public CraftSnowman(CraftServer server, EntitySnowman entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntitySnowman getHandle() { 15 | return (EntitySnowman) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftSnowman"; 21 | } 22 | 23 | public EntityType getType() { 24 | return EntityType.SNOWMAN; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftSpider.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntitySpider; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.Spider; 8 | 9 | public class CraftSpider extends CraftMonster implements Spider { 10 | 11 | public CraftSpider(CraftServer server, EntitySpider entity) { 12 | super(server, entity); 13 | } 14 | 15 | @Override 16 | public EntitySpider getHandle() { 17 | return (EntitySpider) entity; 18 | } 19 | 20 | @Override 21 | public String toString() { 22 | return "CraftSpider"; 23 | } 24 | 25 | public EntityType getType() { 26 | return EntityType.SPIDER; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftSquid.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntitySquid; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.Squid; 8 | 9 | public class CraftSquid extends CraftWaterMob implements Squid { 10 | 11 | public CraftSquid(CraftServer server, EntitySquid entity) { 12 | super(server, entity); 13 | } 14 | 15 | @Override 16 | public EntitySquid getHandle() { 17 | return (EntitySquid) entity; 18 | } 19 | 20 | @Override 21 | public String toString() { 22 | return "CraftSquid"; 23 | } 24 | 25 | public EntityType getType() { 26 | return EntityType.SQUID; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftThrownExpBottle.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityThrownExpBottle; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.EntityType; 6 | import org.bukkit.entity.ThrownExpBottle; 7 | 8 | public class CraftThrownExpBottle extends CraftProjectile implements ThrownExpBottle { 9 | public CraftThrownExpBottle(CraftServer server, EntityThrownExpBottle entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntityThrownExpBottle getHandle() { 15 | return (EntityThrownExpBottle) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "EntityThrownExpBottle"; 21 | } 22 | 23 | public EntityType getType() { 24 | return EntityType.THROWN_EXP_BOTTLE; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftVehicle.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import org.bukkit.craftbukkit.CraftServer; 4 | import org.bukkit.entity.Vehicle; 5 | 6 | public abstract class CraftVehicle extends CraftEntity implements Vehicle { 7 | public CraftVehicle(CraftServer server, net.minecraft.server.Entity entity) { 8 | super(server, entity); 9 | } 10 | 11 | @Override 12 | public String toString() { 13 | return "CraftVehicle{passenger=" + getPassenger() + '}'; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityVillager; 4 | import org.apache.commons.lang.Validate; 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.Villager; 8 | 9 | public class CraftVillager extends CraftAgeable implements Villager { 10 | public CraftVillager(CraftServer server, EntityVillager entity) { 11 | super(server, entity); 12 | } 13 | 14 | @Override 15 | public EntityVillager getHandle() { 16 | return (EntityVillager) entity; 17 | } 18 | 19 | @Override 20 | public String toString() { 21 | return "CraftVillager"; 22 | } 23 | 24 | public EntityType getType() { 25 | return EntityType.VILLAGER; 26 | } 27 | 28 | public Profession getProfession() { 29 | return Profession.getProfession(getHandle().getProfession()); 30 | } 31 | 32 | public void setProfession(Profession profession) { 33 | Validate.notNull(profession); 34 | getHandle().setProfession(profession.getId()); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftWaterMob.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityWaterAnimal; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.WaterMob; 7 | 8 | public class CraftWaterMob extends CraftCreature implements WaterMob { 9 | 10 | public CraftWaterMob(CraftServer server, EntityWaterAnimal entity) { 11 | super(server, entity); 12 | } 13 | 14 | @Override 15 | public EntityWaterAnimal getHandle() { 16 | return (EntityWaterAnimal) entity; 17 | } 18 | 19 | @Override 20 | public String toString() { 21 | return "CraftWaterMob"; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftWeather.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityWeather; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.EntityType; 6 | import org.bukkit.entity.Weather; 7 | 8 | public class CraftWeather extends CraftEntity implements Weather { 9 | public CraftWeather(final CraftServer server, final EntityWeather entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntityWeather getHandle() { 15 | return (EntityWeather) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftWeather"; 21 | } 22 | 23 | public EntityType getType() { 24 | return EntityType.WEATHER; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityWitch; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.Witch; 6 | import org.bukkit.entity.EntityType; 7 | 8 | public class CraftWitch extends CraftMonster implements Witch { 9 | public CraftWitch(CraftServer server, EntityWitch entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntityWitch getHandle() { 15 | return (EntityWitch) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftWitch"; 21 | } 22 | 23 | public EntityType getType() { 24 | return EntityType.WITCH; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftWither.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityWither; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.Wither; 6 | import org.bukkit.entity.EntityType; 7 | 8 | public class CraftWither extends CraftMonster implements Wither { 9 | public CraftWither(CraftServer server, EntityWither entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public EntityWither getHandle() { 15 | return (EntityWither) entity; 16 | } 17 | 18 | @Override 19 | public String toString() { 20 | return "CraftWither"; 21 | } 22 | 23 | public EntityType getType() { 24 | return EntityType.WITHER; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftWitherSkull.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityWitherSkull; 4 | import org.bukkit.craftbukkit.CraftServer; 5 | import org.bukkit.entity.EntityType; 6 | import org.bukkit.entity.WitherSkull; 7 | 8 | public class CraftWitherSkull extends CraftFireball implements WitherSkull { 9 | public CraftWitherSkull(CraftServer server, EntityWitherSkull entity) { 10 | super(server, entity); 11 | } 12 | 13 | @Override 14 | public void setCharged(boolean charged) { 15 | getHandle().a(charged); 16 | } 17 | 18 | @Override 19 | public boolean isCharged() { 20 | return getHandle().f(); 21 | } 22 | 23 | @Override 24 | public EntityWitherSkull getHandle() { 25 | return (EntityWitherSkull) entity; 26 | } 27 | 28 | @Override 29 | public String toString() { 30 | return "CraftWitherSkull"; 31 | } 32 | 33 | public EntityType getType() { 34 | return EntityType.WITHER_SKULL; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftWolf.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityWolf; 4 | import org.bukkit.DyeColor; 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.Wolf; 8 | 9 | public class CraftWolf extends CraftTameableAnimal implements Wolf { 10 | public CraftWolf(CraftServer server, EntityWolf wolf) { 11 | super(server, wolf); 12 | } 13 | 14 | public boolean isAngry() { 15 | return getHandle().isAngry(); 16 | } 17 | 18 | public void setAngry(boolean angry) { 19 | getHandle().setAngry(angry); 20 | } 21 | 22 | @Override 23 | public EntityWolf getHandle() { 24 | return (EntityWolf) entity; 25 | } 26 | 27 | @Override 28 | public EntityType getType() { 29 | return EntityType.WOLF; 30 | } 31 | 32 | public DyeColor getCollarColor() { 33 | return DyeColor.getByWoolData((byte) getHandle().getCollarColor()); 34 | } 35 | 36 | public void setCollarColor(DyeColor color) { 37 | getHandle().setCollarColor(color.getWoolData()); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/entity/CraftZombie.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.entity; 2 | 3 | import net.minecraft.server.EntityZombie; 4 | 5 | import org.bukkit.craftbukkit.CraftServer; 6 | import org.bukkit.entity.EntityType; 7 | import org.bukkit.entity.Zombie; 8 | 9 | public class CraftZombie extends CraftMonster implements Zombie { 10 | 11 | public CraftZombie(CraftServer server, EntityZombie entity) { 12 | super(server, entity); 13 | } 14 | 15 | @Override 16 | public EntityZombie getHandle() { 17 | return (EntityZombie) entity; 18 | } 19 | 20 | @Override 21 | public String toString() { 22 | return "CraftZombie"; 23 | } 24 | 25 | public EntityType getType() { 26 | return EntityType.ZOMBIE; 27 | } 28 | 29 | public boolean isBaby() { 30 | return getHandle().isBaby(); 31 | } 32 | 33 | public void setBaby(boolean flag) { 34 | getHandle().setBaby(flag); 35 | } 36 | 37 | public boolean isVillager() { 38 | return getHandle().isVillager(); 39 | } 40 | 41 | public void setVillager(boolean flag) { 42 | getHandle().setVillager(flag); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/generator/InternalChunkGenerator.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.generator; 2 | 3 | import net.minecraft.server.IChunkProvider; 4 | import org.bukkit.generator.ChunkGenerator; 5 | 6 | // Do not implement functions to this class, add to NormalChunkGenerator 7 | public abstract class InternalChunkGenerator extends ChunkGenerator implements IChunkProvider { 8 | } 9 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/generator/NetherChunkGenerator.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.generator; 2 | 3 | import net.minecraft.server.World; 4 | 5 | /** 6 | * This class is useless. Just fyi. 7 | */ 8 | public class NetherChunkGenerator extends NormalChunkGenerator { 9 | public NetherChunkGenerator(World world, long seed) { 10 | super(world, seed); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/generator/SkyLandsChunkGenerator.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.generator; 2 | 3 | import net.minecraft.server.World; 4 | 5 | /** 6 | * This class is useless. Just fyi. 7 | */ 8 | public class SkyLandsChunkGenerator extends NormalChunkGenerator { 9 | public SkyLandsChunkGenerator(World world, long seed) { 10 | super(world, seed); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/help/CommandAliasHelpTopic.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.help; 2 | 3 | import org.apache.commons.lang.Validate; 4 | import org.bukkit.ChatColor; 5 | import org.bukkit.command.CommandSender; 6 | import org.bukkit.help.HelpMap; 7 | import org.bukkit.help.HelpTopic; 8 | 9 | public class CommandAliasHelpTopic extends HelpTopic { 10 | 11 | private final String aliasFor; 12 | private final HelpMap helpMap; 13 | 14 | public CommandAliasHelpTopic(String alias, String aliasFor, HelpMap helpMap) { 15 | this.aliasFor = aliasFor.startsWith("/") ? aliasFor : "/" + aliasFor; 16 | this.helpMap = helpMap; 17 | this.name = alias.startsWith("/") ? alias : "/" + alias; 18 | Validate.isTrue(!this.name.equals(this.aliasFor), "Command " + this.name + " cannot be alias for itself"); 19 | this.shortText = ChatColor.YELLOW + "Alias for " + ChatColor.WHITE + this.aliasFor; 20 | } 21 | 22 | @Override 23 | public String getFullText(CommandSender forWho) { 24 | StringBuilder sb = new StringBuilder(shortText); 25 | HelpTopic aliasForTopic = helpMap.getHelpTopic(aliasFor); 26 | if (aliasForTopic != null) { 27 | sb.append("\n"); 28 | sb.append(aliasForTopic.getFullText(forWho)); 29 | } 30 | return sb.toString(); 31 | } 32 | 33 | @Override 34 | public boolean canSee(CommandSender commandSender) { 35 | if (amendedPermission == null) { 36 | HelpTopic aliasForTopic = helpMap.getHelpTopic(aliasFor); 37 | if (aliasForTopic != null) { 38 | return aliasForTopic.canSee(commandSender); 39 | } else { 40 | return false; 41 | } 42 | } else { 43 | return commandSender.hasPermission(amendedPermission); 44 | } 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/help/CustomHelpTopic.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.help; 2 | 3 | import org.bukkit.command.CommandSender; 4 | import org.bukkit.command.ConsoleCommandSender; 5 | import org.bukkit.help.HelpTopic; 6 | 7 | /** 8 | * This is a help topic implementation for general topics registered in the help.yml file. 9 | */ 10 | public class CustomHelpTopic extends HelpTopic { 11 | private final String permissionNode; 12 | 13 | public CustomHelpTopic(String name, String shortText, String fullText, String permissionNode) { 14 | this.permissionNode = permissionNode; 15 | this.name = name; 16 | this.shortText = shortText; 17 | this.fullText = shortText + "\n" + fullText; 18 | } 19 | 20 | public boolean canSee(CommandSender sender) { 21 | if (sender instanceof ConsoleCommandSender) { 22 | return true; 23 | } 24 | 25 | if (!permissionNode.equals("")) { 26 | return sender.hasPermission(permissionNode); 27 | } else { 28 | return true; 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/help/CustomIndexHelpTopic.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.help; 2 | 3 | import org.bukkit.command.CommandSender; 4 | import org.bukkit.help.HelpMap; 5 | import org.bukkit.help.HelpTopic; 6 | import org.bukkit.help.IndexHelpTopic; 7 | 8 | import java.util.HashSet; 9 | import java.util.LinkedList; 10 | import java.util.List; 11 | 12 | /** 13 | */ 14 | public class CustomIndexHelpTopic extends IndexHelpTopic { 15 | private List futureTopics; 16 | private final HelpMap helpMap; 17 | 18 | public CustomIndexHelpTopic(HelpMap helpMap, String name, String shortText, String permission, List futureTopics, String preamble) { 19 | super(name, shortText, permission, new HashSet(), preamble); 20 | this.helpMap = helpMap; 21 | this.futureTopics = futureTopics; 22 | } 23 | 24 | @Override 25 | public String getFullText(CommandSender sender) { 26 | if (futureTopics != null) { 27 | List topics = new LinkedList(); 28 | for (String futureTopic : futureTopics) { 29 | HelpTopic topic = helpMap.getHelpTopic(futureTopic); 30 | if (topic != null) { 31 | topics.add(topic); 32 | } 33 | } 34 | setTopicsCollection(topics); 35 | futureTopics = null; 36 | } 37 | 38 | return super.getFullText(sender); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/help/HelpTopicAmendment.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.help; 2 | 3 | /** 4 | * A HelpTopicAmendment represents the contents of a topic amendment from the help.yml 5 | */ 6 | public class HelpTopicAmendment { 7 | private final String topicName; 8 | private final String shortText; 9 | private final String fullText; 10 | private final String permission; 11 | 12 | public HelpTopicAmendment(String topicName, String shortText, String fullText, String permission) { 13 | this.fullText = fullText; 14 | this.shortText = shortText; 15 | this.topicName = topicName; 16 | this.permission = permission; 17 | } 18 | 19 | /** 20 | * Gets the amended full text 21 | * @return the full text 22 | */ 23 | public String getFullText() { 24 | return fullText; 25 | } 26 | 27 | /** 28 | * Gets the amended short text 29 | * @return the short text 30 | */ 31 | public String getShortText() { 32 | return shortText; 33 | } 34 | 35 | /** 36 | * Gets the name of the topic being amended 37 | * @return the topic name 38 | */ 39 | public String getTopicName() { 40 | return topicName; 41 | } 42 | 43 | /** 44 | * Gets the amended permission 45 | * @return the permission 46 | */ 47 | public String getPermission() { 48 | return permission; 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/help/MultipleCommandAliasHelpTopicFactory.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.help; 2 | 3 | import org.bukkit.command.MultipleCommandAlias; 4 | import org.bukkit.help.HelpTopic; 5 | import org.bukkit.help.HelpTopicFactory; 6 | 7 | /** 8 | * This class creates {@link MultipleCommandAliasHelpTopic} help topics from {@link MultipleCommandAlias} commands. 9 | */ 10 | public class MultipleCommandAliasHelpTopicFactory implements HelpTopicFactory { 11 | 12 | public HelpTopic createTopic(MultipleCommandAlias multipleCommandAlias) { 13 | return new MultipleCommandAliasHelpTopic(multipleCommandAlias); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/inventory/CraftFurnaceRecipe.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.inventory; 2 | 3 | import net.minecraft.server.RecipesFurnace; 4 | 5 | import org.bukkit.craftbukkit.util.CraftMagicNumbers; 6 | import org.bukkit.inventory.FurnaceRecipe; 7 | import org.bukkit.inventory.ItemStack; 8 | 9 | public class CraftFurnaceRecipe extends FurnaceRecipe implements CraftRecipe { 10 | public CraftFurnaceRecipe(ItemStack result, ItemStack source) { 11 | super(result, source.getType(), source.getDurability()); 12 | } 13 | 14 | public static CraftFurnaceRecipe fromBukkitRecipe(FurnaceRecipe recipe) { 15 | if (recipe instanceof CraftFurnaceRecipe) { 16 | return (CraftFurnaceRecipe) recipe; 17 | } 18 | return new CraftFurnaceRecipe(recipe.getResult(), recipe.getInput()); 19 | } 20 | 21 | @Override 22 | public void addToCraftingManager() { 23 | ItemStack result = this.getResult(); 24 | ItemStack input = this.getInput(); 25 | RecipesFurnace.getInstance().registerRecipe(CraftItemStack.asNMSCopy(input), CraftItemStack.asNMSCopy(result)); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryBeacon.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.inventory; 2 | 3 | import net.minecraft.server.TileEntityBeacon; 4 | import org.bukkit.inventory.BeaconInventory; 5 | import org.bukkit.inventory.ItemStack; 6 | 7 | public class CraftInventoryBeacon extends CraftInventory implements BeaconInventory { 8 | public CraftInventoryBeacon(TileEntityBeacon beacon) { 9 | super(beacon); 10 | } 11 | 12 | public void setItem(ItemStack item) { 13 | setItem(0, item); 14 | } 15 | 16 | public ItemStack getItem() { 17 | return getItem(0); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryBrewer.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.inventory; 2 | 3 | import org.bukkit.block.BrewingStand; 4 | import org.bukkit.inventory.BrewerInventory; 5 | import org.bukkit.inventory.ItemStack; 6 | 7 | import net.minecraft.server.IInventory; 8 | 9 | public class CraftInventoryBrewer extends CraftInventory implements BrewerInventory { 10 | public CraftInventoryBrewer(IInventory inventory) { 11 | super(inventory); 12 | } 13 | 14 | public ItemStack getIngredient() { 15 | return getItem(3); 16 | } 17 | 18 | public void setIngredient(ItemStack ingredient) { 19 | setItem(3, ingredient); 20 | } 21 | 22 | @Override 23 | public BrewingStand getHolder() { 24 | return (BrewingStand) inventory.getOwner(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryEnchanting.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.inventory; 2 | 3 | import org.bukkit.inventory.EnchantingInventory; 4 | import org.bukkit.inventory.ItemStack; 5 | 6 | import net.minecraft.server.ContainerEnchantTableInventory; 7 | 8 | public class CraftInventoryEnchanting extends CraftInventory implements EnchantingInventory { 9 | public CraftInventoryEnchanting(ContainerEnchantTableInventory inventory) { 10 | super(inventory); 11 | } 12 | 13 | public void setItem(ItemStack item) { 14 | setItem(0,item); 15 | } 16 | 17 | public ItemStack getItem() { 18 | return getItem(0); 19 | } 20 | 21 | @Override 22 | public ContainerEnchantTableInventory getInventory() { 23 | return (ContainerEnchantTableInventory)inventory; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryFurnace.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.inventory; 2 | 3 | import org.bukkit.block.Furnace; 4 | import org.bukkit.inventory.FurnaceInventory; 5 | import org.bukkit.inventory.ItemStack; 6 | 7 | import net.minecraft.server.TileEntityFurnace; 8 | 9 | public class CraftInventoryFurnace extends CraftInventory implements FurnaceInventory { 10 | public CraftInventoryFurnace(TileEntityFurnace inventory) { 11 | super(inventory); 12 | } 13 | 14 | public ItemStack getResult() { 15 | return getItem(2); 16 | } 17 | 18 | public ItemStack getFuel() { 19 | return getItem(1); 20 | } 21 | 22 | public ItemStack getSmelting() { 23 | return getItem(0); 24 | } 25 | 26 | public void setFuel(ItemStack stack) { 27 | setItem(1,stack); 28 | } 29 | 30 | public void setResult(ItemStack stack) { 31 | setItem(2,stack); 32 | } 33 | 34 | public void setSmelting(ItemStack stack) { 35 | setItem(0,stack); 36 | } 37 | 38 | @Override 39 | public Furnace getHolder() { 40 | return (Furnace) inventory.getOwner(); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryHorse.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.inventory; 2 | 3 | import net.minecraft.server.IInventory; 4 | import org.bukkit.inventory.HorseInventory; 5 | import org.bukkit.inventory.ItemStack; 6 | 7 | public class CraftInventoryHorse extends CraftInventory implements HorseInventory { 8 | 9 | public CraftInventoryHorse(IInventory inventory) { 10 | super(inventory); 11 | } 12 | 13 | public ItemStack getSaddle() { 14 | return getItem(0); 15 | } 16 | 17 | public ItemStack getArmor() { 18 | return getItem(1); 19 | } 20 | 21 | public void setSaddle(ItemStack stack) { 22 | setItem(0, stack); 23 | } 24 | 25 | public void setArmor(ItemStack stack) { 26 | setItem(1, stack); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryMerchant.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.inventory; 2 | 3 | import net.minecraft.server.InventoryMerchant; 4 | import org.bukkit.inventory.MerchantInventory; 5 | 6 | public class CraftInventoryMerchant extends CraftInventory implements MerchantInventory { 7 | public CraftInventoryMerchant(InventoryMerchant merchant) { 8 | super(merchant); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/inventory/CraftRecipe.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.inventory; 2 | 3 | import org.bukkit.inventory.Recipe; 4 | 5 | public interface CraftRecipe extends Recipe { 6 | void addToCraftingManager(); 7 | } 8 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/map/CraftMapRenderer.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.map; 2 | 3 | import net.minecraft.server.WorldMap; 4 | import net.minecraft.server.WorldMapDecoration; 5 | 6 | import org.bukkit.Bukkit; 7 | import org.bukkit.entity.Player; 8 | import org.bukkit.map.MapCanvas; 9 | import org.bukkit.map.MapCursorCollection; 10 | import org.bukkit.map.MapRenderer; 11 | import org.bukkit.map.MapView; 12 | 13 | public class CraftMapRenderer extends MapRenderer { 14 | 15 | private final WorldMap worldMap; 16 | 17 | public CraftMapRenderer(CraftMapView mapView, WorldMap worldMap) { 18 | super(false); 19 | this.worldMap = worldMap; 20 | } 21 | 22 | @Override 23 | public void render(MapView map, MapCanvas canvas, Player player) { 24 | // Map 25 | for (int x = 0; x < 128; ++x) { 26 | for (int y = 0; y < 128; ++y) { 27 | canvas.setPixel(x, y, worldMap.colors[y * 128 + x]); 28 | } 29 | } 30 | 31 | // Cursors 32 | MapCursorCollection cursors = canvas.getCursors(); 33 | while (cursors.size() > 0) { 34 | cursors.removeCursor(cursors.getCursor(0)); 35 | } 36 | 37 | for (Object key : worldMap.g.keySet()) { 38 | // If this cursor is for a player check visibility with vanish system 39 | Player other = Bukkit.getPlayerExact((String) key); 40 | if (other != null && !player.canSee(other)) { 41 | continue; 42 | } 43 | 44 | WorldMapDecoration decoration = (WorldMapDecoration) worldMap.g.get(key); 45 | cursors.addCursor(decoration.locX, decoration.locY, (byte) (decoration.rotation & 15), decoration.type); 46 | } 47 | } 48 | 49 | } 50 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/map/RenderData.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.map; 2 | 3 | import java.util.ArrayList; 4 | import org.bukkit.map.MapCursor; 5 | 6 | public class RenderData { 7 | 8 | public final byte[] buffer; 9 | public final ArrayList cursors; 10 | 11 | public RenderData() { 12 | this.buffer = new byte[128 * 128]; 13 | this.cursors = new ArrayList(); 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/metadata/EntityMetadataStore.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.metadata; 2 | 3 | import org.bukkit.entity.Entity; 4 | import org.bukkit.metadata.MetadataStore; 5 | import org.bukkit.metadata.MetadataStoreBase; 6 | 7 | /** 8 | * An EntityMetadataStore stores metadata values for all {@link Entity} classes an their descendants. 9 | */ 10 | public class EntityMetadataStore extends MetadataStoreBase implements MetadataStore { 11 | /** 12 | * Generates a unique metadata key for an {@link Entity} UUID. 13 | * 14 | * @see MetadataStoreBase#disambiguate(Object, String) 15 | * @param entity the entity 16 | * @param metadataKey The name identifying the metadata value 17 | * @return a unique metadata key 18 | */ 19 | @Override 20 | protected String disambiguate(Entity entity, String metadataKey) { 21 | return entity.getUniqueId().toString() + ":" + metadataKey; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/metadata/PlayerMetadataStore.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.metadata; 2 | 3 | import org.bukkit.OfflinePlayer; 4 | import org.bukkit.metadata.MetadataStore; 5 | import org.bukkit.metadata.MetadataStoreBase; 6 | 7 | /** 8 | * A PlayerMetadataStore stores metadata for {@link org.bukkit.entity.Player} and {@link OfflinePlayer} objects. 9 | */ 10 | public class PlayerMetadataStore extends MetadataStoreBase implements MetadataStore { 11 | /** 12 | * Generates a unique metadata key for {@link org.bukkit.entity.Player} and {@link OfflinePlayer} using the player 13 | * name. 14 | * @see MetadataStoreBase#disambiguate(Object, String) 15 | * @param player the player 16 | * @param metadataKey The name identifying the metadata value 17 | * @return a unique metadata key 18 | */ 19 | @Override 20 | protected String disambiguate(OfflinePlayer player, String metadataKey) { 21 | return player.getName().toLowerCase() + ":" + metadataKey; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/metadata/WorldMetadataStore.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.metadata; 2 | 3 | import org.bukkit.World; 4 | import org.bukkit.metadata.MetadataStore; 5 | import org.bukkit.metadata.MetadataStoreBase; 6 | 7 | /** 8 | * An WorldMetadataStore stores metadata values for {@link World} objects. 9 | */ 10 | public class WorldMetadataStore extends MetadataStoreBase implements MetadataStore { 11 | /** 12 | * Generates a unique metadata key for a {@link World} object based on the world UID. 13 | * @see WorldMetadataStore#disambiguate(Object, String) 14 | * @param world the world 15 | * @param metadataKey The name identifying the metadata value 16 | * @return a unique metadata key 17 | */ 18 | @Override 19 | protected String disambiguate(World world, String metadataKey) { 20 | return world.getUID().toString() + ":" + metadataKey; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/scheduler/CraftAsyncDebugger.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.scheduler; 2 | 3 | import org.bukkit.plugin.Plugin; 4 | 5 | 6 | class CraftAsyncDebugger { 7 | private CraftAsyncDebugger next = null; 8 | private final int expiry; 9 | private final Plugin plugin; 10 | private final Class clazz; 11 | 12 | CraftAsyncDebugger(final int expiry, final Plugin plugin, final Class clazz) { 13 | this.expiry = expiry; 14 | this.plugin = plugin; 15 | this.clazz = clazz; 16 | 17 | } 18 | 19 | final CraftAsyncDebugger getNextHead(final int time) { 20 | CraftAsyncDebugger next, current = this; 21 | while (time > current.expiry && (next = current.next) != null) { 22 | current = next; 23 | } 24 | return current; 25 | } 26 | 27 | final CraftAsyncDebugger setNext(final CraftAsyncDebugger next) { 28 | return this.next = next; 29 | } 30 | 31 | StringBuilder debugTo(final StringBuilder string) { 32 | for (CraftAsyncDebugger next = this; next != null; next = next.next) { 33 | string.append(next.plugin.getDescription().getName()).append(':').append(next.clazz.getName()).append('@').append(next.expiry).append(','); 34 | } 35 | return string; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardComponent.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.scoreboard; 2 | 3 | abstract class CraftScoreboardComponent { 4 | private CraftScoreboard scoreboard; 5 | 6 | CraftScoreboardComponent(CraftScoreboard scoreboard) { 7 | this.scoreboard = scoreboard; 8 | } 9 | 10 | CraftScoreboard checkState() throws IllegalStateException { 11 | CraftScoreboard scoreboard = this.scoreboard; 12 | if (scoreboard == null) { 13 | throw new IllegalStateException("Unregistered scoreboard component"); 14 | } 15 | return scoreboard; 16 | } 17 | 18 | public CraftScoreboard getScoreboard() { 19 | return scoreboard; 20 | } 21 | 22 | abstract void unregister() throws IllegalStateException; 23 | 24 | final void setUnregistered() { 25 | scoreboard = null; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardTranslations.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.scoreboard; 2 | 3 | import net.minecraft.server.Scoreboard; 4 | 5 | import org.bukkit.scoreboard.DisplaySlot; 6 | 7 | import com.google.common.collect.ImmutableBiMap; 8 | 9 | class CraftScoreboardTranslations { 10 | static final int MAX_DISPLAY_SLOT = 3; 11 | static ImmutableBiMap SLOTS = ImmutableBiMap.of( 12 | DisplaySlot.BELOW_NAME, "belowName", 13 | DisplaySlot.PLAYER_LIST, "list", 14 | DisplaySlot.SIDEBAR, "sidebar"); 15 | 16 | private CraftScoreboardTranslations() {} 17 | 18 | static DisplaySlot toBukkitSlot(int i) { 19 | return SLOTS.inverse().get(Scoreboard.getSlotName(i)); 20 | } 21 | 22 | static int fromBukkitSlot(DisplaySlot slot) { 23 | return Scoreboard.getSlotForName(SLOTS.get(slot)); 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/util/BlockStateListPopulator.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.util; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | import net.minecraft.server.Block; 7 | 8 | import org.bukkit.World; 9 | import org.bukkit.block.BlockState; 10 | 11 | public class BlockStateListPopulator { 12 | private final World world; 13 | private final List list; 14 | 15 | public BlockStateListPopulator(World world) { 16 | this(world, new ArrayList()); 17 | } 18 | 19 | public BlockStateListPopulator(World world, List list) { 20 | this.world = world; 21 | this.list = list; 22 | } 23 | 24 | public void setTypeAndData(int x, int y, int z, Block block, int data, int light) { 25 | BlockState state = world.getBlockAt(x, y, z).getState(); 26 | state.setTypeId(Block.b(block)); 27 | state.setRawData((byte) data); 28 | list.add(state); 29 | } 30 | public void setTypeId(int x, int y, int z, int type) { 31 | BlockState state = world.getBlockAt(x, y, z).getState(); 32 | state.setTypeId(type); 33 | list.add(state); 34 | } 35 | 36 | public void setTypeUpdate(int x, int y, int z, Block block) { 37 | this.setType(x, y, z, block); 38 | } 39 | 40 | public void setType(int x, int y, int z, Block block) { 41 | BlockState state = world.getBlockAt(x, y, z).getState(); 42 | state.setTypeId(Block.b(block)); 43 | list.add(state); 44 | } 45 | 46 | public void updateList() { 47 | for (BlockState state : list) { 48 | state.update(true); 49 | } 50 | } 51 | 52 | public List getList() { 53 | return list; 54 | } 55 | 56 | public World getWorld() { 57 | return world; 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/util/CraftDamageSource.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.util; 2 | 3 | import net.minecraft.server.DamageSource; 4 | 5 | // Util class to create custom DamageSources. 6 | public final class CraftDamageSource extends DamageSource { 7 | public static DamageSource copyOf(final DamageSource original) { 8 | CraftDamageSource newSource = new CraftDamageSource(original.translationIndex); 9 | 10 | // Check ignoresArmor 11 | if (original.ignoresArmor()) { 12 | newSource.k(); 13 | } 14 | 15 | // Check magic 16 | if (original.s()) { 17 | newSource.t(); 18 | } 19 | 20 | // Check fire 21 | if (original.c()) { 22 | newSource.n(); 23 | } 24 | 25 | return newSource; 26 | } 27 | 28 | private CraftDamageSource(String identifier) { 29 | super(identifier); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/util/CraftIconCache.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.util; 2 | 3 | import org.bukkit.util.CachedServerIcon; 4 | 5 | public class CraftIconCache implements CachedServerIcon { 6 | public final String value; 7 | 8 | public CraftIconCache(final String value) { 9 | this.value = value; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/util/DatFileFilter.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.util; 2 | 3 | import java.io.File; 4 | import java.io.FilenameFilter; 5 | 6 | public class DatFileFilter implements FilenameFilter { 7 | public boolean accept(File dir, String name) { 8 | return name.endsWith(".dat"); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/util/ForwardLogHandler.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.util; 2 | 3 | import org.apache.logging.log4j.LogManager; 4 | import org.apache.logging.log4j.Logger; 5 | 6 | import java.util.Map; 7 | import java.util.concurrent.ConcurrentHashMap; 8 | import java.util.logging.ConsoleHandler; 9 | import java.util.logging.Level; 10 | import java.util.logging.LogRecord; 11 | 12 | public class ForwardLogHandler extends ConsoleHandler { 13 | private Map cachedLoggers = new ConcurrentHashMap(); 14 | 15 | private Logger getLogger(String name) { 16 | Logger logger = cachedLoggers.get(name); 17 | if (logger == null) { 18 | logger = LogManager.getLogger(name); 19 | cachedLoggers.put(name, logger); 20 | } 21 | 22 | return logger; 23 | } 24 | 25 | @Override 26 | public void publish(LogRecord record) { 27 | Logger logger = getLogger(record.getLoggerName()); 28 | Throwable exception = record.getThrown(); 29 | Level level = record.getLevel(); 30 | String message = getFormatter().formatMessage(record); 31 | 32 | if (level == Level.SEVERE) { 33 | logger.error(message, exception); 34 | } else if (level == Level.WARNING) { 35 | logger.warn(message, exception); 36 | } else if (level == Level.INFO) { 37 | logger.info(message, exception); 38 | } else if (level == Level.CONFIG) { 39 | logger.debug(message, exception); 40 | } else { 41 | logger.trace(message, exception); 42 | } 43 | } 44 | 45 | @Override 46 | public void flush() { 47 | } 48 | 49 | @Override 50 | public void close() throws SecurityException { 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/util/Java15Compat.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.util; 2 | 3 | import java.lang.reflect.Array; 4 | 5 | public class Java15Compat { 6 | public static T[] Arrays_copyOf(T[] original, int newLength) { 7 | if (0 <= newLength) { 8 | return org.bukkit.util.Java15Compat.Arrays_copyOfRange(original, 0, newLength); 9 | } 10 | throw new NegativeArraySizeException(); 11 | } 12 | 13 | public static long[] Arrays_copyOf(long[] original, int newLength) { 14 | if (0 <= newLength) { 15 | return Arrays_copyOfRange(original, 0, newLength); 16 | } 17 | throw new NegativeArraySizeException(); 18 | } 19 | 20 | private static long[] Arrays_copyOfRange(long[] original, int start, int end) { 21 | if (original.length >= start && 0 <= start) { 22 | if (start <= end) { 23 | int length = end - start; 24 | int copyLength = Math.min(length, original.length - start); 25 | long[] copy = (long[]) Array.newInstance(original.getClass().getComponentType(), length); 26 | System.arraycopy(original, start, copy, 0, copyLength); 27 | return copy; 28 | } 29 | throw new IllegalArgumentException(); 30 | } 31 | throw new ArrayIndexOutOfBoundsException(); 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/util/LazyPlayerSet.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.util; 2 | 3 | import java.util.HashSet; 4 | import java.util.List; 5 | import net.minecraft.server.EntityPlayer; 6 | import net.minecraft.server.MinecraftServer; 7 | 8 | import org.bukkit.entity.Player; 9 | 10 | public class LazyPlayerSet extends LazyHashSet { 11 | 12 | @Override 13 | HashSet makeReference() { 14 | if (reference != null) { 15 | throw new IllegalStateException("Reference already created!"); 16 | } 17 | List players = MinecraftServer.getServer().getPlayerList().players; 18 | HashSet reference = new HashSet(players.size()); 19 | for (EntityPlayer player : players) { 20 | reference.add(player.getBukkitEntity()); 21 | } 22 | return reference; 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/util/LongHash.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.util; 2 | 3 | public class LongHash { 4 | public static long toLong(int msw, int lsw) { 5 | return ((long) msw << 32) + lsw - Integer.MIN_VALUE; 6 | } 7 | 8 | public static int msw(long l) { 9 | return (int) (l >> 32); 10 | } 11 | 12 | public static int lsw(long l) { 13 | return (int) (l & 0xFFFFFFFF) + Integer.MIN_VALUE; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.util; 2 | 3 | import net.minecraft.server.ExceptionWorldConflict; 4 | import net.minecraft.server.MinecraftServer; 5 | 6 | public class ServerShutdownThread extends Thread { 7 | private final MinecraftServer server; 8 | 9 | public ServerShutdownThread(MinecraftServer server) { 10 | this.server = server; 11 | } 12 | 13 | @Override 14 | public void run() { 15 | try { 16 | if(!server.isStopped()) { // Poweruser 17 | server.stop(); 18 | } 19 | } catch (ExceptionWorldConflict ex) { 20 | ex.printStackTrace(); 21 | } finally { 22 | try { 23 | server.reader.getTerminal().restore(); 24 | } catch (Exception e) { 25 | } 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/util/Versioning.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.util; 2 | 3 | import java.io.IOException; 4 | import java.io.InputStream; 5 | import java.util.Properties; 6 | import java.util.logging.Level; 7 | import java.util.logging.Logger; 8 | import org.bukkit.Bukkit; 9 | 10 | public final class Versioning { 11 | public static String getBukkitVersion() { 12 | String result = "Unknown-Version"; 13 | 14 | InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/org.bukkit/bukkit/pom.properties"); 15 | Properties properties = new Properties(); 16 | 17 | if (stream != null) { 18 | try { 19 | properties.load(stream); 20 | 21 | result = properties.getProperty("version"); 22 | } catch (IOException ex) { 23 | Logger.getLogger(Versioning.class.getName()).log(Level.SEVERE, "Could not get Bukkit version!", ex); 24 | } 25 | } 26 | 27 | return result; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/org/bukkit/craftbukkit/util/Waitable.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.util; 2 | 3 | import java.util.concurrent.ExecutionException; 4 | 5 | 6 | public abstract class Waitable implements Runnable { 7 | private enum Status { 8 | WAITING, 9 | RUNNING, 10 | FINISHED, 11 | } 12 | Throwable t = null; 13 | T value = null; 14 | Status status = Status.WAITING; 15 | 16 | public final void run() { 17 | synchronized (this) { 18 | if (status != Status.WAITING) { 19 | throw new IllegalStateException("Invalid state " + status); 20 | } 21 | status = Status.RUNNING; 22 | } 23 | try { 24 | value = evaluate(); 25 | } catch (Throwable t) { 26 | this.t = t; 27 | } finally { 28 | synchronized (this) { 29 | status = Status.FINISHED; 30 | this.notifyAll(); 31 | } 32 | } 33 | } 34 | 35 | protected abstract T evaluate(); 36 | 37 | public synchronized T get() throws InterruptedException, ExecutionException { 38 | while (status != Status.FINISHED) { 39 | this.wait(); 40 | } 41 | if (t != null) { 42 | throw new ExecutionException(t); 43 | } 44 | return value; 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/main/resources/configurations/bukkit.yml: -------------------------------------------------------------------------------- 1 | # This is the main configuration file for Bukkit. 2 | # As you can see, there's actually not that much to configure without any plugins. 3 | # For a reference for any variable inside this file, check out the Bukkit Wiki at 4 | # http://wiki.bukkit.org/Bukkit.yml 5 | # 6 | # If you need help on this file, feel free to join us on irc or leave a message 7 | # on the forums asking for advice. 8 | # 9 | # IRC: #bukkit @ esper.net 10 | # (If this means nothing to you, just go to http://webchat.esper.net/?channels=bukkit ) 11 | # Forums: http://forums.bukkit.org/forums/bukkit-help.6/ 12 | # Twitter: http://twitter.com/CraftBukkit 13 | # Bug tracker: http://leaky.bukkit.org/ 14 | 15 | 16 | settings: 17 | allow-end: true 18 | warn-on-overload: true 19 | permissions-file: permissions.yml 20 | update-folder: update 21 | ping-packet-limit: 100 22 | use-exact-login-location: false 23 | plugin-profiling: false 24 | connection-throttle: 4000 25 | query-plugins: true 26 | deprecated-verbose: default 27 | shutdown-message: Server closed 28 | spawn-limits: 29 | monsters: 70 30 | animals: 15 31 | water-animals: 5 32 | ambient: 15 33 | chunk-gc: 34 | period-in-ticks: 600 35 | load-threshold: 0 36 | ticks-per: 37 | animal-spawns: 400 38 | monster-spawns: 1 39 | autosave: 6000 40 | auto-updater: 41 | enabled: true 42 | on-broken: [warn-console, warn-ops] 43 | on-update: [warn-console, warn-ops] 44 | preferred-channel: rb 45 | host: dl.bukkit.org 46 | suggest-channels: true 47 | aliases: now-in-commands.yml 48 | database: 49 | username: bukkit 50 | isolation: SERIALIZABLE 51 | driver: org.sqlite.JDBC 52 | password: walrus 53 | url: jdbc:sqlite:{DIR}{NAME}.db 54 | -------------------------------------------------------------------------------- /src/main/resources/configurations/commands.yml: -------------------------------------------------------------------------------- 1 | # This is the commands configuration file for Bukkit. 2 | # For documentation on how to make use of this file, check out the Bukkit Wiki at 3 | # http://wiki.bukkit.org/Commands.yml 4 | # 5 | # If you need help on this file, feel free to join us on irc or leave a message 6 | # on the forums asking for advice. 7 | # 8 | # IRC: #bukkit @ esper.net 9 | # (If this means nothing to you, just go to http://webchat.esper.net/?channels=bukkit ) 10 | # Forums: http://forums.bukkit.org/forums/bukkit-help.6/ 11 | # Twitter: http://twitter.com/CraftBukkit 12 | # Bug tracker: http://leaky.bukkit.org/ 13 | 14 | command-block-overrides: [] 15 | aliases: 16 | icanhasbukkit: 17 | - "version $1-" 18 | -------------------------------------------------------------------------------- /src/main/resources/configurations/minetickmod.yml: -------------------------------------------------------------------------------- 1 | minetickmod: 2 | profiler-log-interval: 30 3 | profiler-write-log: false 4 | profiler-write-interval: 10 5 | threadedWorlds: true 6 | orebfuscatedWorlds: [] 7 | packetCompressionLevel: 7 8 | packetBuilderThreadPoolSize: -1 9 | packetsPerTick: 1 10 | packetChunkRates: 11 | HIGHEST: 5 12 | HIGH: 3 13 | MODERATE: 2 14 | LOW: 1 15 | notGeneratingWorlds: [] 16 | maxEntityLifeTime: 10 17 | entitiesWithLimitedLifeTime: [] 18 | customOreRates: [] 19 | maxChunkGenerationRates: 20 | DEFAULT: 0.5 21 | FLAT: 1.0 22 | LARGEBIOMES: 0.5 23 | AMPLIFIED: 0.5 24 | activationRange: 25 | low: 16 26 | high: 64 27 | max: 88 28 | pathSearchThreadPoolSize: 2 29 | minimumTargetDistanceForOffloadedPathSearches: 0 30 | entitiesWithOffloadedPathSearches: 31 | - BAT 32 | - CHICKEN 33 | - COW 34 | - CREEPER 35 | - MAGMA_CUBE 36 | - PIG 37 | - SHEEP 38 | - SKELETON 39 | - SLIME 40 | - SQUID 41 | - ZOMBIE 42 | keepConnectionsAlive: false 43 | -------------------------------------------------------------------------------- /src/main/resources/log4j2.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | -------------------------------------------------------------------------------- /src/test/java/org/bukkit/DyeColorsTest.java: -------------------------------------------------------------------------------- 1 | package org.bukkit; 2 | 3 | import static org.junit.Assert.*; 4 | import static org.hamcrest.Matchers.*; 5 | 6 | import java.util.ArrayList; 7 | import java.util.List; 8 | 9 | import net.minecraft.server.EntitySheep; 10 | import net.minecraft.server.ItemDye; 11 | 12 | import org.bukkit.support.AbstractTestingBase; 13 | import org.junit.Test; 14 | import org.junit.runner.RunWith; 15 | import org.junit.runners.Parameterized; 16 | import org.junit.runners.Parameterized.Parameter; 17 | import org.junit.runners.Parameterized.Parameters; 18 | 19 | @RunWith(Parameterized.class) 20 | public class DyeColorsTest extends AbstractTestingBase { 21 | 22 | @Parameters(name= "{index}: {0}") 23 | public static List data() { 24 | List list = new ArrayList(); 25 | for (DyeColor dye : DyeColor.values()) { 26 | list.add(new Object[] {dye}); 27 | } 28 | return list; 29 | } 30 | 31 | @Parameter public DyeColor dye; 32 | 33 | @Test 34 | public void checkColor() { 35 | Color color = dye.getColor(); 36 | float[] nmsColorArray = EntitySheep.bp[dye.getWoolData()]; 37 | Color nmsColor = Color.fromRGB((int) (nmsColorArray[0] * 255), (int) (nmsColorArray[1] * 255), (int) (nmsColorArray[2] * 255)); 38 | assertThat(color, is(nmsColor)); 39 | } 40 | 41 | @Test 42 | public void checkFireworkColor() { 43 | Color color = dye.getFireworkColor(); 44 | int nmsColor = ItemDye.c[dye.getDyeData()]; 45 | assertThat(color, is(Color.fromRGB(nmsColor))); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /src/test/java/org/bukkit/MaterialTest.java: -------------------------------------------------------------------------------- 1 | package org.bukkit; 2 | 3 | import static org.junit.Assert.*; 4 | import static org.hamcrest.Matchers.*; 5 | 6 | import java.util.Collections; 7 | import java.util.Map; 8 | 9 | import net.minecraft.server.Item; 10 | 11 | import org.bukkit.support.AbstractTestingBase; 12 | import org.junit.Test; 13 | 14 | import com.google.common.collect.Maps; 15 | import java.util.Iterator; 16 | import org.bukkit.craftbukkit.util.CraftMagicNumbers; 17 | 18 | public class MaterialTest extends AbstractTestingBase { 19 | 20 | @Test 21 | public void verifyMapping() { 22 | Map materials = Maps.newHashMap(); 23 | for (Material material : Material.values()) { 24 | if (INVALIDATED_MATERIALS.contains(material)) { 25 | continue; 26 | } 27 | 28 | materials.put(material.getId(), material); 29 | } 30 | materials.remove(0); // Purge air. 31 | 32 | Iterator items = Item.REGISTRY.iterator(); 33 | 34 | while (items.hasNext()) { 35 | Item item = items.next(); 36 | if (item == null) continue; 37 | 38 | int id = CraftMagicNumbers.getId(item); 39 | String name = item.getName(); 40 | 41 | Material material = materials.remove(id); 42 | 43 | assertThat("Missing " + name + "(" + id + ")", material, is(not(nullValue()))); 44 | } 45 | 46 | assertThat(materials, is(Collections.EMPTY_MAP)); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/test/java/org/bukkit/SoundTest.java: -------------------------------------------------------------------------------- 1 | package org.bukkit; 2 | 3 | import static org.junit.Assert.*; 4 | import static org.hamcrest.Matchers.*; 5 | 6 | import org.bukkit.craftbukkit.CraftSound; 7 | import org.junit.Test; 8 | 9 | 10 | public class SoundTest { 11 | 12 | @Test 13 | public void testGetSound() { 14 | for (Sound sound : Sound.values()) { 15 | assertThat(sound.name(), CraftSound.getSound(sound), is(not(nullValue()))); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/test/java/org/bukkit/WorldTypeTest.java: -------------------------------------------------------------------------------- 1 | package org.bukkit; 2 | 3 | import static org.junit.Assert.*; 4 | import static org.hamcrest.Matchers.*; 5 | 6 | import net.minecraft.server.WorldType; 7 | import org.junit.Test; 8 | 9 | public class WorldTypeTest { 10 | @Test 11 | public void testTypes() { 12 | for (WorldType type : WorldType.types) { 13 | if (type == null) continue; 14 | 15 | assertThat(type.name() + " has no Bukkit world", org.bukkit.WorldType.getByName(type.name()), is(not(nullValue()))); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/test/java/org/bukkit/craftbukkit/inventory/NMSCraftItemStackTest.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.inventory; 2 | 3 | import static org.junit.Assert.*; 4 | import static org.hamcrest.Matchers.*; 5 | 6 | import net.minecraft.server.Enchantment; 7 | 8 | import org.bukkit.inventory.ItemStack; 9 | import org.bukkit.support.AbstractTestingBase; 10 | import org.junit.Test; 11 | 12 | public class NMSCraftItemStackTest extends AbstractTestingBase { 13 | 14 | @Test 15 | public void testCloneEnchantedItem() throws Exception { 16 | net.minecraft.server.ItemStack nmsItemStack = new net.minecraft.server.ItemStack(net.minecraft.server.Items.POTION); 17 | nmsItemStack.addEnchantment(Enchantment.DAMAGE_ALL, 1); 18 | ItemStack itemStack = CraftItemStack.asCraftMirror(nmsItemStack); 19 | ItemStack clone = itemStack.clone(); 20 | assertThat(clone.getType(), is(itemStack.getType())); 21 | assertThat(clone.getAmount(), is(itemStack.getAmount())); 22 | assertThat(clone.getDurability(), is(itemStack.getDurability())); 23 | assertThat(clone.getEnchantments(), is(itemStack.getEnchantments())); 24 | assertThat(clone.getTypeId(), is(itemStack.getTypeId())); 25 | assertThat(clone.getData(), is(itemStack.getData())); 26 | assertThat(clone, is(itemStack)); 27 | } 28 | 29 | @Test 30 | public void testCloneNullItem() throws Exception { 31 | net.minecraft.server.ItemStack nmsItemStack = null; 32 | ItemStack itemStack = CraftItemStack.asCraftMirror(nmsItemStack); 33 | ItemStack clone = itemStack.clone(); 34 | assertThat(clone, is(itemStack)); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/test/java/org/bukkit/craftbukkit/updater/BukkitDLUpdaterServiceTest.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.craftbukkit.updater; 2 | 3 | import static org.junit.Assert.*; 4 | import static org.hamcrest.Matchers.*; 5 | 6 | import java.io.FileNotFoundException; 7 | import java.io.IOException; 8 | 9 | import org.junit.Test; 10 | 11 | public class BukkitDLUpdaterServiceTest { 12 | @Test(expected=IOException.class) 13 | public void testHostNotFound() throws IOException { 14 | BukkitDLUpdaterService service = new BukkitDLUpdaterService("404.example.org"); 15 | 16 | service.fetchArtifact("rb"); 17 | } 18 | 19 | @Test(expected=FileNotFoundException.class) 20 | public void testArtifactNotFound() throws IOException { 21 | BukkitDLUpdaterService service = new BukkitDLUpdaterService("dl.bukkit.org"); 22 | 23 | service.fetchArtifact("meep"); 24 | } 25 | 26 | @Test 27 | public void testArtifactExists() throws IOException { 28 | BukkitDLUpdaterService service = new BukkitDLUpdaterService("dl.bukkit.org"); 29 | 30 | assertThat(service.fetchArtifact("latest-dev"), is(not(nullValue()))); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/test/java/org/bukkit/potion/PotionTest.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.potion; 2 | 3 | import static org.junit.Assert.*; 4 | import static org.hamcrest.Matchers.*; 5 | 6 | import java.util.EnumMap; 7 | import java.util.Map; 8 | 9 | import org.bukkit.support.AbstractTestingBase; 10 | import org.bukkit.support.Util; 11 | import org.junit.Test; 12 | 13 | public class PotionTest extends AbstractTestingBase { 14 | 15 | @Test 16 | public void getEffects() { 17 | for (PotionType type : PotionType.values()) { 18 | for (PotionEffect effect : new Potion(type).getEffects()) { 19 | PotionEffectType potionType = effect.getType(); 20 | assertThat(effect.getType(), is(sameInstance(PotionEffectType.getById(potionType.getId())))); 21 | 22 | assertNotNull(potionType.getName(), PotionType.getByEffect(potionType)); 23 | } 24 | } 25 | } 26 | 27 | @Test 28 | public void testEffectCompleteness() throws Throwable { 29 | Map effectDurations = Util.getInternalState(net.minecraft.server.PotionBrewer.class, null, "effectDurations"); 30 | 31 | Map effects = new EnumMap(PotionType.class); 32 | for (int id : effectDurations.keySet()) { 33 | PotionEffectType type = PotionEffectType.getById(id); 34 | assertNotNull(String.valueOf(id), PotionEffectType.getById(id)); 35 | 36 | PotionType enumType = PotionType.getByEffect(type); 37 | assertNotNull(type.getName(), enumType); 38 | 39 | assertThat(enumType.name(), effects.put(enumType, enumType.name()), is(nullValue())); 40 | } 41 | 42 | assertThat(effects.entrySet(), hasSize(effectDurations.size())); 43 | assertThat(effectDurations.entrySet(), hasSize(PotionType.values().length - /* WATER */ 1)); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/test/java/org/bukkit/support/AbstractTestingBase.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.support; 2 | 3 | import com.google.common.collect.ImmutableList; 4 | import java.util.List; 5 | import net.minecraft.server.DispenserRegistry; 6 | import org.bukkit.Material; 7 | import org.junit.BeforeClass; 8 | 9 | /** 10 | * If you are getting: java.lang.ExceptionInInitializerError 11 | * at net.minecraft.server.StatisticList.(SourceFile:58) 12 | * at net.minecraft.server.Item.(SourceFile:252) 13 | * at net.minecraft.server.Block.(Block.java:577) 14 | * 15 | * extend this class to solve it. 16 | */ 17 | public abstract class AbstractTestingBase { 18 | public static final List INVALIDATED_MATERIALS = ImmutableList.builder().add(Material.BREWING_STAND, Material.BED_BLOCK, Material.NETHER_WARTS, Material.CAULDRON, Material.FLOWER_POT, Material.CROPS, Material.SUGAR_CANE_BLOCK, Material.CAKE_BLOCK, Material.SKULL, Material.PISTON_EXTENSION, Material.PISTON_MOVING_PIECE, Material.GLOWING_REDSTONE_ORE, Material.DIODE_BLOCK_ON, Material.PUMPKIN_STEM, Material.SIGN_POST, Material.REDSTONE_COMPARATOR_ON, Material.TRIPWIRE, Material.REDSTONE_LAMP_ON, Material.MELON_STEM, Material.REDSTONE_TORCH_OFF, Material.REDSTONE_COMPARATOR_OFF, Material.REDSTONE_WIRE, Material.WALL_SIGN, Material.DIODE_BLOCK_OFF, Material.IRON_DOOR_BLOCK, Material.WOODEN_DOOR).add(Material.LOCKED_CHEST).build(); 19 | 20 | @BeforeClass 21 | public static void setup() { 22 | DispenserRegistry.b(); 23 | DummyServer.setup(); 24 | DummyPotions.setup(); 25 | DummyEnchantments.setup(); 26 | } 27 | } -------------------------------------------------------------------------------- /src/test/java/org/bukkit/support/DummyEnchantments.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.support; 2 | 3 | import net.minecraft.server.Enchantment; 4 | 5 | public class DummyEnchantments { 6 | static { 7 | Enchantment.byId.getClass(); 8 | org.bukkit.enchantments.Enchantment.stopAcceptingRegistrations(); 9 | } 10 | 11 | public static void setup() {} 12 | } 13 | -------------------------------------------------------------------------------- /src/test/java/org/bukkit/support/DummyPotions.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.support; 2 | 3 | import net.minecraft.server.MobEffectList; 4 | 5 | import org.bukkit.craftbukkit.potion.CraftPotionBrewer; 6 | import org.bukkit.potion.Potion; 7 | import org.bukkit.potion.PotionEffectType; 8 | 9 | public class DummyPotions { 10 | static { 11 | Potion.setPotionBrewer(new CraftPotionBrewer()); 12 | MobEffectList.BLINDNESS.getClass(); 13 | PotionEffectType.stopAcceptingRegistrations(); 14 | } 15 | 16 | public static void setup() {} 17 | } 18 | -------------------------------------------------------------------------------- /src/test/java/org/bukkit/support/Matchers.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.support; 2 | 3 | import org.hamcrest.BaseMatcher; 4 | import org.hamcrest.Description; 5 | import org.hamcrest.Matcher; 6 | 7 | public final class Matchers { 8 | 9 | private Matchers() {} 10 | 11 | public static Matcher sameHash(T value) { 12 | return new SameHash(value); 13 | } 14 | 15 | static class SameHash extends BaseMatcher { 16 | private final int expected; 17 | 18 | SameHash(T object) { 19 | expected = object.hashCode(); 20 | } 21 | 22 | public boolean matches(Object item) { 23 | return item.hashCode() == expected; 24 | } 25 | 26 | public void describeTo(Description description) { 27 | description.appendValue(expected); 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/test/java/org/bukkit/support/Util.java: -------------------------------------------------------------------------------- 1 | package org.bukkit.support; 2 | 3 | import java.lang.reflect.Field; 4 | 5 | public class Util { 6 | /* 7 | public static T getInternalState(Object object, String fieldName) { 8 | return getInternalState(object.getClass(), object, fieldName); 9 | } 10 | */ 11 | 12 | @SuppressWarnings("unchecked") 13 | public static T getInternalState(Class clazz, Object object, String fieldName) { 14 | Field field; 15 | try { 16 | field = clazz.getDeclaredField(fieldName); 17 | } catch (SecurityException e) { 18 | throw new RuntimeException("Not allowed to access " + clazz, e); 19 | } catch (NoSuchFieldException e) { 20 | throw new RuntimeException("Unable to find field " + fieldName, e); 21 | } 22 | 23 | field.setAccessible(true); 24 | try { 25 | return (T) field.get(object); 26 | } catch (IllegalArgumentException e) { 27 | } catch (IllegalAccessException e) { 28 | } 29 | throw new RuntimeException("Unable to get internal value"); 30 | } 31 | } 32 | --------------------------------------------------------------------------------