From b8b41aa5846dae5a9bbf4fee82020f1d9e2b2a48 Mon Sep 17 00:00:00 2001 From: Benjamin Culkin Date: Mon, 12 Aug 2024 17:08:54 -0400 Subject: Initial commit --- src/main/java/fyresmodjam/ClientProxy.java | 169 ++++ src/main/java/fyresmodjam/CommonProxy.java | 97 ++ src/main/java/fyresmodjam/EntityLevelStat.java | 183 ++++ src/main/java/fyresmodjam/ModjamMod.java | 626 ++++++++++++ src/main/java/fyresmodjam/blessings/Blessing.java | 119 +++ .../java/fyresmodjam/blessings/BlessingUtils.java | 216 ++++ .../blessings/marks/ArcaneNullityMark.java | 36 + .../blessings/marks/BerserkingMark.java | 28 + .../fyresmodjam/blessings/marks/FalseLifeMark.java | 58 ++ .../fyresmodjam/blessings/marks/GuardingMark.java | 27 + .../fyresmodjam/blessings/marks/HolyLightMark.java | 32 + .../fyresmodjam/blessings/marks/HuntingMark.java | 37 + .../java/fyresmodjam/blessings/marks/Mark.java | 15 + .../blessings/marks/RetaliationMark.java | 57 ++ .../fyresmodjam/blessings/marks/ScoutingMark.java | 13 + .../fyresmodjam/blessings/marks/VampirismMark.java | 67 ++ .../java/fyresmodjam/blessings/marks/WarMark.java | 28 + .../blessings/standard/AlchemistBlessing.java | 16 + .../blessings/standard/BerserkerBlessing.java | 50 + .../blessings/standard/DiverBlessing.java | 23 + .../blessings/standard/GuardianBlessing.java | 23 + .../blessings/standard/HunterBlessing.java | 37 + .../blessings/standard/InfernoBlessing.java | 55 + .../blessings/standard/LonerBlessing.java | 38 + .../blessings/standard/LooterBlessing.java | 32 + .../blessings/standard/LumberjackBlessing.java | 59 ++ .../blessings/standard/MechanicBlessing.java | 17 + .../blessings/standard/MinerBlessing.java | 61 ++ .../blessings/standard/NinjaBlessing.java | 55 + .../blessings/standard/PaladinBlessing.java | 27 + .../blessings/standard/ParatrooperBlessing.java | 29 + .../blessings/standard/PorcupineBlessing.java | 45 + .../blessings/standard/ScholarBlessing.java | 29 + .../blessings/standard/SwampBlessing.java | 34 + .../blessings/standard/ThickSkinnedBlessing.java | 24 + .../blessings/standard/ThiefBlessing.java | 29 + .../blessings/standard/VampireBlessing.java | 55 + .../blessings/standard/WarriorBlessing.java | 39 + .../fyresmodjam/commands/CommandCraftingStats.java | 156 +++ .../commands/CommandCurrentBlessing.java | 87 ++ .../commands/CommandCurrentDisadvantage.java | 84 ++ .../commands/CommandCurrentWorldTask.java | 110 ++ .../fyresmodjam/commands/CommandKillStats.java | 158 +++ .../fyresmodjam/commands/CommandWeaponStats.java | 157 +++ .../fyresmodjam/handlers/ClientTickHandler.java | 82 ++ .../fyresmodjam/handlers/CommonTickHandler.java | 350 +++++++ .../java/fyresmodjam/handlers/FyresKeyHandler.java | 186 ++++ src/main/java/fyresmodjam/handlers/GUIHandler.java | 21 + .../fyresmodjam/handlers/NewPacketHandler.java | 1067 ++++++++++++++++++++ .../java/fyresmodjam/misc/ArmorStatTracker.java | 79 ++ .../fyresmodjam/misc/CreativeTabModjamMod.java | 81 ++ src/main/java/fyresmodjam/misc/DamageSources.java | 22 + src/main/java/fyresmodjam/misc/EntityStat.java | 27 + .../java/fyresmodjam/misc/EntityStatHelper.java | 740 ++++++++++++++ .../java/fyresmodjam/misc/EntityStatTracker.java | 29 + src/main/java/fyresmodjam/misc/ItemStat.java | 30 + src/main/java/fyresmodjam/misc/ItemStatHelper.java | 565 +++++++++++ .../java/fyresmodjam/misc/ItemStatTracker.java | 29 + src/main/java/fyresmodjam/misc/WeaponRankStat.java | 83 ++ .../java/fyresmodjam/worldgen/FyresWorldData.java | 480 +++++++++ .../fyresmodjam/advancements/startTheGame.json | 2 + .../resources/assets/fyresmodjam/lang/en_US.lang | 19 + src/main/resources/assets/fyresmodjam/sounds.json | 3 + .../assets/fyresmodjam/sounds/pillarActivated.ogg | Bin 0 -> 9448 bytes .../assets/fyresmodjam/textures/blocks/crystal.png | Bin 0 -> 328 bytes .../fyresmodjam/textures/blocks/crystal_stand.png | Bin 0 -> 2061 bytes .../fyresmodjam/textures/blocks/mushroomBlock.png | Bin 0 -> 224 bytes .../textures/blocks/mushroomBlock_overlay.png | Bin 0 -> 225 bytes .../assets/fyresmodjam/textures/blocks/pillar.png | Bin 0 -> 684 bytes .../fyresmodjam/textures/blocks/pillarActive.png | Bin 0 -> 726 bytes .../assets/fyresmodjam/textures/blocks/spikes.png | Bin 0 -> 677 bytes .../assets/fyresmodjam/textures/blocks/spikes2.png | Bin 0 -> 317 bytes .../assets/fyresmodjam/textures/blocks/trap2.png | Bin 0 -> 1263 bytes .../assets/fyresmodjam/textures/blocks/trap3.png | Bin 0 -> 1160 bytes .../fyresmodjam/textures/items/basic_staff.png | Bin 0 -> 340 bytes .../fyresmodjam/textures/items/crystal_item.png | Bin 0 -> 230 bytes .../textures/items/crystal_stand_item.png | Bin 0 -> 422 bytes .../textures/items/enchantedSceptre.png | Bin 0 -> 295 bytes .../fyresmodjam/textures/items/fire_amulet.png | Bin 0 -> 297 bytes .../textures/items/fire_amulet_overlay.png | Bin 0 -> 256 bytes .../fyresmodjam/textures/items/itemPillar.png | Bin 0 -> 237 bytes .../assets/fyresmodjam/textures/items/itemTrap.png | Bin 0 -> 317 bytes .../assets/fyresmodjam/textures/items/mushroom.png | Bin 0 -> 233 bytes .../textures/items/mushroom_overlay.png | Bin 0 -> 228 bytes .../textures/items/mysteryPotionThrowable_1.png | Bin 0 -> 352 bytes .../textures/items/mysteryPotionThrowable_10.png | Bin 0 -> 360 bytes .../textures/items/mysteryPotionThrowable_11.png | Bin 0 -> 358 bytes .../textures/items/mysteryPotionThrowable_12.png | Bin 0 -> 361 bytes .../textures/items/mysteryPotionThrowable_13.png | Bin 0 -> 359 bytes .../textures/items/mysteryPotionThrowable_2.png | Bin 0 -> 365 bytes .../textures/items/mysteryPotionThrowable_3.png | Bin 0 -> 352 bytes .../textures/items/mysteryPotionThrowable_4.png | Bin 0 -> 359 bytes .../textures/items/mysteryPotionThrowable_5.png | Bin 0 -> 359 bytes .../textures/items/mysteryPotionThrowable_6.png | Bin 0 -> 356 bytes .../textures/items/mysteryPotionThrowable_7.png | Bin 0 -> 359 bytes .../textures/items/mysteryPotionThrowable_8.png | Bin 0 -> 357 bytes .../textures/items/mysteryPotionThrowable_9.png | Bin 0 -> 360 bytes .../fyresmodjam/textures/items/mysteryPotion_1.png | Bin 0 -> 257 bytes .../textures/items/mysteryPotion_10.png | Bin 0 -> 266 bytes .../textures/items/mysteryPotion_11.png | Bin 0 -> 259 bytes .../textures/items/mysteryPotion_12.png | Bin 0 -> 264 bytes .../textures/items/mysteryPotion_13.png | Bin 0 -> 258 bytes .../fyresmodjam/textures/items/mysteryPotion_2.png | Bin 0 -> 255 bytes .../fyresmodjam/textures/items/mysteryPotion_3.png | Bin 0 -> 255 bytes .../fyresmodjam/textures/items/mysteryPotion_4.png | Bin 0 -> 262 bytes .../fyresmodjam/textures/items/mysteryPotion_5.png | Bin 0 -> 263 bytes .../fyresmodjam/textures/items/mysteryPotion_6.png | Bin 0 -> 259 bytes .../fyresmodjam/textures/items/mysteryPotion_7.png | Bin 0 -> 260 bytes .../fyresmodjam/textures/items/mysteryPotion_8.png | Bin 0 -> 256 bytes .../fyresmodjam/textures/items/mysteryPotion_9.png | Bin 0 -> 266 bytes .../assets/fyresmodjam/textures/items/sceptre.png | Bin 0 -> 319 bytes .../assets/fyresmodjam/textures/items/scroll.png | Bin 0 -> 304 bytes .../fyresmodjam/textures/items/star_amulet.png | Bin 0 -> 298 bytes .../textures/items/star_amulet_overlay.png | Bin 0 -> 255 bytes .../assets/fyresmodjam/textures/items/trap2.png | Bin 0 -> 295 bytes .../assets/fyresmodjam/textures/items/trap3.png | Bin 0 -> 284 bytes .../textures/items/unenchantedSceptre.png | Bin 0 -> 288 bytes src/main/resources/mcmod.info | 16 + src/main/resources/pack.mcmeta | 7 + 119 files changed, 7255 insertions(+) create mode 100644 src/main/java/fyresmodjam/ClientProxy.java create mode 100644 src/main/java/fyresmodjam/CommonProxy.java create mode 100644 src/main/java/fyresmodjam/EntityLevelStat.java create mode 100644 src/main/java/fyresmodjam/ModjamMod.java create mode 100644 src/main/java/fyresmodjam/blessings/Blessing.java create mode 100644 src/main/java/fyresmodjam/blessings/BlessingUtils.java create mode 100644 src/main/java/fyresmodjam/blessings/marks/ArcaneNullityMark.java create mode 100644 src/main/java/fyresmodjam/blessings/marks/BerserkingMark.java create mode 100644 src/main/java/fyresmodjam/blessings/marks/FalseLifeMark.java create mode 100644 src/main/java/fyresmodjam/blessings/marks/GuardingMark.java create mode 100644 src/main/java/fyresmodjam/blessings/marks/HolyLightMark.java create mode 100644 src/main/java/fyresmodjam/blessings/marks/HuntingMark.java create mode 100644 src/main/java/fyresmodjam/blessings/marks/Mark.java create mode 100644 src/main/java/fyresmodjam/blessings/marks/RetaliationMark.java create mode 100644 src/main/java/fyresmodjam/blessings/marks/ScoutingMark.java create mode 100644 src/main/java/fyresmodjam/blessings/marks/VampirismMark.java create mode 100644 src/main/java/fyresmodjam/blessings/marks/WarMark.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/AlchemistBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/BerserkerBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/DiverBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/GuardianBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/HunterBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/InfernoBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/LonerBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/LooterBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/LumberjackBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/MechanicBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/MinerBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/NinjaBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/PaladinBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/ParatrooperBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/PorcupineBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/ScholarBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/SwampBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/ThickSkinnedBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/ThiefBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/VampireBlessing.java create mode 100644 src/main/java/fyresmodjam/blessings/standard/WarriorBlessing.java create mode 100644 src/main/java/fyresmodjam/commands/CommandCraftingStats.java create mode 100644 src/main/java/fyresmodjam/commands/CommandCurrentBlessing.java create mode 100644 src/main/java/fyresmodjam/commands/CommandCurrentDisadvantage.java create mode 100644 src/main/java/fyresmodjam/commands/CommandCurrentWorldTask.java create mode 100644 src/main/java/fyresmodjam/commands/CommandKillStats.java create mode 100644 src/main/java/fyresmodjam/commands/CommandWeaponStats.java create mode 100644 src/main/java/fyresmodjam/handlers/ClientTickHandler.java create mode 100644 src/main/java/fyresmodjam/handlers/CommonTickHandler.java create mode 100644 src/main/java/fyresmodjam/handlers/FyresKeyHandler.java create mode 100644 src/main/java/fyresmodjam/handlers/GUIHandler.java create mode 100644 src/main/java/fyresmodjam/handlers/NewPacketHandler.java create mode 100644 src/main/java/fyresmodjam/misc/ArmorStatTracker.java create mode 100644 src/main/java/fyresmodjam/misc/CreativeTabModjamMod.java create mode 100644 src/main/java/fyresmodjam/misc/DamageSources.java create mode 100644 src/main/java/fyresmodjam/misc/EntityStat.java create mode 100644 src/main/java/fyresmodjam/misc/EntityStatHelper.java create mode 100644 src/main/java/fyresmodjam/misc/EntityStatTracker.java create mode 100644 src/main/java/fyresmodjam/misc/ItemStat.java create mode 100644 src/main/java/fyresmodjam/misc/ItemStatHelper.java create mode 100644 src/main/java/fyresmodjam/misc/ItemStatTracker.java create mode 100644 src/main/java/fyresmodjam/misc/WeaponRankStat.java create mode 100644 src/main/java/fyresmodjam/worldgen/FyresWorldData.java create mode 100644 src/main/resources/assets/fyresmodjam/advancements/startTheGame.json create mode 100644 src/main/resources/assets/fyresmodjam/lang/en_US.lang create mode 100644 src/main/resources/assets/fyresmodjam/sounds.json create mode 100644 src/main/resources/assets/fyresmodjam/sounds/pillarActivated.ogg create mode 100644 src/main/resources/assets/fyresmodjam/textures/blocks/crystal.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/blocks/crystal_stand.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/blocks/mushroomBlock.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/blocks/mushroomBlock_overlay.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/blocks/pillar.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/blocks/pillarActive.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/blocks/spikes.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/blocks/spikes2.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/blocks/trap2.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/blocks/trap3.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/basic_staff.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/crystal_item.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/crystal_stand_item.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/enchantedSceptre.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/fire_amulet.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/fire_amulet_overlay.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/itemPillar.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/itemTrap.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mushroom.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mushroom_overlay.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_1.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_10.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_11.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_12.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_13.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_2.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_3.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_4.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_5.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_6.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_7.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_8.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_9.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_1.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_10.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_11.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_12.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_13.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_2.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_3.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_4.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_5.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_6.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_7.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_8.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_9.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/sceptre.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/scroll.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/star_amulet.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/star_amulet_overlay.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/trap2.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/trap3.png create mode 100644 src/main/resources/assets/fyresmodjam/textures/items/unenchantedSceptre.png create mode 100644 src/main/resources/mcmod.info create mode 100644 src/main/resources/pack.mcmeta (limited to 'src') diff --git a/src/main/java/fyresmodjam/ClientProxy.java b/src/main/java/fyresmodjam/ClientProxy.java new file mode 100644 index 0000000..1fff87e --- /dev/null +++ b/src/main/java/fyresmodjam/ClientProxy.java @@ -0,0 +1,169 @@ +package fyresmodjam; + +import fyresmodjam.handlers.ClientTickHandler; +import fyresmodjam.handlers.FyresKeyHandler; +import fyresmodjam.handlers.NewPacketHandler; +import net.minecraft.client.Minecraft; +import net.minecraft.util.math.RayTraceResult; +import net.minecraft.world.World; +import net.minecraftforge.client.event.RenderGameOverlayEvent; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.config.Configuration; +import net.minecraftforge.fml.common.FMLCommonHandler; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; + +public class ClientProxy extends CommonProxy { + + @SubscribeEvent + public void guiRenderEvent(RenderGameOverlayEvent.Post event) { + if (event.getType() == RenderGameOverlayEvent.ElementType.HOTBAR) { + RayTraceResult mouse = Minecraft + .getMinecraft().objectMouseOver; + + World world = Minecraft.getMinecraft().world; + + /* + if (mouse != null && world != null + && mouse.typeOfHit == RayTraceResult.Type.BLOCK) { + TileEntity te = world.getTileEntity(mouse.getBlockPos()); + Block id = te.getWorld().getBlockState(mouse.getBlockPos()).getBlock(); + + if (id == ModjamMod.blockPillar + || (id == ModjamMod.blockTrap + && te != null + && te instanceof TileEntityTrap + && ((TileEntityTrap) te).placedBy != null)) { + String key = Keyboard.getKeyName( + FyresKeyHandler.examine + .getKeyCode()); + String string = "Press " + key + + " to Examine"; + + if (te != null && Minecraft + .getMinecraft().player != null + && te instanceof TileEntityTrap + && ((TileEntityTrap) te).placedBy + .equals(Minecraft + .getMinecraft().player.getName())) { + string = Minecraft + .getMinecraft().player + .isSneaking() ? "Use to disarm (Stand to toggle setting)" + : "Use to toggle setting (Sneak to disarm)"; + } + + Minecraft.getMinecraft().fontRenderer + .drawStringWithShadow( + string, + (event.getResolution() + .getScaledWidth() + / 2) + - (Minecraft.getMinecraft().fontRenderer + .getStringWidth(string) + / 2), + event.getResolution().getScaledHeight() + / 2 + + 16, + Color.WHITE.getRGB()); + } + } + + if (Minecraft.getMinecraft().player != null) { + EntityPlayer player = Minecraft + .getMinecraft().player; + + player.world.getBlockState(player.getPosition()).getBlock().getMetaFromState(player.world.getBlockState(player.getPosition())); + if (BlessingUtils.hasBlessing(player)) { + if (BlessingUtils.hasBlessing( + player, + "BlessingBerserker")) { + if (!EntityStatHelper + .hasStat(player, "BlessingCounter")) { + EntityStatHelper.giveStat( + player, + "BlessingCounter", + 0); + } + + String string = EntityStatHelper + .getStat(player, "BlessingCounter"); + Minecraft.getMinecraft().fontRenderer + .drawStringWithShadow( + string, + (event.getResolution() + .getScaledWidth() + / 2) + - (Minecraft.getMinecraft().fontRenderer + .getStringWidth(string) + / 2), + event.getResolution().getScaledHeight() + - 48 + + (player.capabilities.isCreativeMode + ? 16 + : 0), + Color.RED.getRGB()); + } + } + } */ + } + + } + + @SuppressWarnings("unchecked") + @Override + public void register() { + ClientTickHandler clientHandler = new ClientTickHandler(); + FMLCommonHandler.instance().bus().register(clientHandler); + + FMLCommonHandler.instance().bus() + .register(new FyresKeyHandler()); + + /* + ClientRegistry.bindTileEntitySpecialRenderer( + TileEntityPillar.class, + new TileEntityPillarRenderer()); + ClientRegistry.bindTileEntitySpecialRenderer( + TileEntityTrap.class, + new TileEntityTrapRenderer()); + ClientRegistry.bindTileEntitySpecialRenderer( + TileEntityCrystal.class, + new TileEntityCrystalRenderer()); + ClientRegistry.bindTileEntitySpecialRenderer( + TileEntityCrystalStand.class, + new TileEntityCrystalStandRenderer()); + + RenderingRegistry.registerEntityRenderingHandler( + EntityMysteryPotion.class, + new RenderMysteryPotion( + ModjamMod.mysteryPotion)); + */ + MinecraftForge.EVENT_BUS.register(this); + } + + @Override + public void sendPlayerMessage(String message) { + NewPacketHandler.SEND_MESSAGE.data = new Object[] { + message + }; + + NewPacketHandler.SEND_MESSAGE.executeClient( + Minecraft.getMinecraft().player); + } + + @Override + public void loadFromConfig(Configuration config) { + super.loadFromConfig(config); + + ModjamMod.examineKey = config + .get("Keybindings", "examine_key", + ModjamMod.examineKey) + .getInt(ModjamMod.examineKey); + ModjamMod.blessingKey = config + .get("Keybindings", "blessing_key", + ModjamMod.blessingKey) + .getInt(ModjamMod.blessingKey); + + FyresKeyHandler.examine.setKeyCode(ModjamMod.examineKey); + FyresKeyHandler.activateBlessing + .setKeyCode(ModjamMod.blessingKey); + } +} diff --git a/src/main/java/fyresmodjam/CommonProxy.java b/src/main/java/fyresmodjam/CommonProxy.java new file mode 100644 index 0000000..8d26293 --- /dev/null +++ b/src/main/java/fyresmodjam/CommonProxy.java @@ -0,0 +1,97 @@ +package fyresmodjam; + +import net.minecraftforge.common.config.Configuration; + +public class CommonProxy { + public void register() { + } + + public void sendPlayerMessage(String message) { + } + + public void loadFromConfig(Configuration config) { + ModjamMod.pillarGlow = config + .get(Configuration.CATEGORY_GENERAL, + "pillar_glow", + ModjamMod.pillarGlow) + .getBoolean(ModjamMod.pillarGlow); + + ModjamMod.pillarGenChance = config + .get(Configuration.CATEGORY_GENERAL, + "pillar_gen_difficulty", + ModjamMod.pillarGenChance) + .getInt(); + ModjamMod.maxPillarsPerChunk = config.get( + Configuration.CATEGORY_GENERAL, + "max_pillars_per_chunk", + ModjamMod.maxPillarsPerChunk).getInt(); + ModjamMod.towerGenChance = config + .get(Configuration.CATEGORY_GENERAL, + "tower_gen_difficulty", + ModjamMod.towerGenChance) + .getInt(); + ModjamMod.trapGenChance = config + .get(Configuration.CATEGORY_GENERAL, + "trap_gen_difficulty", + ModjamMod.trapGenChance) + .getInt(); + ModjamMod.mushroomReplaceChance = config.get( + Configuration.CATEGORY_GENERAL, + "mushroom_replace_difficulty", + ModjamMod.mushroomReplaceChance).getInt(); + + ModjamMod.spawnTraps = !(config + .get(Configuration.CATEGORY_GENERAL, + "disable_traps", + !ModjamMod.spawnTraps) + .getBoolean(!ModjamMod.spawnTraps)); + ModjamMod.spawnTowers = config + .get(Configuration.CATEGORY_GENERAL, + "spawn_towers", + ModjamMod.spawnTowers) + .getBoolean(ModjamMod.spawnTowers); + ModjamMod.spawnRandomPillars = config.get( + Configuration.CATEGORY_GENERAL, + "spawn_random_pillars", + ModjamMod.spawnRandomPillars) + .getBoolean(ModjamMod.spawnRandomPillars); + ModjamMod.disableDisadvantages = config.get( + Configuration.CATEGORY_GENERAL, + "disable_disadvantages", + ModjamMod.disableDisadvantages) + .getBoolean(ModjamMod.disableDisadvantages); + ModjamMod.versionChecking = config + .get(Configuration.CATEGORY_GENERAL, + "version_checking", + ModjamMod.versionChecking) + .getBoolean(ModjamMod.versionChecking); + + ModjamMod.showAllPillarsInCreative = config.get( + Configuration.CATEGORY_GENERAL, + "show_all_pillars_in_creative", + ModjamMod.showAllPillarsInCreative) + .getBoolean(ModjamMod.showAllPillarsInCreative); + + ModjamMod.enableMobKillStats = config.get( + Configuration.CATEGORY_GENERAL, + "enable_mob_kill_stats", + ModjamMod.enableMobKillStats) + .getBoolean(ModjamMod.enableMobKillStats); + ModjamMod.enableWeaponKillStats = config.get( + Configuration.CATEGORY_GENERAL, + "enable_weapon_kill_stats", + ModjamMod.enableWeaponKillStats) + .getBoolean(ModjamMod.enableWeaponKillStats); + ModjamMod.enableCraftingStats = config.get( + Configuration.CATEGORY_GENERAL, + "enable_crafting_stats", + ModjamMod.enableCraftingStats) + .getBoolean(ModjamMod.enableCraftingStats); + + ModjamMod.trapsBelowGroundOnly = config.get( + Configuration.CATEGORY_GENERAL, + "traps_below_ground_only", + ModjamMod.trapsBelowGroundOnly) + .getBoolean(ModjamMod.trapsBelowGroundOnly); + } +} diff --git a/src/main/java/fyresmodjam/EntityLevelStat.java b/src/main/java/fyresmodjam/EntityLevelStat.java new file mode 100644 index 0000000..ee2d72e --- /dev/null +++ b/src/main/java/fyresmodjam/EntityLevelStat.java @@ -0,0 +1,183 @@ +package fyresmodjam; + +import java.util.Random; + +import fyresmodjam.blessings.BlessingUtils; +import fyresmodjam.misc.EntityStat; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.SharedMonsterAttributes; +import net.minecraft.entity.monster.EntityCreeper; + +public final class EntityLevelStat extends EntityStat { + public EntityLevelStat(String name, String value) { + super(name, value); + } + + @Override + public Object getNewValue(Random r) { + for (int i = 1;; i++) { + if (ModjamMod.r.nextInt( + 5 * (Math.max(1, i / 5))) < 3) { + return i; + } + } + } + + @Override + public String getAlteredEntityName(EntityLiving entity) { + int level = 1; + + try { + level = Integer.parseInt(entity.getEntityData() + .getString(name)); + } catch (Exception e) { + e.printStackTrace(); + } + + String baseName = ""; + + if (BlessingUtils.hasDisadvantage("Organized Foes")) { + baseName += "Level " + level + " "; + + switch (level) { + case 2: + baseName = "Private"; + break; + case 3: + baseName = "Corporal"; + break; + case 4: + baseName = "Sergeant"; + break; + case 5: + baseName = "Lieutenant"; + break; + case 6: + baseName = "Captain"; + break; + case 7: + baseName = "Major"; + break; + case 8: + baseName = "Colonel"; + break; + case 9: + baseName = "General"; + default: + if (level > 9) { + baseName = "Field Marshal"; + } else { + baseName = "Unelisted"; + } + } + + if (!baseName.equals("Unelisted")) { + baseName += " "; + } + + baseName += entity.getName(); + } else { + baseName = (level == 5 ? "\u00A7c" : "") + + entity.getName() + ", Level " + + level; + } + + return baseName; + } + + @Override + public void modifyEntity(Entity entity) { + int level = 1; + + try { + level = Integer.parseInt(entity.getEntityData() + .getString(name)); + } catch (Exception e) { + e.printStackTrace(); + } + + int healthGain = calculateMobHealthGain(entity, level); + + if (healthGain != 0) { + ((EntityLivingBase) entity).getEntityAttribute( + SharedMonsterAttributes.MAX_HEALTH) + .setBaseValue(((EntityLivingBase) entity) + .getMaxHealth() + + healthGain); + ((EntityLivingBase) entity).setHealth( + ((EntityLivingBase) entity) + .getMaxHealth() + + healthGain); + } + + if (level >= 5) { + blessMob(entity); + } else if (BlessingUtils.hasDisadvantage("Diabolic") + && ModjamMod.r.nextInt(20) == 0) { + blessMob(entity); + } + + if (BlessingUtils.hasDisadvantage("Organized Mobs")) { + equipMob((EntityLivingBase) entity, level); + } + } + + private void equipMob(EntityLivingBase entity, int level) { + if (level < 2) { + return; + } + + float regionalDifficulty = entity.world + .getDifficultyForLocation( + entity.getPosition()).getClampedAdditionalDifficulty(); + + int adjustedDifficulty = (int) Math + .ceil(level + regionalDifficulty); + + if (ModjamMod.r.nextInt(10) == 0 + || adjustedDifficulty > 5) { + } + + // TODO actually implement this + } + + private int calculateMobHealthGain(Entity entity, int level) { + int levelBase = level - 1; + float adjustedMaxHealth = ((EntityLivingBase) entity) + .getMaxHealth() / 4; + + float bonusLevel5Health; + + if (level >= 5) { + bonusLevel5Health = ((EntityLivingBase) entity) + .getMaxHealth() / 4; + + bonusLevel5Health *= Math.max(1, level / 5); + } else { + bonusLevel5Health = 0; + } + + return (int) ((levelBase * adjustedMaxHealth) + + bonusLevel5Health); + } + + private void blessMob(Entity entity) { + String chosenBlessing = BlessingUtils.getMobBlessing(); + + entity.getEntityData().setString("Blessing", + chosenBlessing); + + BlessingUtils.getBlessingInstance(chosenBlessing) + .correctBlessing(entity); + + if (entity instanceof EntityCreeper) { + // TODO is it fine to comment this out? + //((EntityCreeper) entity).getDataWatcher() + // .updateObject(17, (byte) 1); + ((EntityCreeper) entity).getEntityData() + .setBoolean("powered", true); + } + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/ModjamMod.java b/src/main/java/fyresmodjam/ModjamMod.java new file mode 100644 index 0000000..4e9c50f --- /dev/null +++ b/src/main/java/fyresmodjam/ModjamMod.java @@ -0,0 +1,626 @@ +package fyresmodjam; + +import java.io.File; +import java.util.EnumMap; +import java.util.Random; + +import org.lwjgl.input.Keyboard; + +import fyresmodjam.blessings.Blessing; +import fyresmodjam.blessings.BlessingUtils; +import fyresmodjam.commands.CommandCraftingStats; +import fyresmodjam.commands.CommandCurrentBlessing; +import fyresmodjam.commands.CommandCurrentDisadvantage; +import fyresmodjam.commands.CommandCurrentWorldTask; +import fyresmodjam.commands.CommandKillStats; +import fyresmodjam.commands.CommandWeaponStats; +import fyresmodjam.handlers.CommonTickHandler; +import fyresmodjam.handlers.GUIHandler; +import fyresmodjam.handlers.NewPacketHandler; +import fyresmodjam.handlers.NewPacketHandler.ChannelHandler; + +import fyresmodjam.misc.ArmorStatTracker; +import fyresmodjam.misc.CreativeTabModjamMod; +import fyresmodjam.misc.EntityStat; +import fyresmodjam.misc.EntityStatHelper; +import fyresmodjam.misc.EntityStatTracker; +import fyresmodjam.misc.ItemStatHelper; +import fyresmodjam.misc.ItemStatTracker; +import fyresmodjam.misc.WeaponRankStat; +import fyresmodjam.worldgen.FyresWorldData; +import net.minecraft.block.Block; +import net.minecraft.client.Minecraft; +import net.minecraft.command.CommandHandler; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.monster.EntityMob; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemArmor; +import net.minecraft.item.ItemAxe; +import net.minecraft.item.ItemBow; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemSword; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.config.Configuration; +import net.minecraftforge.event.AnvilUpdateEvent; +import net.minecraftforge.event.entity.player.PlayerEvent; +import net.minecraftforge.fml.common.FMLCommonHandler; +import net.minecraftforge.fml.common.Mod; +import net.minecraftforge.fml.common.Mod.EventHandler; +import net.minecraftforge.fml.common.Mod.Instance; +import net.minecraftforge.fml.common.SidedProxy; +import net.minecraftforge.fml.common.event.FMLInitializationEvent; +import net.minecraftforge.fml.common.event.FMLPostInitializationEvent; +import net.minecraftforge.fml.common.event.FMLPreInitializationEvent; +import net.minecraftforge.fml.common.event.FMLServerStartingEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerChangedDimensionEvent; +import net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerLoggedInEvent; +import net.minecraftforge.fml.common.network.FMLEmbeddedChannel; +import net.minecraftforge.fml.common.network.NetworkRegistry; +import net.minecraftforge.fml.common.registry.EntityRegistry; +import net.minecraftforge.fml.common.registry.GameRegistry; +import net.minecraftforge.fml.relauncher.Side; + +@Mod(modid = "fyresmodjam", name = "Fyres ModJam Mod", version = "0.0.3d") +public class ModjamMod extends CommandHandler { + @SidedProxy(clientSide = "fyresmodjam.ClientProxy", serverSide = "fyresmodjam.CommonProxy") + public static CommonProxy proxy; + + @Instance("fyresmodjam") + public static ModjamMod instance; + + public static EnumMap channels = NetworkRegistry.INSTANCE + .newChannel("YWDMod", new ChannelHandler()); + + public static Random r = new Random(); + + public static int achievementID = 2500, + examineKey = Keyboard.KEY_X, + blessingKey = Keyboard.KEY_K; + public static int pillarGenChance = 75, + maxPillarsPerChunk = 3, towerGenChance = 225, + trapGenChance = 300, mushroomReplaceChance = 15; + public static boolean pillarGlow = true, spawnTraps = true, + spawnTowers = true, spawnRandomPillars = true, + disableDisadvantages = false, + versionChecking = true, + trapsBelowGroundOnly = false, + showAllPillarsInCreative = false, + enableWeaponKillStats = true, + enableMobKillStats = true, + enableCraftingStats = true; + + public static CreativeTabs tabModjamMod = new CreativeTabModjamMod( + CreativeTabs.getNextID(), + "The \"You Will Die\" Mod"); + + public static Block blockPillar; + public static Block blockTrap; + public static Block mysteryMushroomBlock; + + public static Item itemPillar; + public static Item mysteryPotion; + public static Item itemTrap; + public static Item mysteryMushroom; + public static Item sceptre; + + public static Item crystalItem; + public static Item scroll; + + public static Block crystal; + public static Block crystalStand; +/* + public static Achievement startTheGame; + public static Achievement losingIsFun; + public static Achievement whoops; + + public static Achievement theHunt; + public static Achievement jackOfAllTrades; + + public static AchievementPage page; + + */ + public static String version = "v0.0.3e"; + public static String foundVersion = "v0.0.3e"; + public static boolean newerVersion = false; + + public static String configPath = null; + + @EventHandler + public void preInit(FMLPreInitializationEvent event) { + File old = new File(event.getSuggestedConfigurationFile() + .getAbsolutePath() + .replace("fyresmodjam", "YouWillDieMod")); + + if (old.exists()) { + old.delete(); + System.out.println(true); + } + + configPath = event.getSuggestedConfigurationFile() + .getAbsolutePath().replace("fyresmodjam", + "TheYouWillDieMod"); + + Configuration config = new Configuration( + new File(configPath)); + + config.load(); + + proxy.loadFromConfig(config); + + config.save(); + + // Item and Block loading + + /* + blockPillar = new BlockPillar().setBlockUnbreakable() + .setResistance(6000000.0F); + blockTrap = new BlockTrap().setBlockUnbreakable() + .setResistance(6000000.0F); + mysteryMushroomBlock = new BlockMysteryMushroom() + .setHardness(0.0F) +// .setStepSound(Block.soundTypeGrass) + .setLightLevel(0.125F) + .setRegistryName("mysteryMushroomBlock"); + + itemPillar = new ItemPillar() + .setUnlocalizedName("blockPillar"); + GameRegistry.registerItem(itemPillar, "itemPillar"); + + mysteryPotion = new ItemMysteryPotion() + .setUnlocalizedName("mysteryPotion") + .setCreativeTab(CreativeTabs.BREWING); + GameRegistry.registerItem(mysteryPotion, "mysteryPotion"); + + itemTrap = new ItemTrap().setUnlocalizedName("itemTrap") + .setCreativeTab(CreativeTabs.REDSTONE); + GameRegistry.registerItem(itemTrap, "itemTrap"); + + mysteryMushroom = new ItemMysteryMushroom() + .setUnlocalizedName("mysteryMushroom") + .setCreativeTab(CreativeTabs.BREWING); + GameRegistry.registerItem(mysteryMushroom, + "mysteryMushroom"); + + sceptre = new ItemObsidianSceptre() + .setUnlocalizedName("sceptre") + .setCreativeTab(CreativeTabs.TOOLS) + .setFull3D(); + GameRegistry.registerItem(sceptre, "sceptre"); + + GameRegistry.registerBlock(blockPillar, "blockPillar"); + GameRegistry.registerTileEntity(TileEntityPillar.class, + "Pillar Tile Entity"); + + GameRegistry.registerBlock(blockTrap, "blockTrap"); + GameRegistry.registerTileEntity(TileEntityTrap.class, + "Trap Entity"); + + GameRegistry.registerBlock(mysteryMushroomBlock, + "mysteryMushroomBlock"); + + */ + + /* + startTheGame = getNewAchievement(achievementID, 0, 0, + new ItemStack(Items.iron_sword, 1), + "startTheGame", "You Will Die", + "Join a world with this mod installed", + null, true); + losingIsFun = getNewAchievement(achievementID + 1, -2, 0, + new ItemStack(itemTrap, 1), "losingIsFun", + "Losing Is Fun", "Experience \"fun\"", + startTheGame, false); + whoops = getNewAchievement(achievementID + 2, 2, 0, + new ItemStack(itemTrap, 1, 1), "whoops", + "Whoops", "Fail to disarm a trap", + startTheGame, false); + + theHunt = getNewAchievement(achievementID + 3, 0, -2, + new ItemStack(Items.bow, 1), "theHunt", + "The Hunt", + "Become a competent slayer of 5 or more different creatures", + startTheGame, false); + jackOfAllTrades = getNewAchievement(achievementID + 4, 0, + 2, new ItemStack(Blocks.crafting_table, 1), + "jackOfAllTrades", "Jack of All Trades", + "Become a novice user of at least 10 different weapons", + startTheGame, false); + + page = new AchievementPage("The \"You Will Die\" Mod", + startTheGame, losingIsFun, whoops, theHunt, + jackOfAllTrades); + + AchievementPage.registerAchievementPage(page); + */ + } + + @EventHandler + public void init(FMLInitializationEvent event) { + + // Registering + + CommonTickHandler commonHandler = new CommonTickHandler(); + FMLCommonHandler.instance().bus().register(commonHandler); + + MinecraftForge.EVENT_BUS.register(this); + FMLCommonHandler.instance().bus().register(this); + + new ItemStatHelper().register(); + new EntityStatHelper().register(); + + NetworkRegistry.INSTANCE.registerGuiHandler(this, + new GUIHandler()); + + /* + GameRegistry.registerWorldGenerator(new PillarGen(), 0); + + GameRegistry.registerWorldGenerator( + new WorldGenTrapsTowersAndMore(), 0); + + for (int i = 0; i < 3; i++) { + GameRegistry.registerWorldGenerator( + new WorldGenMoreDungeons(), 0); + } + */ + //EntityRegistry.registerGlobalEntityID( + // EntityMysteryPotion.class, "MysteryPotion", + // EntityRegistry.findGlobalUniqueEntityId()); + + // TODO ensure this is right + ResourceLocation loc = new ResourceLocation("MysteryPotion"); + /* + EntityRegistry.registerModEntity(loc, EntityMysteryPotion.class, + "MysteryPotion", 0, instance, 128, 1, + true); + */ + // TODO figure out how to do this + /* + GameRegistry.addShapelessRecipe( + new ItemStack(itemTrap, 1, 0), + new Object[] { + Blocks.heavy_weighted_pressure_plate, + Blocks.cactus + }); + GameRegistry.addShapelessRecipe( + new ItemStack(itemTrap, 1, 1), + new Object[] { + Blocks.heavy_weighted_pressure_plate, + Blocks.torch + }); + GameRegistry.addShapelessRecipe( + new ItemStack(itemTrap, 1, 2), + new Object[] { + Blocks.heavy_weighted_pressure_plate, + new ItemStack(Items.dye, 1, + 0) + }); + + for (int i = 0; i < 13; i++) { + GameRegistry.addShapelessRecipe( + new ItemStack(mysteryPotion, 1, + i + 13), + new Object[] { + new ItemStack(mysteryPotion, + 1, + i), + Items.gunpowder + }); + GameRegistry.addShapelessRecipe( + new ItemStack(mysteryPotion, 1, i), + new Object[] { + new ItemStack(Items.potionitem, + 1, + 0), + Items.leather, + new ItemStack(mysteryMushroom, + 1, + i) + }); + } + + GameRegistry.addRecipe(new ItemStack(sceptre, 1, 0), "X", + "Y", "X", 'X', Blocks.obsidian, 'Y', + Blocks.end_stone); + GameRegistry.addShapelessRecipe( + new ItemStack(sceptre, 1, 1), + new Object[] { + new ItemStack(sceptre, 1, + 0), + Items.ender_pearl, + Items.book + }); + */ + proxy.register(); + + // Entity Trackers + EntityStatTracker playerTracker = new EntityStatTracker( + EntityPlayer.class, true); + + playerTracker.addStat(new EntityStat("BlessingCooldown", + "" + 0)); + playerTracker.addStat( + new EntityStat("BlessingCounter", "" + 0)); + + EntityStatTracker mobTracker = new EntityStatTracker( + EntityMob.class, true); + + mobTracker.addStat(new EntityLevelStat("Level", "")); + + EntityStatHelper.addStatTracker(mobTracker); + + // Item Trackers + + ItemStatTracker weaponTracker = new ItemStatTracker( + new Class[] { + ItemSword.class, + ItemAxe.class, + ItemBow.class + }, true); + + weaponTracker.addStat(new WeaponRankStat("Rank", "")); + + ItemStatHelper.addStatTracker(weaponTracker); + + ItemStatTracker armorTracker = new ItemStatTracker( + new Class[] { + ItemArmor.class + }, true); + + armorTracker.addStat(new ArmorStatTracker("Rank", "")); + + ItemStatHelper.addStatTracker(armorTracker); + + // Other + + for (int i = 0; i < 13; i++) { + /* + ChestGenHooks.getInfo(ChestGenHooks.DUNGEON_CHEST) + .addItem(new WeightedRandomChestContent( + mysteryPotion, i, + 1, 3, 2)); + WorldGenTrapsTowersAndMore.chestGenInfo.addItem( + new WeightedRandomChestContent( + mysteryPotion, i, + 1, 3, 2)); + */ + } + } + + @EventHandler + public void postInit(FMLPostInitializationEvent event) { + + } + + @SubscribeEvent + public void onPlayerLogin(PlayerLoggedInEvent event) { + EntityPlayer player = event.player; + + if (!player.world.isRemote) { + NewPacketHandler.UPDATE_WORLD_DATA.sendToPlayer( + player, + CommonTickHandler.worldData.potionValues, + CommonTickHandler.worldData.potionDurations, + CommonTickHandler.worldData + .getDisadvantage(), + CommonTickHandler.worldData.currentTask, + CommonTickHandler.worldData.currentTaskID, + CommonTickHandler.worldData.currentTaskAmount, + CommonTickHandler.worldData.progress, + CommonTickHandler.worldData.tasksCompleted, + CommonTickHandler.worldData.enderDragonKilled, + ModjamMod.spawnTraps, + CommonTickHandler.worldData.rewardLevels, + CommonTickHandler.worldData.mushroomColors); + + String name = CommonTickHandler.worldData.currentTask + .equals("Kill") ? FyresWorldData.validMobNames[CommonTickHandler.worldData.currentTaskID] + : FyresWorldData.validItems[CommonTickHandler.worldData.currentTaskID] + .getDisplayName(); + + if (CommonTickHandler.worldData.currentTaskAmount > 1) { + if (name.contains("Block")) { + name = name.replace("Block", + "Blocks") + .replace("block", + "blocks"); + } else { + name += "s"; + } + } + + int index = -1; + for (int i = 0; i < FyresWorldData.validDisadvantages.length; i++) { + if (FyresWorldData.validDisadvantages[i] + .equals(CommonTickHandler.worldData + .getDisadvantage())) { + index = i; + break; + } + } + + /* + * @TODO move disadvantages into a class + */ + NewPacketHandler.SEND_MESSAGE.sendToPlayer(player, + "\u00A7eWorld disadvantage: " + + CommonTickHandler.worldData + .getDisadvantage() + + (index == -1 ? "" + : " (" + FyresWorldData.disadvantageDescriptions[index] + + ")")); + + NewPacketHandler.SEND_MESSAGE.sendToPlayer(player, + "\u00A7eWorld goal: " + + CommonTickHandler.worldData.currentTask + + " " + + CommonTickHandler.worldData.currentTaskAmount + + " " + name + + ". (" + + CommonTickHandler.worldData.progress + + " " + + CommonTickHandler.worldData.currentTask + + "ed)"); + + if (!BlessingUtils.hasBlessing(player)) { + String selectedBlessing = BlessingUtils + .getPlayerBlessing(); + Blessing blessing = BlessingUtils + .getBlessingInstance( + selectedBlessing); + + player.getEntityData().setString( + "Blessing", + selectedBlessing); + + NewPacketHandler.SEND_MESSAGE.sendToPlayer( + player, + "\u00A72You've been granted the " + + blessing.customName() + + ". (Use /currentBlessing to check effect)"); + } + + NewPacketHandler.UPDATE_BLESSING.sendToPlayer( + player, + player.getEntityData().getString( + "Blessing")); + + if (EntityStatHelper.hasStat(player, + "BlessingCounter")) { + NewPacketHandler.UPDATE_STAT.sendToPlayer( + player, "BlessingCounter", + EntityStatHelper.getStat( + player, + "BlessingCounter")); + } + + if (!player.getEntityData() + .hasKey("PotionKnowledge")) { + player.getEntityData().setIntArray( + "PotionKnowledge", + new int[] { + -1, -1, -1, + -1, -1, -1, + -1, -1, -1, + -1, -1, -1 + }); + } + + NewPacketHandler.UPDATE_POTION_KNOWLEDGE + .sendToPlayer(player, player + .getEntityData() + .getIntArray("PotionKnowledge")); + } + + if (versionChecking && newerVersion) { + // TODO see how chat works + //player.addChatComponentMessage( + // new ChatComponentTranslation( + // "fyresmodjam.newVersion")); + } + + //player.triggerAchievement(startTheGame); + } + + @SubscribeEvent + public void onPlayerChangedDimension( + PlayerChangedDimensionEvent event) { + EntityPlayer player = event.player; + + NewPacketHandler.UPDATE_WORLD_DATA.sendToPlayer(player, + CommonTickHandler.worldData.potionValues, + CommonTickHandler.worldData.potionDurations, + CommonTickHandler.worldData + .getDisadvantage(), + CommonTickHandler.worldData.currentTask, + CommonTickHandler.worldData.currentTaskID, + CommonTickHandler.worldData.currentTaskAmount, + CommonTickHandler.worldData.progress, + CommonTickHandler.worldData.tasksCompleted, + CommonTickHandler.worldData.enderDragonKilled, + ModjamMod.spawnTraps, + CommonTickHandler.worldData.rewardLevels, + CommonTickHandler.worldData.mushroomColors); + + NewPacketHandler.UPDATE_BLESSING.sendToPlayer(player, + BlessingUtils.getBlessing(player)); + + if (EntityStatHelper.hasStat(player, "BlessingCounter")) { + NewPacketHandler.UPDATE_STAT.sendToPlayer(player, + "BlessingCounter", + EntityStatHelper.getStat(player, + "BlessingCounter")); + } + + if (!player.getEntityData().hasKey("PotionKnowledge")) { + player.getEntityData().setIntArray( + "PotionKnowledge", new int[] { + -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, + -1, -1 + }); + } + + NewPacketHandler.UPDATE_POTION_KNOWLEDGE.sendToPlayer( + player, player.getEntityData().getIntArray( + "PotionKnowledge")); + } + + @SubscribeEvent + public void checkBreakSpeed(PlayerEvent.BreakSpeed event) { + if (event.getEntityPlayer() != null && BlessingUtils + .hasBlessing(event.getEntityPlayer())) { + BlessingUtils.getBlessingInstance(BlessingUtils + .getBlessing(event.getEntityPlayer())) + .checkBreakSpeed(event); + } + } + + @EventHandler + public void serverStarting(FMLServerStartingEvent event) { + initCommands(event); + } + + public void initCommands(FMLServerStartingEvent event) { + event.registerServerCommand(new CommandCurrentBlessing()); + event.registerServerCommand( + new CommandCurrentDisadvantage()); + event.registerServerCommand(new CommandCurrentWorldTask()); + event.registerServerCommand(new CommandKillStats()); + event.registerServerCommand(new CommandWeaponStats()); + event.registerServerCommand(new CommandCraftingStats()); + } + + @Override + protected MinecraftServer getServer() { + // TODO is this right? + return Minecraft.getMinecraft().getIntegratedServer(); + } + + /* + @SuppressWarnings("deprecation") + public static Achievement getNewAchievement(int id, int x, int y, + ItemStack stack, String name, String displayName, + String desc, Achievement prereq, + boolean independent) { + Achievement achievement = new Achievement("YWD-" + id, + name, x, y, stack, prereq); + if (independent) { + achievement = achievement.initIndependentStat(); + } + LanguageRegistry.instance().addStringLocalization( + "achievement." + name, "en_US", + displayName); + LanguageRegistry.instance().addStringLocalization( + "achievement." + name + ".desc", "en_US", + desc); + achievement.registerStat(); + return achievement; + } + */ +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/blessings/Blessing.java b/src/main/java/fyresmodjam/blessings/Blessing.java new file mode 100644 index 0000000..4c5e6a1 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/Blessing.java @@ -0,0 +1,119 @@ +package fyresmodjam.blessings; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.event.entity.living.LivingDeathEvent; +import net.minecraftforge.event.entity.living.LivingHurtEvent; +import net.minecraftforge.event.entity.player.PlayerEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.ServerTickEvent; + +/** + * Represents a blessing bestowed to a player. + * + * @author bjculkin + */ +public abstract class Blessing { + private static int nextOrdinal = 0; + + public final int ordinal; + + protected Blessing() { + ordinal = nextOrdinal++; + } + + public boolean hasCustomName() { + return false; + } + + public String customName() { + return "Blessing of the " + name(); + } + + /** + * Get the name of this blessing. + * + * @return The name of this blessing. + */ + public abstract String name(); + + /** + * Get the description of this blessing. + * + * @return The description of this blessing. + */ + public abstract String description(); + + /** + * Modify the player's break speed. + * + * @param pebsev + * The break speed event. + */ + public void checkBreakSpeed(PlayerEvent.BreakSpeed pebsev) { + return; + } + + /** + * Correct inappropriate blessings for mobs. + * + * @param ent + * The mob to correct for. + */ + public void correctBlessing(Entity ent) { + return; + } + + /** + * Do something on every tick. + * + * @param stev + * The tick event + */ + public void commonTick(ServerTickEvent stev, EntityPlayer play) { + return; + } + + /** + * Handle adjusting the damage multiplier for mob knowledge. + * + * @param lhev + * The event being dealt with. + * + * @param pickedDamageBonus + * The base damage bonus for mob knowledge. + * + * @return + * The new damage bonus for mob knowledge + */ + public float adjustMobKnowledgeBonus(LivingHurtEvent lhev, float pickedDamageBonus) { + return pickedDamageBonus; + } + + /** + * Handle adjusting the damage multiplier for weapon knowledge. + * + * @param lhev + * The event being dealt with. + * + * @param pickedDamageBonus + * The base damage bonus for weapon knowledge. + * + * @return + * The new damage bonus for weapon knowledge + */ + public float adjustWeaponKnowledgeBonus(LivingHurtEvent lhev, float pickedDamageBonus) { + return pickedDamageBonus; + } + + public float onIncomingDamage(LivingHurtEvent lhev, float damageMultiplier) { + return damageMultiplier; + } + + public float onOutgoingDamage(LivingHurtEvent event, float damageMultiplier) { + return damageMultiplier; + } + + public void onMobKill(LivingDeathEvent event) { + return; + } +} diff --git a/src/main/java/fyresmodjam/blessings/BlessingUtils.java b/src/main/java/fyresmodjam/blessings/BlessingUtils.java new file mode 100644 index 0000000..c240a7a --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/BlessingUtils.java @@ -0,0 +1,216 @@ +package fyresmodjam.blessings; + +import java.util.HashMap; +import java.util.Map; + +import fyresmodjam.ModjamMod; +import fyresmodjam.handlers.CommonTickHandler; +import fyresmodjam.misc.EntityStatHelper; + +import fyresmodjam.blessings.marks.*; +import fyresmodjam.blessings.standard.*; + +import net.minecraft.entity.Entity; +import net.minecraft.nbt.NBTTagCompound; + +public class BlessingUtils { + public final static Map playerBlessings; + public final static Map mobBlessings; + + static { + playerBlessings = new HashMap(); + mobBlessings = new HashMap(); + + createStandardBlessings(); + createMarks(); + } + + private static void createMarks() { + BerserkingMark berserkingMark = new BerserkingMark(); + FalseLifeMark falseLifeMark = new FalseLifeMark(); + GuardingMark guardingMark = new GuardingMark(); + HuntingMark huntingMark = new HuntingMark(); + ScoutingMark scoutingMark = new ScoutingMark(); + VampirismMark vampirismMark = new VampirismMark(); + WarMark warMark = new WarMark(); + + addOmniBlessing("MarkBerserking", berserkingMark); + addOmniBlessing("MarkFalseLife", falseLifeMark); + addOmniBlessing("MarkGuarding", guardingMark); + addOmniBlessing("MarkHunting", huntingMark); + addOmniBlessing("MarkVampirism", vampirismMark); + addOmniBlessing("MarkWar", warMark); + + playerBlessings.put("MarkScouting", scoutingMark); + } + + private static void createStandardBlessings() { + AlchemistBlessing alchemistBlessing = new AlchemistBlessing(); + BerserkerBlessing berserkerBlessing = new BerserkerBlessing(); + GuardianBlessing guardianBlessing = new GuardianBlessing(); + HunterBlessing hunterBlessing = new HunterBlessing(); + InfernoBlessing infernoBlessing = new InfernoBlessing(); + LonerBlessing lonerBlessing = new LonerBlessing(); + ParatrooperBlessing paratrooperBlessing = new ParatrooperBlessing(); + PorcupineBlessing porcupineBlessing = new PorcupineBlessing(); + SwampBlessing swampBlessing = new SwampBlessing(); + ThickSkinnedBlessing thickSkinnedBlessing = new ThickSkinnedBlessing(); + VampireBlessing vampireBlessing = new VampireBlessing(); + WarriorBlessing warriorBlessing = new WarriorBlessing(); + DiverBlessing diverBlessing = new DiverBlessing(); + LooterBlessing looterBlessing = new LooterBlessing(); + LumberjackBlessing lumberjackBlessing = new LumberjackBlessing(); + MechanicBlessing mechanicBlessing = new MechanicBlessing(); + MinerBlessing minerBlessing = new MinerBlessing(); + NinjaBlessing ninjaBlessing = new NinjaBlessing(); + ScholarBlessing scholarBlessing = new ScholarBlessing(); + ThiefBlessing thiefBlessing = new ThiefBlessing(); + + addOmniBlessing("BlessingWarrior", warriorBlessing); + addOmniBlessing("BlessingHunter", hunterBlessing); + addOmniBlessing("BlessingSwamp", swampBlessing); + addOmniBlessing("BlessingGuardian", guardianBlessing); + addOmniBlessing("BlessingVampire", vampireBlessing); + addOmniBlessing("BlessingInferno", infernoBlessing); + addOmniBlessing("BlessingLoner", lonerBlessing); + addOmniBlessing("BlessingParatrooper", + paratrooperBlessing); + addOmniBlessing("BlessingPorcupine", porcupineBlessing); + addOmniBlessing("BlessingThick-Skinned", + thickSkinnedBlessing); + + PaladinBlessing paladinBlessing = new PaladinBlessing(); + + playerBlessings.put("BlessingAlchemist", + alchemistBlessing); + playerBlessings.put("BlessingBerserker", + berserkerBlessing); + playerBlessings.put("BlessingDiver", diverBlessing); + playerBlessings.put("BlessingLooter", looterBlessing); + playerBlessings.put("BlessingLumberjack", + lumberjackBlessing); + playerBlessings.put("BlessingMechanic", mechanicBlessing); + playerBlessings.put("BlessingMiner", minerBlessing); + playerBlessings.put("BlessingNinja", ninjaBlessing); + playerBlessings.put("BlessingPaladin", paladinBlessing); + playerBlessings.put("BlessingScholar", scholarBlessing); + playerBlessings.put("BlessingThief", thiefBlessing); + } + + private static void addOmniBlessing(String blessName, + Blessing blessInst) { + playerBlessings.put(blessName, blessInst); + mobBlessings.put(blessName, blessInst); + } + + public static boolean hasDisadvantage() { + if (CommonTickHandler.worldData != null) { + String currentDisadvantage = CommonTickHandler.worldData + .getDisadvantage(); + + return currentDisadvantage != null + && !(currentDisadvantage + .equals("")); + } + + return false; + } + + public static boolean hasDisadvantage(String disadvantage) { + if (hasDisadvantage()) { + return CommonTickHandler.worldData + .getDisadvantage() + .equals(disadvantage); + } + + return false; + } + + public static String getDisadvantage() { + return CommonTickHandler.worldData.currentDisadvantage; + } + + public static String getBlessing(Entity ent) { + return ent.getEntityData().getString("Blessing"); + } + + public static boolean hasBlessing(Entity ent) { + NBTTagCompound entityData = ent.getEntityData(); + + return entityData.hasKey("Blessing") && !(entityData + .getString("Blessing").equals("")); + } + + public static boolean hasBlessing(Entity ent, String blessing) { + if (hasBlessing(ent)) { + return ent.getEntityData().getString("Blessing") + .equals(blessing); + } + + return false; + } + + public static boolean hasBlessingCounter(Entity ent) { + return EntityStatHelper.hasStat(ent, "BlessingCounter"); + } + + public static int getBlessingCounter(Entity ent) { + return Integer.parseInt(EntityStatHelper.getStat(ent, + "BlessingCounter")); + } + + public static boolean isBlessingActive(Entity ent) { + return ent.getEntityData().hasKey("BlessingActive") + && ent.getEntityData().getBoolean( + "BlessingActive"); + } + + public static Blessing getBlessingInstance(String blessing) { + if (playerBlessings.containsKey(blessing)) { + return playerBlessings.get(blessing); + } else { + System.err.printf( + "ERROR: Blessing '%s' not found, using default blessing\n", + blessing); + return playerBlessings.get("BlessingGuardian"); + } + } + + public static String getPlayerBlessing() { + int n = ModjamMod.r.nextInt(playerBlessings.size()); + + int i = 0; + for (String blessing : playerBlessings.keySet()) { + if (i >= n) { + return blessing; + } + + i += 1; + } + + System.err.println( + "ERROR: Couldn't get blessing for player; using default."); + return "BlessingGuardian"; + } + + public static String getMobBlessing() { + int n = ModjamMod.r.nextInt(mobBlessings.size()); + + int i = 0; + for (String blessing : mobBlessings.keySet()) { + if (i >= n) { + return blessing; + } + + i += 1; + } + + System.err.println( + "ERROR: Couldn't get blessing for mob; using default."); + return "BlessingGuardian"; + } + + public static Blessing getBlessingInstance(Entity entity) { + return getBlessingInstance(getBlessing(entity)); + } +} diff --git a/src/main/java/fyresmodjam/blessings/marks/ArcaneNullityMark.java b/src/main/java/fyresmodjam/blessings/marks/ArcaneNullityMark.java new file mode 100644 index 0000000..3c127df --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/marks/ArcaneNullityMark.java @@ -0,0 +1,36 @@ +package fyresmodjam.blessings.marks; + +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class ArcaneNullityMark extends Mark { + + @Override + public String name() { + return "Arcane Nullity"; + } + + @Override + public String description() { + return "BENEFIT - Take no damage from magic\nDRAWBACK - Deal no damage with magic"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent lhev, + float damageMultiplier) { + if (lhev.getSource().isMagicDamage()) { + lhev.setCanceled(true); + } + + return damageMultiplier; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent lhev, + float damageMultiplier) { + if (lhev.getSource().isMagicDamage()) { + lhev.setCanceled(true); + } + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/marks/BerserkingMark.java b/src/main/java/fyresmodjam/blessings/marks/BerserkingMark.java new file mode 100644 index 0000000..a592175 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/marks/BerserkingMark.java @@ -0,0 +1,28 @@ +package fyresmodjam.blessings.marks; + +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class BerserkingMark extends Mark { + + @Override + public String name() { + return "Berserking"; + } + + @Override + public String description() { + return "BENEFIT - Deal greatly increased damage\nDRAWBACK - Take greatly increased damage"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + return damageMultiplier + .5f; + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, + float damageMultiplier) { + return damageMultiplier + .5f; + } +} diff --git a/src/main/java/fyresmodjam/blessings/marks/FalseLifeMark.java b/src/main/java/fyresmodjam/blessings/marks/FalseLifeMark.java new file mode 100644 index 0000000..88f467a --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/marks/FalseLifeMark.java @@ -0,0 +1,58 @@ +package fyresmodjam.blessings.marks; + +import net.minecraft.entity.SharedMonsterAttributes; +import net.minecraft.potion.Potion; +import net.minecraft.potion.PotionEffect; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class FalseLifeMark extends Mark { + + @Override + public String name() { + return "False Life"; + } + + @Override + public String description() { + return "BENEFIT - Rally from a fatal injury\nDRAWBACK - Lose permanent health to do so"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, + float damageMultiplier) { + float totalAmount = Math.max(0.5f, + event.getAmount() * damageMultiplier); + + if (totalAmount > event.getEntityLiving().getMaxHealth()) { + event.setCanceled(true); + + event.getEntityLiving().getEntityAttribute( + SharedMonsterAttributes.MAX_HEALTH) + .setBaseValue(event.getEntityLiving() + .getMaxHealth() + / 0.75f); + + event.getEntityLiving().setHealth( + event.getEntityLiving().getMaxHealth()); + + // TODO figure out potions + /* + event.getEntityLiving() + .addPotionEffect(new PotionEffect( + Potion.moveSpeed.id, + 30, 1)); + event.getEntityLiving() + .addPotionEffect(new PotionEffect( + Potion.resistance.id, + 20, 1)); + event.getEntityLiving() + .addPotionEffect(new PotionEffect( + Potion.damageBoost.id, + 20, 1)); + */ + return 0; + } + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/marks/GuardingMark.java b/src/main/java/fyresmodjam/blessings/marks/GuardingMark.java new file mode 100644 index 0000000..db4fc97 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/marks/GuardingMark.java @@ -0,0 +1,27 @@ +package fyresmodjam.blessings.marks; + +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class GuardingMark extends Mark { + @Override + public String name() { + return "Guarding"; + } + + @Override + public String description() { + return "BENEFIT - Take less damage\nDRAWBACK - Deal less damage"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + return damageMultiplier - 1f; + } + + @Override + public float onIncomingDamage(LivingHurtEvent lhev, + float damageMultiplier) { + return damageMultiplier - 1f; + } +} diff --git a/src/main/java/fyresmodjam/blessings/marks/HolyLightMark.java b/src/main/java/fyresmodjam/blessings/marks/HolyLightMark.java new file mode 100644 index 0000000..96d5bab --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/marks/HolyLightMark.java @@ -0,0 +1,32 @@ +package fyresmodjam.blessings.marks; + +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class HolyLightMark extends Mark { + + @Override + public String name() { + return "Holy Light"; + } + + @Override + public String description() { + return "BENEFIT - Deal greatly increased damage to undead\nDRAWBACK - Heal non-undead for a small amount"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.getEntityLiving().isEntityUndead()) { + return damageMultiplier + .5f; + } + + float healed = Math.max(0.5f, + (event.getAmount() * damageMultiplier) + * 0.25f); + + event.getEntityLiving().heal(healed); + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/marks/HuntingMark.java b/src/main/java/fyresmodjam/blessings/marks/HuntingMark.java new file mode 100644 index 0000000..b92ee7b --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/marks/HuntingMark.java @@ -0,0 +1,37 @@ +package fyresmodjam.blessings.marks; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.IRangedAttackMob; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class HuntingMark extends Mark { + + @Override + public String name() { + return "Hunting"; + } + + @Override + public String description() { + return "BENEFIT - Deal greatly increased damage with projectile weapons\nDRAWBACK - Deal less damage with all other weapons"; + } + + @Override + public void correctBlessing(Entity ent) { + if (!(ent instanceof IRangedAttackMob)) { + ent.getEntityData().setString("Blessing", + "MarkWar"); + } + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.getSource().isProjectile()) { + return damageMultiplier + 0.4f; + } + + return damageMultiplier - 0.2f; + } + +} diff --git a/src/main/java/fyresmodjam/blessings/marks/Mark.java b/src/main/java/fyresmodjam/blessings/marks/Mark.java new file mode 100644 index 0000000..0181fd8 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/marks/Mark.java @@ -0,0 +1,15 @@ +package fyresmodjam.blessings.marks; + +import fyresmodjam.blessings.Blessing; + +public abstract class Mark extends Blessing { + @Override + public boolean hasCustomName() { + return true; + } + + @Override + public String customName() { + return "Mark of " + name(); + } +} diff --git a/src/main/java/fyresmodjam/blessings/marks/RetaliationMark.java b/src/main/java/fyresmodjam/blessings/marks/RetaliationMark.java new file mode 100644 index 0000000..a0537b2 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/marks/RetaliationMark.java @@ -0,0 +1,57 @@ +package fyresmodjam.blessings.marks; + +import fyresmodjam.ModjamMod; +import fyresmodjam.misc.DamageSources; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class RetaliationMark extends Mark { + + private static final double RETALIATION_CHANCE = 0.05; + + @Override + public String name() { + return "Retaliation"; + } + + @Override + public String description() { + return "BENEFIT - Have a chance to reflect attacks\nDRAWBACK - Have a chance for your attacks to be reflected"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (!event.getSource().damageType.equals("retaliation")) { + // Don't retaliate for retaliation + if (ModjamMod.r.nextDouble() < RETALIATION_CHANCE) { + event.getEntityLiving().attackEntityFrom( + DamageSources.retaliation, + Math.max(0.5f, event + .getAmount() + * damageMultiplier)); + + event.setCanceled(true); + } + } + + return damageMultiplier; + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (!event.getSource().damageType.equals("retaliation")) { + // Don't retaliate for retaliation + if (ModjamMod.r.nextDouble() < RETALIATION_CHANCE) { + event.getEntityLiving().attackEntityFrom( + DamageSources.retaliation, + Math.max(0.5f, event.getAmount() + * damageMultiplier)); + + event.setCanceled(true); + } + } + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/marks/ScoutingMark.java b/src/main/java/fyresmodjam/blessings/marks/ScoutingMark.java new file mode 100644 index 0000000..1995c14 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/marks/ScoutingMark.java @@ -0,0 +1,13 @@ +package fyresmodjam.blessings.marks; + +public class ScoutingMark extends Mark { + @Override + public String name() { + return "Scouting"; + } + + @Override + public String description() { + return "BENEFIT - You can see traps without sneaking\nDRAWBACK - Take increased damage from traps"; + } +} diff --git a/src/main/java/fyresmodjam/blessings/marks/VampirismMark.java b/src/main/java/fyresmodjam/blessings/marks/VampirismMark.java new file mode 100644 index 0000000..5aa1da4 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/marks/VampirismMark.java @@ -0,0 +1,67 @@ +package fyresmodjam.blessings.marks; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.event.entity.living.LivingHurtEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.ServerTickEvent; + +public class VampirismMark extends Mark { + + @Override + public String name() { + return "Vampirism"; + } + + @Override + public String description() { + return "BENEFIT - Heal a substantial amount of the damage done to enemies\nDRAWBACK - Greatly weakened during the day and ignited in direct sunlight"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.getEntity().getBrightness() > 0.5F && event + .getEntity().world.canBlockSeeSky(event + .getEntity() + .getPosition())) { + return damageMultiplier + 0.4F; + } + + return damageMultiplier; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + Entity trueSource = event.getSource().getTrueSource(); + + if (trueSource instanceof EntityLivingBase) { + ((EntityLivingBase) trueSource) + .heal((event.getAmount() + * damageMultiplier) + * 0.25F); + + boolean seeTheSky = trueSource.world + .canBlockSeeSky(trueSource + .getPosition()); + if (trueSource.getBrightness() > 0.5F + && seeTheSky) { + return damageMultiplier - 0.4F; + } + } + + return damageMultiplier; + } + + @Override + public void commonTick(ServerTickEvent stev, EntityPlayer play) { + boolean seeTheSky = play.world + .canBlockSeeSky(play.getPosition()); + + if (play.getBrightness() > 0.5f && seeTheSky + && play.ticksExisted % 20 == 0) { + play.setFire(5); + } + } +} diff --git a/src/main/java/fyresmodjam/blessings/marks/WarMark.java b/src/main/java/fyresmodjam/blessings/marks/WarMark.java new file mode 100644 index 0000000..e4276c7 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/marks/WarMark.java @@ -0,0 +1,28 @@ +package fyresmodjam.blessings.marks; + +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class WarMark extends Mark { + + @Override + public String name() { + return "War"; + } + + @Override + public String description() { + return "BENEFIT - Deal greatly increased damage with melee weapons\nDRAWBACK - Deal less damage with all other weapons"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if ((event.getSource().getDamageType().equals("player") + || event.getSource().getDamageType() + .equals("mob"))) { + return damageMultiplier + 0.4f; + } + + return damageMultiplier - 0.2f; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/AlchemistBlessing.java b/src/main/java/fyresmodjam/blessings/standard/AlchemistBlessing.java new file mode 100644 index 0000000..0e36758 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/AlchemistBlessing.java @@ -0,0 +1,16 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; + +public class AlchemistBlessing extends Blessing { + + @Override + public String name() { + return "Alchemist"; + } + + @Override + public String description() { + return "All mystery potions act like wildcard potions"; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/BerserkerBlessing.java b/src/main/java/fyresmodjam/blessings/standard/BerserkerBlessing.java new file mode 100644 index 0000000..4e7f784 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/BerserkerBlessing.java @@ -0,0 +1,50 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import fyresmodjam.blessings.BlessingUtils; +import fyresmodjam.misc.EntityStatHelper; +import net.minecraft.entity.Entity; +import net.minecraftforge.event.entity.living.LivingDeathEvent; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class BerserkerBlessing extends Blessing { + + @Override + public String name() { + return "Berserker"; + } + + @Override + public String description() { + return "@@§ePASSIVE - §oKills are added as berserk charges. (10 max)@@§eACTIVE - §oTurn on/off berserk mode. While berserk mode is active, you do increased damage, and expend a counter every 2 seconds"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (BlessingUtils.isBlessingActive( + event.getSource().getTrueSource())) { + return damageMultiplier + 0.3f; + } + + return damageMultiplier; + } + + @Override + public void onMobKill(LivingDeathEvent event) { + Entity trueSource = event.getSource().getTrueSource(); + + if (!EntityStatHelper.hasStat(trueSource, + "BlessingCounter")) { + EntityStatHelper.giveStat(trueSource, + "BlessingCounter", 0); + } + + EntityStatHelper.giveStat(trueSource, "BlessingCounter", + Math.min(10, Integer.parseInt( + EntityStatHelper.getStat( + trueSource, + "BlessingCounter")) + + 1)); + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/DiverBlessing.java b/src/main/java/fyresmodjam/blessings/standard/DiverBlessing.java new file mode 100644 index 0000000..c0b8c72 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/DiverBlessing.java @@ -0,0 +1,23 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.fml.common.gameevent.TickEvent.ServerTickEvent; + +public class DiverBlessing extends Blessing { + + @Override + public String name() { + return "Diver"; + } + + @Override + public String description() { + return "Breathe underwater"; + } + + @Override + public void commonTick(ServerTickEvent stev, EntityPlayer play) { + play.setAir(0); + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/GuardianBlessing.java b/src/main/java/fyresmodjam/blessings/standard/GuardianBlessing.java new file mode 100644 index 0000000..47015dd --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/GuardianBlessing.java @@ -0,0 +1,23 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class GuardianBlessing extends Blessing { + + @Override + public String name() { + return "Guardian"; + } + + @Override + public String description() { + return "Reduce proportional damage taken"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent lhev, + float damageMultiplier) { + return damageMultiplier - 0.2f; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/HunterBlessing.java b/src/main/java/fyresmodjam/blessings/standard/HunterBlessing.java new file mode 100644 index 0000000..bd2892f --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/HunterBlessing.java @@ -0,0 +1,37 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraft.entity.Entity; +import net.minecraft.entity.IRangedAttackMob; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class HunterBlessing extends Blessing { + + @Override + public String name() { + return "Hunter"; + } + + @Override + public String description() { + return "Increased projectile damage"; + } + + @Override + public void correctBlessing(Entity ent) { + if (!(ent instanceof IRangedAttackMob)) { + ent.getEntityData().setString("Blessing", + "BlessingWarrior"); + } + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.getSource().isProjectile()) { + return damageMultiplier + 0.2f; + } + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/InfernoBlessing.java b/src/main/java/fyresmodjam/blessings/standard/InfernoBlessing.java new file mode 100644 index 0000000..40454aa --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/InfernoBlessing.java @@ -0,0 +1,55 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import fyresmodjam.misc.DamageSources; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.event.entity.living.LivingHurtEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.ServerTickEvent; + +public class InfernoBlessing extends Blessing { + + @Override + public String name() { + return "Inferno"; + } + + @Override + public String description() { + return "Benefit: Take no fire damage, and do increased damage while on fire\nDrawback: Take damge while wet"; + } + + @Override + public void commonTick(ServerTickEvent stev, EntityPlayer play) { + if (play.isWet() && play.ticksExisted % 10 == 0) { + play.attackEntityFrom(DamageSources.inferno, 1.0F); + } + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.getSource().isFireDamage() + || event.getSource().getDamageType() + .equals("inFire") + || event.getSource().getDamageType() + .equals("onFire") + || event.getSource().getDamageType() + .equals("lava")) { + event.setCanceled(true); + + return 0; + } + + return damageMultiplier; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.getSource().getTrueSource().isBurning()) { + return damageMultiplier + 0.35f; + } + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/LonerBlessing.java b/src/main/java/fyresmodjam/blessings/standard/LonerBlessing.java new file mode 100644 index 0000000..ac52ec5 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/LonerBlessing.java @@ -0,0 +1,38 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class LonerBlessing extends Blessing { + + @Override + public String name() { + return "Loner"; + } + + @Override + public String description() { + return "Do higher damage the lower your health is"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + Entity trueSource = event.getSource().getTrueSource(); + + if (trueSource instanceof EntityLivingBase) { + EntityLivingBase livingSource = (EntityLivingBase) trueSource; + + float healthRatio = livingSource.getHealth() + / livingSource.getMaxHealth(); + + float scaleFactor = 1.0F - healthRatio; + + return damageMultiplier + 0.35F * scaleFactor; + } + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/LooterBlessing.java b/src/main/java/fyresmodjam/blessings/standard/LooterBlessing.java new file mode 100644 index 0000000..bbf9ec5 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/LooterBlessing.java @@ -0,0 +1,32 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.ModjamMod; +import fyresmodjam.blessings.Blessing; +import net.minecraftforge.event.entity.living.LivingDeathEvent; + +public class LooterBlessing extends Blessing { + + @Override + public String name() { + return "Looter"; + } + + @Override + public String description() { + return "Enemies have a chance to drop dungeon loot"; + } + + @Override + public void onMobKill(LivingDeathEvent event) { + if (ModjamMod.r.nextInt(50) == 0) { + // TODO figure out how loot gen works + + //if (!event.entity.worldObj.isRemote) { + // event.entity.dropItem(ChestGenHooks + // .getOneItem(ChestGenHooks.DUNGEON_CHEST, + // ModjamMod.r) + // .getItem(), 1); + //} + } + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/LumberjackBlessing.java b/src/main/java/fyresmodjam/blessings/standard/LumberjackBlessing.java new file mode 100644 index 0000000..6ef337e --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/LumberjackBlessing.java @@ -0,0 +1,59 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraft.block.material.Material; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemTool; +import net.minecraft.util.EnumHand; +import net.minecraftforge.event.entity.living.LivingHurtEvent; +import net.minecraftforge.event.entity.player.PlayerEvent.BreakSpeed; + +public class LumberjackBlessing extends Blessing { + @Override + public String name() { + return "Lumberjack"; + } + + @Override + public String description() { + return "Increased breaking speed on wooden blocks, and increased damage with axes"; + } + + @Override + public void checkBreakSpeed(BreakSpeed pebsev) { + if (pebsev.getState().getMaterial() == Material.WOOD) { + pebsev.setNewSpeed( + pebsev.getOriginalSpeed() * 1.25F); + } + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + ItemStack held = null; + + if (event.getSource() + .getTrueSource() instanceof EntityLivingBase) { + held = ((EntityLivingBase) event.getSource() + .getTrueSource()).getHeldItem( + EnumHand.MAIN_HAND); + } + + if (held != null && itemIsAxe(held)) { + return damageMultiplier + 0.15F; + } + + return damageMultiplier; + } + + private boolean itemIsAxe(ItemStack held) { + if (held.getItem() instanceof ItemTool) { + return ((ItemTool) held.getItem()) + .getToolClasses(held) + .contains("axe"); + } + + return false; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/MechanicBlessing.java b/src/main/java/fyresmodjam/blessings/standard/MechanicBlessing.java new file mode 100644 index 0000000..b2a80e6 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/MechanicBlessing.java @@ -0,0 +1,17 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; + +public class MechanicBlessing extends Blessing { + + @Override + public String name() { + return "Mechanic"; + } + + @Override + public String description() { + return "@@§ePASSIVE - §oYou disarm traps more often and have an increased chance to salvage disarmed traps.\n@@§eACTIVE - §oOnce per day, you may disarm and salvage a trap for free"; + } + +} diff --git a/src/main/java/fyresmodjam/blessings/standard/MinerBlessing.java b/src/main/java/fyresmodjam/blessings/standard/MinerBlessing.java new file mode 100644 index 0000000..f261faa --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/MinerBlessing.java @@ -0,0 +1,61 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraft.block.material.Material; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemTool; +import net.minecraft.util.EnumHand; +import net.minecraftforge.event.entity.living.LivingHurtEvent; +import net.minecraftforge.event.entity.player.PlayerEvent.BreakSpeed; + +public class MinerBlessing extends Blessing { + @Override + public String name() { + return "Miner"; + } + + @Override + public String description() { + return "Increased breaking speed on stone and iron blocks, and increased damage with pickaxes"; + } + + @Override + public void checkBreakSpeed(BreakSpeed pebsev) { + if (pebsev.getState().getMaterial() == Material.ROCK + || pebsev.getState() + .getMaterial() == Material.IRON) { + pebsev.setNewSpeed( + pebsev.getOriginalSpeed() * 1.25F); + } + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + ItemStack held = null; + + if (event.getSource() + .getTrueSource() instanceof EntityLivingBase) { + held = ((EntityLivingBase) event.getSource() + .getTrueSource()).getHeldItem( + EnumHand.MAIN_HAND); + } + + if (held != null && itemIsPickaxe(held)) { + return damageMultiplier + 0.2F; + } + + return damageMultiplier; + } + + private boolean itemIsPickaxe(ItemStack held) { + if (held.getItem() instanceof ItemTool) { + return ((ItemTool) held.getItem()) + .getToolClasses(held) + .contains("pickaxe"); + } + + return false; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/NinjaBlessing.java b/src/main/java/fyresmodjam/blessings/standard/NinjaBlessing.java new file mode 100644 index 0000000..3883f14 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/NinjaBlessing.java @@ -0,0 +1,55 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.potion.Potion; +import net.minecraft.potion.PotionEffect; +import net.minecraftforge.event.entity.living.LivingHurtEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.ServerTickEvent; + +public class NinjaBlessing extends Blessing { + + @Override + public String name() { + return "Ninja"; + } + + @Override + public String description() { + return "- Go invisible while sneaking\n- Attacks on enemies with full health deal 2x damage"; + } + + @Override + public void commonTick(ServerTickEvent stev, EntityPlayer player) { + if (player.isSneaking()) { + // TODO figure out potions + // PotionEffect e = player.getActivePotionEffect( + // Potion.invisibility); + + // if (e == null || player.getActivePotionEffect( + // Potion.invisibility) + // .getDuration() < 10) { + // player.addPotionEffect(new PotionEffect( + // Potion.invisibility.id, 10, + // 1, false)); + // } + } + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + boolean atMaxHealth = event.getEntityLiving() + .getHealth() == event.getEntityLiving() + .getMaxHealth(); + + if (event.getEntityLiving() != null + && event.getSource().getTrueSource() + .isSneaking() + && atMaxHealth) { + return damageMultiplier + 1.0F; + } + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/PaladinBlessing.java b/src/main/java/fyresmodjam/blessings/standard/PaladinBlessing.java new file mode 100644 index 0000000..9979931 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/PaladinBlessing.java @@ -0,0 +1,27 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class PaladinBlessing extends Blessing { + + @Override + public String name() { + return "Paladin"; + } + + @Override + public String description() { + return "Deal bonus damage to undead"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.getEntityLiving().isEntityUndead()) { + return damageMultiplier + .2f; + } + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/ParatrooperBlessing.java b/src/main/java/fyresmodjam/blessings/standard/ParatrooperBlessing.java new file mode 100644 index 0000000..d777566 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/ParatrooperBlessing.java @@ -0,0 +1,29 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class ParatrooperBlessing extends Blessing { + + @Override + public String name() { + return "Paratrooper"; + } + + @Override + public String description() { + return "Take no fall damage"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, + float damageMultiplier) { + if(event.getSource().damageType.equals("fall")) { + event.setCanceled(true); + + return 0; + } + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/PorcupineBlessing.java b/src/main/java/fyresmodjam/blessings/standard/PorcupineBlessing.java new file mode 100644 index 0000000..a46c3d0 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/PorcupineBlessing.java @@ -0,0 +1,45 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import fyresmodjam.misc.DamageSources; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.util.DamageSource; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class PorcupineBlessing extends Blessing { + + @Override + public String name() { + return "Porcupine"; + } + + @Override + public String description() { + return "Deal retaliation damage to melee attackers"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, + float damageMultiplier) { + Entity trueSource = event.getSource().getTrueSource(); + + boolean isMeleeDamage = event.getSource().damageType + .equals("mob") + || event.getSource().getDamageType() + .equals("player"); + + if (trueSource != null + && trueSource instanceof EntityLivingBase + && !event.getSource().isProjectile() + && isMeleeDamage) { + DamageSource damage = DamageSources.retaliation; + + ((EntityLivingBase) trueSource) + .attackEntityFrom(damage, + event.getAmount() * 0.07F); + } + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/ScholarBlessing.java b/src/main/java/fyresmodjam/blessings/standard/ScholarBlessing.java new file mode 100644 index 0000000..e66726c --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/ScholarBlessing.java @@ -0,0 +1,29 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class ScholarBlessing extends Blessing { + + @Override + public String name() { + return "Scholar"; + } + + @Override + public String description() { + return "Do more damage:\n- With weapons you are familiar with\n-Against enemies you are familiar with"; + } + + @Override + public float adjustMobKnowledgeBonus(LivingHurtEvent lhev, + float pickedDamageBonus) { + return pickedDamageBonus + (pickedDamageBonus * 0.5f); + } + + @Override + public float adjustWeaponKnowledgeBonus(LivingHurtEvent lhev, + float pickedDamageBonus) { + return pickedDamageBonus + (pickedDamageBonus * 0.5f); + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/SwampBlessing.java b/src/main/java/fyresmodjam/blessings/standard/SwampBlessing.java new file mode 100644 index 0000000..e9ecad3 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/SwampBlessing.java @@ -0,0 +1,34 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraft.potion.Potion; +import net.minecraft.potion.PotionEffect; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class SwampBlessing extends Blessing { + + @Override + public String name() { + return "Swamp"; + } + + @Override + public String description() { + return "Attacks slow enemies"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.getEntityLiving() != null) { + // TODO figure out potions + +// event.getEntityLiving() +// .addPotionEffect(new PotionEffect( +// Potion.moveSlowdown.id, +// 100, 1, false)); + } + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/ThickSkinnedBlessing.java b/src/main/java/fyresmodjam/blessings/standard/ThickSkinnedBlessing.java new file mode 100644 index 0000000..ca16900 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/ThickSkinnedBlessing.java @@ -0,0 +1,24 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class ThickSkinnedBlessing extends Blessing { + + @Override + public String name() { + return "Thick-Skinned"; + } + + @Override + public String description() { + return "Reduce damage taken by a flat amount"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, float damageMultiplier) { + event.setAmount(Math.max(0.5f, event.getAmount() - 1f)); + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/ThiefBlessing.java b/src/main/java/fyresmodjam/blessings/standard/ThiefBlessing.java new file mode 100644 index 0000000..b807b4b --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/ThiefBlessing.java @@ -0,0 +1,29 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.ModjamMod; +import fyresmodjam.blessings.Blessing; +import net.minecraft.init.Items; +import net.minecraftforge.event.entity.living.LivingDeathEvent; + +public class ThiefBlessing extends Blessing { + + @Override + public String name() { + return "Thief"; + } + + @Override + public String description() { + return "Enemies have a chance to drop gold nuggets"; + } + + @Override + public void onMobKill(LivingDeathEvent event) { + if(ModjamMod.r.nextInt(20) == 0) { + if (!event.getEntity().world.isRemote) { + event.getEntity().dropItem(Items.GOLD_NUGGET, + 1); + } + } + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/VampireBlessing.java b/src/main/java/fyresmodjam/blessings/standard/VampireBlessing.java new file mode 100644 index 0000000..6594eab --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/VampireBlessing.java @@ -0,0 +1,55 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class VampireBlessing extends Blessing { + + @Override + public String name() { + return "Vampire"; + } + + @Override + public String description() { + return "\tBenefit: Heal a small percentage of damage dealt to enemies\n\tDrawback: Weakened during the day"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, + float damageMultiplier) { + Entity ent = event.getEntity(); + if (ent.getBrightness() > 0.5F && ent.world + .canBlockSeeSky(ent.getPosition())) { + return damageMultiplier + 0.2F; + } + + return damageMultiplier; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + Entity trueSource = event.getSource().getTrueSource(); + if (trueSource instanceof EntityLivingBase) { + + ((EntityLivingBase) trueSource) + .heal((event.getAmount() + * damageMultiplier) + * 0.07F); + + boolean seeTheSky = trueSource.world + .canBlockSeeSky(trueSource + .getPosition()); + + if (trueSource.getBrightness() > 0.5F + && seeTheSky) { + return damageMultiplier - 0.2F; + } + } + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/blessings/standard/WarriorBlessing.java b/src/main/java/fyresmodjam/blessings/standard/WarriorBlessing.java new file mode 100644 index 0000000..2c1e2e7 --- /dev/null +++ b/src/main/java/fyresmodjam/blessings/standard/WarriorBlessing.java @@ -0,0 +1,39 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraft.entity.Entity; +import net.minecraft.entity.IRangedAttackMob; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class WarriorBlessing extends Blessing { + + @Override + public String name() { + return "Warrior"; + } + + @Override + public String description() { + return "Increased melee damage"; + } + + @Override + public void correctBlessing(Entity ent) { + if (ent instanceof IRangedAttackMob) { + ent.getEntityData().setString("Blessing", + "BlessingHunter"); + } + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if ((event.getSource().getDamageType().equals("player") + || event.getSource().getDamageType() + .equals("mob"))) { + return damageMultiplier + 0.2f; + } + + return damageMultiplier; + } +} diff --git a/src/main/java/fyresmodjam/commands/CommandCraftingStats.java b/src/main/java/fyresmodjam/commands/CommandCraftingStats.java new file mode 100644 index 0000000..d07a511 --- /dev/null +++ b/src/main/java/fyresmodjam/commands/CommandCraftingStats.java @@ -0,0 +1,156 @@ +package fyresmodjam.commands; + +import java.util.LinkedList; +import java.util.List; + +import fyresmodjam.ModjamMod; +import fyresmodjam.handlers.NewPacketHandler; +import fyresmodjam.misc.EntityStatHelper; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.BlockPos; + +public class CommandCraftingStats implements ICommand { + + @Override + public int compareTo(ICommand arg0) { + return 0; + } + + @Override + public String getName() { + return "craftingKnowledge"; + } + + @Override + public String getUsage(ICommandSender icommandsender) { + return "commands.craftingKnowledge.usage"; + } + + @Override + public List getAliases() { + return new LinkedList<>(); + } + + + @Override + public void execute(MinecraftServer mcServer, ICommandSender icommandsender, + String[] astring) { + int page = astring.length > 0 + ? Integer.parseInt(astring[0]) - 1 + : 0, maxPage = 0; + if (icommandsender instanceof EntityPlayer) { + EntityPlayer entityplayer = (EntityPlayer) icommandsender; + + String message = "\u00A7c\u00A7oCrafting stats not enabled."; + + if (ModjamMod.enableCraftingStats) { + message = "@Crafting Knowledge:"; + + if (entityplayer.getEntityData() + .hasKey("CraftingStats")) { + NBTTagCompound craftingStats = entityplayer + .getEntityData() + .getCompoundTag("CraftingStats"); + + String trackedItems = craftingStats + .hasKey("TrackedItemList") + ? craftingStats.getString( + "TrackedItemList") + : ""; + + if (trackedItems != null + && trackedItems.length() > 0) { + String[] trackedItemList = trackedItems + .split(";"); + + maxPage = Math.max(0, + (craftingStats.getSize() + - 1) + / 4); + if (page > maxPage) { + page = maxPage; + } + if (page < 0) { + page = 0; + } + + message = "@Crafting Knowledge (page " + + (page + 1) + + "/" + + (maxPage + 1) + + "):"; + + int count = 0, skip = 0; + for (String item : trackedItemList) { + if (skip < page * 4) { + skip++; + continue; + } + + int kills = craftingStats + .getInteger(item); + + int last = 0; + for (int i = 0; i < EntityStatHelper.killCount.length; i++) { + if (kills >= EntityStatHelper.killCount[i] + * 2) { + last = i; + continue; + } else { + break; + } + } + + message += "@\u00A7b " + + EntityStatHelper.knowledge[last] + + " " + + item.toLowerCase() + + " smith\u00A73 (" + + kills + + " craft(s)" + + (last < EntityStatHelper.knowledge.length + - 1 ? ", " + (EntityStatHelper.killCount[last + 1] * 2 - kills + " craft(s) to next rank)") : ")"); + count++; + + if (count >= 4) { + break; + } + } + } + } else { + message += "@ You've yet to learn anything."; + } + } + + NewPacketHandler.SEND_MESSAGE.sendToPlayer( + entityplayer, message); + } + } + + @Override + public boolean checkPermission(MinecraftServer mcServer, + ICommandSender icommandsender) { + return true; + } + + @Override + public List getTabCompletions(MinecraftServer mcServer, + ICommandSender icommandsender, String[] astring, + BlockPos bPos) { + return new LinkedList<>(); + } + + @Override + public boolean isUsernameIndex(String[] astring, int i) { + return false; + } + + public int getRequiredPermissionLevel() { + return 0; + } + +} diff --git a/src/main/java/fyresmodjam/commands/CommandCurrentBlessing.java b/src/main/java/fyresmodjam/commands/CommandCurrentBlessing.java new file mode 100644 index 0000000..f39a689 --- /dev/null +++ b/src/main/java/fyresmodjam/commands/CommandCurrentBlessing.java @@ -0,0 +1,87 @@ +package fyresmodjam.commands; + +import java.util.LinkedList; +import java.util.List; + +import fyresmodjam.blessings.BlessingUtils; +import fyresmodjam.blessings.Blessing; +import fyresmodjam.handlers.NewPacketHandler; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.BlockPos; + +public class CommandCurrentBlessing implements ICommand { + + @Override + public int compareTo(ICommand arg0) { + return 0; + } + + @Override + public String getName() { + return "currentBlessing"; + } + + @Override + public String getUsage(ICommandSender icommandsender) { + return "commands.currentBlessing.usage"; + } + + @Override + public List getAliases() { + return new LinkedList<>(); + } + + @Override + public void execute(MinecraftServer mcServer, ICommandSender icommandsender, + String[] astring) { + if (icommandsender instanceof EntityPlayer) { + EntityPlayer entityplayer = (EntityPlayer) icommandsender; + + boolean hasBlessing = BlessingUtils + .hasBlessing(entityplayer); + + String blessingMsg = ""; + + if (hasBlessing) { + Blessing bless = BlessingUtils + .getBlessingInstance( + entityplayer); + + blessingMsg = String.format( + "§eCurrent Blessing - §o%s\n%s", + bless.customName(), + bless.description()); + } else { + blessingMsg = "You don't currently have a blessing"; + } + + NewPacketHandler.SEND_MESSAGE.sendToPlayer( + entityplayer, blessingMsg); + } + } + + @Override + public boolean checkPermission(MinecraftServer mcServer, + ICommandSender icommandsender) { + return true; + } + + @Override + public List getTabCompletions(MinecraftServer mcServer, ICommandSender icommandsender, + String[] astring, BlockPos bPos) { + return new LinkedList<>(); + } + + @Override + public boolean isUsernameIndex(String[] astring, int i) { + return false; + } + + public int getRequiredPermissionLevel() { + return 0; + } + +} diff --git a/src/main/java/fyresmodjam/commands/CommandCurrentDisadvantage.java b/src/main/java/fyresmodjam/commands/CommandCurrentDisadvantage.java new file mode 100644 index 0000000..205a67d --- /dev/null +++ b/src/main/java/fyresmodjam/commands/CommandCurrentDisadvantage.java @@ -0,0 +1,84 @@ +package fyresmodjam.commands; + +import java.util.LinkedList; +import java.util.List; + +import fyresmodjam.handlers.CommonTickHandler; +import fyresmodjam.handlers.NewPacketHandler; +import fyresmodjam.worldgen.FyresWorldData; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.BlockPos; + +public class CommandCurrentDisadvantage implements ICommand { + + @Override + public int compareTo(ICommand arg0) { + return 0; + } + + @Override + public String getName() { + return "currentDisadvantage"; + } + + @Override + public String getUsage(ICommandSender icommandsender) { + return "commands.currentDisadvantage.usage"; + } + + @Override + public List getAliases() { + return new LinkedList<>(); + } + + @Override + public void execute(MinecraftServer mcServer, ICommandSender icommandsender, + String[] astring) { + if (icommandsender instanceof EntityPlayer) { + EntityPlayer entityplayer = (EntityPlayer) icommandsender; + + int index = -1; + for (int i = 0; i < FyresWorldData.validDisadvantages.length; i++) { + if (FyresWorldData.validDisadvantages[i] + .equals(CommonTickHandler.worldData + .getDisadvantage())) { + index = i; + break; + } + } + NewPacketHandler.SEND_MESSAGE.sendToPlayer( + entityplayer, + "\u00A7eWorld disadvantage: " + + CommonTickHandler.worldData + .getDisadvantage() + + (index == -1 ? "" + : " (" + FyresWorldData.disadvantageDescriptions[index] + + ")")); + } + } + + @Override + public boolean checkPermission(MinecraftServer mcServer, + ICommandSender icommandsender) { + return true; + } + + @Override + public List getTabCompletions(MinecraftServer mcServer, ICommandSender icommandsender, + String[] astring, BlockPos bPos) { + return new LinkedList<>(); + } + + @Override + public boolean isUsernameIndex(String[] astring, int i) { + return false; + } + + public int getRequiredPermissionLevel() { + return 0; + } + +} diff --git a/src/main/java/fyresmodjam/commands/CommandCurrentWorldTask.java b/src/main/java/fyresmodjam/commands/CommandCurrentWorldTask.java new file mode 100644 index 0000000..84058a4 --- /dev/null +++ b/src/main/java/fyresmodjam/commands/CommandCurrentWorldTask.java @@ -0,0 +1,110 @@ +package fyresmodjam.commands; + +import java.util.LinkedList; +import java.util.List; + +import fyresmodjam.handlers.CommonTickHandler; +import fyresmodjam.handlers.NewPacketHandler; +import fyresmodjam.worldgen.FyresWorldData; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.BlockPos; + +public class CommandCurrentWorldTask implements ICommand { + + @Override + public int compareTo(ICommand arg0) { + return 0; + } + + @Override + public String getName() { + return "currentGoal"; + } + + @Override + public String getUsage(ICommandSender icommandsender) { + return "commands.currentGoal.usage"; + } + + @Override + public List getAliases() { + return new LinkedList<>(); + } + + @Override + public void execute(MinecraftServer mcServer, + ICommandSender icommandsender, String[] astring) { + if (icommandsender instanceof EntityPlayer) { + EntityPlayer entityplayer = (EntityPlayer) icommandsender; + + String name = CommonTickHandler.worldData.currentTask + .equals("Kill") ? FyresWorldData.validMobNames[CommonTickHandler.worldData.currentTaskID] + : FyresWorldData.validItems[CommonTickHandler.worldData.currentTaskID] + .getDisplayName(); + + if (CommonTickHandler.worldData.currentTaskAmount > 1) { + if (name.contains("Block")) { + if (name.contains("Block")) { + name = name.replace( + "Block", + "Blocks") + .replace("block", + "blocks"); + } + } else { + name += "s"; + } + } + + NewPacketHandler.SEND_MESSAGE.sendToPlayer( + entityplayer, + "\u00A7eWorld goal: " + + CommonTickHandler.worldData.currentTask + + " " + + CommonTickHandler.worldData.currentTaskAmount + + " " + name + + ". (" + + CommonTickHandler.worldData.progress + + " " + + CommonTickHandler.worldData.currentTask + + "ed)"); + + NewPacketHandler.SEND_MESSAGE.sendToPlayer( + entityplayer, + "\u00A7f Reward: " + + CommonTickHandler.worldData.rewardLevels + + " Experience Levels"); + + NewPacketHandler.SEND_MESSAGE.sendToPlayer( + entityplayer, + "\u00A7eGoals completed: " + + CommonTickHandler.worldData.tasksCompleted); + } + } + + @Override + public boolean checkPermission(MinecraftServer mcServer, + ICommandSender icommandsender) { + return true; + } + + @Override + public List getTabCompletions(MinecraftServer mcServer, + ICommandSender icommandsender, String[] astring, + BlockPos bPos) { + return new LinkedList<>(); + } + + @Override + public boolean isUsernameIndex(String[] astring, int i) { + return false; + } + + public int getRequiredPermissionLevel() { + return 0; + } + +} diff --git a/src/main/java/fyresmodjam/commands/CommandKillStats.java b/src/main/java/fyresmodjam/commands/CommandKillStats.java new file mode 100644 index 0000000..8d4c756 --- /dev/null +++ b/src/main/java/fyresmodjam/commands/CommandKillStats.java @@ -0,0 +1,158 @@ +package fyresmodjam.commands; + +import java.util.LinkedList; +import java.util.List; + +import fyresmodjam.ModjamMod; +import fyresmodjam.handlers.NewPacketHandler; +import fyresmodjam.misc.EntityStatHelper; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.BlockPos; + +public class CommandKillStats implements ICommand { + + @Override + public int compareTo(ICommand arg0) { + return 0; + } + + @Override + public String getName() { + return "creatureKnowledge"; + } + + @Override + public String getUsage(ICommandSender icommandsender) { + return "commands.creatureKnowledge.usage"; + } + + @Override + public List getAliases() { + return new LinkedList<>(); + } + + @Override + public void execute(MinecraftServer mcServer, + ICommandSender icommandsender, String[] astring) { + int page = astring.length > 0 + ? Integer.parseInt(astring[0]) - 1 + : 0, maxPage = 0; + + if (icommandsender instanceof EntityPlayer) { + EntityPlayer entityplayer = (EntityPlayer) icommandsender; + + String message = "\u00A7c\u00A7oMob kill stats not enabled."; + + if (ModjamMod.enableMobKillStats) { + message = "@Creature Knowledge:"; + + if (entityplayer.getEntityData() + .hasKey("KillStats")) { + NBTTagCompound killStats = entityplayer + .getEntityData() + .getCompoundTag("KillStats"); + + String trackedMobs = killStats + .hasKey("TrackedMobList") + ? killStats.getString( + "TrackedMobList") + : ""; + + if (trackedMobs != null + && trackedMobs.length() > 0) { + String[] trackedMobList = trackedMobs + .split(";"); + + maxPage = Math.max(0, + (killStats.getSize() + - 1) + / 4); + if (page > maxPage) { + page = maxPage; + } + if (page < 0) { + page = 0; + } + + message = "@Creature Knowledge (page " + + (page + 1) + + "/" + + (maxPage + 1) + + "):"; + + int count = 0, skip = 0; + for (String mob : trackedMobList) { + if (skip < page * 4) { + skip++; + continue; + } + + int kills = killStats + .getInteger(mob); + + int last = 0; + for (int i = 0; i < EntityStatHelper.killCount.length; i++) { + if (kills >= EntityStatHelper.killCount[i]) { + last = i; + continue; + } else { + break; + } + } + + message += "@\u00A7b " + + EntityStatHelper.knowledge[last] + + " " + + mob.toLowerCase() + + " slayer\u00A73 " + + (last > 0 ? "+" + + EntityStatHelper.damageBonusString[last] + + "% damage bonus (" + : "(") + + kills + + " kill(s)" + + (last < EntityStatHelper.knowledge.length + - 1 ? ", " + (EntityStatHelper.killCount[last + 1] - kills + " kill(s) to next rank)") : ")"); + count++; + + if (count >= 4) { + break; + } + } + } + } else { + message += "@ You've yet to learn anything."; + } + } + + NewPacketHandler.SEND_MESSAGE.sendToPlayer( + entityplayer, message); + } + } + + @Override + public boolean checkPermission(MinecraftServer mcServer, + ICommandSender icommandsender) { + return true; + } + + @Override + public List getTabCompletions(MinecraftServer mcServer, ICommandSender icommandsender, + String[] astring, BlockPos bPos) { + return new LinkedList<>(); + } + + @Override + public boolean isUsernameIndex(String[] astring, int i) { + return false; + } + + public int getRequiredPermissionLevel() { + return 0; + } + +} diff --git a/src/main/java/fyresmodjam/commands/CommandWeaponStats.java b/src/main/java/fyresmodjam/commands/CommandWeaponStats.java new file mode 100644 index 0000000..f3ea8b7 --- /dev/null +++ b/src/main/java/fyresmodjam/commands/CommandWeaponStats.java @@ -0,0 +1,157 @@ +package fyresmodjam.commands; + +import java.util.LinkedList; +import java.util.List; + +import fyresmodjam.ModjamMod; +import fyresmodjam.handlers.NewPacketHandler; +import fyresmodjam.misc.EntityStatHelper; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.math.BlockPos; + +public class CommandWeaponStats implements ICommand { + + @Override + public int compareTo(ICommand arg0) { + return 0; + } + + @Override + public String getName() { + return "weaponKnowledge"; + } + + @Override + public String getUsage(ICommandSender icommandsender) { + return "commands.weaponKnowledge.usage"; + } + + @Override + public List getAliases() { + return new LinkedList<>(); + } + + @Override + public void execute(MinecraftServer mcServer, + ICommandSender icommandsender, String[] astring) { + int page = astring.length > 0 + ? Integer.parseInt(astring[0]) - 1 + : 0, maxPage = 0; + if (icommandsender instanceof EntityPlayer) { + EntityPlayer entityplayer = (EntityPlayer) icommandsender; + + String message = "\u00A7c\u00A7oWeapon kill stats not enabled."; + + if (ModjamMod.enableWeaponKillStats) { + message = "@Weapon Knowledge:"; + + if (entityplayer.getEntityData() + .hasKey("WeaponStats")) { + NBTTagCompound itemStats = entityplayer + .getEntityData() + .getCompoundTag("WeaponStats"); + + String trackedItems = itemStats + .hasKey("TrackedItemList") + ? itemStats.getString( + "TrackedItemList") + : ""; + + if (trackedItems != null + && trackedItems.length() > 0) { + String[] trackedItemList = trackedItems + .split(";"); + + maxPage = Math.max(0, + (itemStats.getSize()) + / 4); + if (page > maxPage) { + page = maxPage; + } + if (page < 0) { + page = 0; + } + + message = "@Weapon Knowledge (page " + + (page + 1) + + "/" + + (maxPage + 1) + + "):"; + + int count = 0, skip = 0; + for (String item : trackedItemList) { + if (skip < page * 4) { + skip++; + continue; + } + + int kills = itemStats + .getInteger(item); + + int last = 0; + for (int i = 0; i < EntityStatHelper.killCount.length; i++) { + if (kills >= EntityStatHelper.killCount[i] + * 2) { + last = i; + continue; + } else { + break; + } + } + + message += "@\u00A7b " + + EntityStatHelper.knowledge[last] + + " " + + item.toLowerCase() + + " user\u00A73 " + + (last > 0 ? "+" + + EntityStatHelper.damageBonusString[last] + + "% damage bonus (" + : "(") + + kills + + " kill(s)" + + (last < EntityStatHelper.knowledge.length + - 1 ? ", " + (EntityStatHelper.killCount[last + 1] * 2 - kills + " kill(s) to next rank)") : ")"); + count++; + + if (count >= 4) { + break; + } + } + } + } else { + message += "@ You've yet to learn anything."; + } + } + + NewPacketHandler.SEND_MESSAGE.sendToPlayer( + entityplayer, message); + } + } + + @Override + public boolean checkPermission(MinecraftServer mcServer, + ICommandSender icommandsender) { + return true; + } + + @Override + public List getTabCompletions(MinecraftServer mcServer, ICommandSender icommandsender, + String[] astring, BlockPos bPos) { + return new LinkedList<>(); + } + + @Override + public boolean isUsernameIndex(String[] astring, int i) { + return false; + } + + public int getRequiredPermissionLevel() { + return 0; + } + +} diff --git a/src/main/java/fyresmodjam/handlers/ClientTickHandler.java b/src/main/java/fyresmodjam/handlers/ClientTickHandler.java new file mode 100644 index 0000000..c3950f7 --- /dev/null +++ b/src/main/java/fyresmodjam/handlers/ClientTickHandler.java @@ -0,0 +1,82 @@ +package fyresmodjam.handlers; + +import java.io.File; + +import fyresmodjam.ModjamMod; +import fyresmodjam.misc.ItemStatHelper; +import net.minecraft.client.Minecraft; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.config.Configuration; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.ClientTickEvent; + +public class ClientTickHandler { + + public static long time = System.currentTimeMillis(); + + @SubscribeEvent + public void clientTick(ClientTickEvent event) { + EntityPlayer player = Minecraft.getMinecraft().player; + + if (System.currentTimeMillis() - time > 200 + && player != null) { + if (player.openContainer != null) { + boolean sendPacket = false; + + for (Object object : player.inventory.mainInventory) { + if (object == null + || !(object instanceof ItemStack)) { + continue; + } + + ItemStack stack = (ItemStack) object; + + if (stack.getItem() != null + && !ItemStatHelper.skip + .contains(stack.getItem() + .getClass()) + && (stack.getTagCompound() == null + || !stack.getTagCompound() + .hasKey("processed") + || stack.getTagCompound() + .getString("processed") + .equals("false"))) { + sendPacket = true; + } + } + + if (sendPacket) { + NewPacketHandler.UPDATE_PLAYER_ITEMS + .sendToServer((Object) null); + time = System.currentTimeMillis(); + } + } + + // TODO move to an advancement + //player.triggerAchievement(ModjamMod.startTheGame); + } + + if (FyresKeyHandler.examine + .getKeyCode() != ModjamMod.examineKey + || FyresKeyHandler.activateBlessing + .getKeyCode() != ModjamMod.blessingKey) { + ModjamMod.examineKey = FyresKeyHandler.examine + .getKeyCode(); + ModjamMod.blessingKey = FyresKeyHandler.activateBlessing + .getKeyCode(); + + Configuration config = new Configuration( + new File(ModjamMod.configPath)); + config.load(); + config.get("Keybindings", "examine_key", + ModjamMod.examineKey) + .set(ModjamMod.examineKey); + config.get("Keybindings", "blessing_key", + ModjamMod.blessingKey) + .set(ModjamMod.blessingKey); + config.save(); + } + } + +} diff --git a/src/main/java/fyresmodjam/handlers/CommonTickHandler.java b/src/main/java/fyresmodjam/handlers/CommonTickHandler.java new file mode 100644 index 0000000..5c25e60 --- /dev/null +++ b/src/main/java/fyresmodjam/handlers/CommonTickHandler.java @@ -0,0 +1,350 @@ +package fyresmodjam.handlers; + +import java.util.ArrayList; + +import fyresmodjam.ModjamMod; +import fyresmodjam.blessings.BlessingUtils; +import fyresmodjam.misc.EntityStatHelper; +import fyresmodjam.worldgen.FyresWorldData; +import net.minecraft.entity.Entity; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.server.MinecraftServer; +import net.minecraft.world.WorldServer; +import net.minecraftforge.fml.common.FMLCommonHandler; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.ServerTickEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.WorldTickEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent; + +public class CommonTickHandler { + public static FyresWorldData worldData = null; + + public static ArrayList addLater = new ArrayList(); + + @SubscribeEvent + public void worldTick(WorldTickEvent event) { + if (event.phase == TickEvent.Phase.START) { + if (event.world != null && event.world.provider + .getDimension() == 0) { + worldData = FyresWorldData + .forWorld(event.world); + worldData.markDirty(); + } + } + } + + @SubscribeEvent + public void serverTick(ServerTickEvent event) { + MinecraftServer server = FMLCommonHandler.instance() + .getMinecraftServerInstance(); + + for (int i = 0; i < server.worlds.length; i++) { + WorldServer s = FMLCommonHandler.instance() + .getMinecraftServerInstance().worlds[i]; + + if (s == null) { + continue; + } + + for (Object o : s.playerEntities) { + if (o == null || !(o instanceof EntityPlayer)) { + continue; + } + + EntityPlayer player = (EntityPlayer) o; + + String blessing; + + if (player.getEntityData() + .hasKey("Blessing")) { + blessing = player.getEntityData() + .getString("Blessing"); + } else { + blessing = null; + } + + int coolDown = 0, counter = 0, timer = 0; + + boolean blessingActive; + + if (EntityStatHelper.hasStat(player, + "BlessingActive")) { + blessingActive = Boolean + .parseBoolean(EntityStatHelper + .getStat(player, "BlessingActive")); + } else { + blessingActive = false; + } + + if (EntityStatHelper.hasStat(player, + "BlessingCooldown")) { + coolDown = Integer.parseInt( + EntityStatHelper.getStat( + player, + "BlessingCooldown")); + if (coolDown > 0) { + coolDown--; + } + } + + if (EntityStatHelper.hasStat(player, + "BlessingTimer")) { + timer = Integer.parseInt( + EntityStatHelper.getStat( + player, + "BlessingTimer")); + if (blessingActive) { + timer++; + } else { + timer = 0; + } + } + + if (EntityStatHelper.hasStat(player, + "BlessingCounter")) { + counter = Integer.parseInt( + EntityStatHelper.getStat( + player, + "BlessingCounter")); + + if (BlessingUtils.hasBlessing( + player)) { + if (blessingActive + && BlessingUtils.hasBlessing( + player, + "BlessingBerserker") + && timer % 40 == 0) { + counter = Math.max( + 0, + counter - 1); + + if (counter == 0) { + NewPacketHandler.SEND_MESSAGE + .sendToPlayer(player, + "\u00A7cYou calm down."); + coolDown = 1200; + timer = 0; + blessingActive = false; + } + } + } + } + + if (blessing != null) { + BlessingUtils.getBlessingInstance( + blessing) + .commonTick(event, + player); + } + + if (EntityStatHelper.hasStat(player, + "BlessingCounter") + && Integer.parseInt( + EntityStatHelper.getStat( + player, + "BlessingCounter")) != counter) { + NewPacketHandler.UPDATE_STAT + .sendToPlayer(player, + "BlessingCounter", + "" + counter); + } + + EntityStatHelper.giveStat(player, + "BlessingActive", + blessingActive); + EntityStatHelper.giveStat(player, + "BlessingCooldown", + coolDown); + EntityStatHelper.giveStat(player, + "BlessingCounter", + counter); + EntityStatHelper.giveStat(player, + "BlessingTimer", timer); + + } + + for (Object o : s.loadedEntityList) { + if (o == null || !(o instanceof Entity)) { + continue; + } + + if (o instanceof EntityItem) { + EntityItem item = (EntityItem) o; + + if (((EntityItem) o).isBurning()) { + ItemStack stack = item + .getItem(); + + if (canAdvanceBurnTaskProgress( + stack)) { + worldData.progress += stack + .getCount(); + ((EntityItem) o).isDead = true; + + String name1; + + if (CommonTickHandler.worldData.currentTask + .equals("Kill")) { + name1 = FyresWorldData.validMobNames[CommonTickHandler.worldData.currentTaskID]; + } else { + name1 = FyresWorldData.validItems[CommonTickHandler.worldData.currentTaskID] + .getDisplayName(); + } + + if (name1.contains( + "Block")) { + if (name1.contains( + "Block")) { + name1 = name1.replace( + "Block", + "Blocks") + .replace("block", + "blocks"); + } + } else { + name1 += "s"; + } + + NewPacketHandler.SEND_MESSAGE + .sendToAllPlayers( + "\u00A7fCurrent Goal Progress: " + + worldData.progress + + "/" + + worldData.currentTaskAmount + + " " + + name1 + + " " + + worldData.currentTask + + "ed."); + + if (worldData.progress >= worldData.currentTaskAmount) { + worldData.progress = 0; + worldData.tasksCompleted++; + + NewPacketHandler.LEVEL_UP + .sendToAllPlayers( + worldData.rewardLevels); + + worldData.giveNewTask(); + + String name; + if (worldData.currentTask + .equals("Kill")) { + name = FyresWorldData.validMobNames[worldData.currentTaskID]; + } else { + name = FyresWorldData.validItems[worldData.currentTaskID] + .getDisplayName(); + } + + if (worldData.currentTaskAmount > 1) { + if (name.contains( + "Block")) { + if (name.contains( + "Block")) { + name = name.replace( + "Block", + "Blocks") + .replace("block", + "blocks"); + } + } else { + name += "s"; + } + } + + NewPacketHandler.SEND_MESSAGE + .sendToAllPlayers( + "\u00A7eA world goal has been completed!" + + (!worldData.getDisadvantage() + .equals("None") ? " World disadvantage has been lifted!" + : "")); + + NewPacketHandler.SEND_MESSAGE + .sendToAllPlayers( + "\u00A7eA new world goal has been set: " + + (worldData.currentTask + + " " + + worldData.currentTaskAmount + + " " + + name + + ". (" + + worldData.progress + + " " + + worldData.currentTask + + "ed)")); + + worldData.currentDisadvantage = "None"; + } + + NewPacketHandler.UPDATE_WORLD_DATA + .sendToAllPlayers( + worldData.potionValues, + worldData.potionDurations, + worldData.getDisadvantage(), + worldData.currentTask, + worldData.currentTaskID, + worldData.currentTaskAmount, + worldData.progress, + worldData.tasksCompleted, + worldData.enderDragonKilled, + ModjamMod.spawnTraps, + worldData.rewardLevels, + worldData.mushroomColors); + + worldData.setDirty( + true); + } + } + } + } + } + + for (Entity e : addLater) { + WorldServer world = null; + + for (WorldServer s : server.worlds) { + if (s.provider.getDimension() == e.dimension) { + world = s; + break; + } + } + + if (world != null) { + world.spawnEntity(e); + } + } + + addLater.clear(); + + if (worldData != null) { + if (worldData.getDisadvantage() + .equals("Neverending Rain")) { + if (!server.worlds[0].getWorldInfo() + .isRaining()) { + server.worlds[0].getWorldInfo() + .setRaining(true); + } + + if (!server.worlds[0].getWorldInfo() + .isThundering()) { + server.worlds[0].getWorldInfo() + .setThundering(true); + } + } else if (worldData.getDisadvantage() + .equals("Neverending Night")) { + server.worlds[0].getWorldInfo() + .setWorldTime(18000); + } + } + } + + private boolean canAdvanceBurnTaskProgress(ItemStack stack) { + return worldData.currentTask.equals("Burn") && (stack + .getItem() == FyresWorldData.validItems[worldData.currentTaskID] + .getItem() + && stack.getItemDamage() == FyresWorldData.validItems[worldData.currentTaskID] + .getItemDamage()); + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/handlers/FyresKeyHandler.java b/src/main/java/fyresmodjam/handlers/FyresKeyHandler.java new file mode 100644 index 0000000..3938c4f --- /dev/null +++ b/src/main/java/fyresmodjam/handlers/FyresKeyHandler.java @@ -0,0 +1,186 @@ +package fyresmodjam.handlers; + +import org.lwjgl.input.Keyboard; + +import fyresmodjam.ModjamMod; +import fyresmodjam.blessings.Blessing; +import fyresmodjam.blessings.BlessingUtils; +import net.minecraft.client.Minecraft; +import net.minecraft.client.settings.KeyBinding; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.math.RayTraceResult; +import net.minecraftforge.fml.client.registry.ClientRegistry; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.InputEvent.KeyInputEvent; + +public class FyresKeyHandler { + + public static KeyBinding examine = new KeyBinding( + "Examine", Keyboard.KEY_X, "YWD"); + public static KeyBinding activateBlessing = new KeyBinding( + "Activate Blessing", Keyboard.KEY_K, "YWD"); + + public static KeyBinding[] keyBindings = new KeyBinding[] { + examine, activateBlessing + }; + + public FyresKeyHandler() { + for (KeyBinding k : keyBindings) { + ClientRegistry.registerKeyBinding(k); + } + } + + @SubscribeEvent + public void keyInput(KeyInputEvent event) { + if (Minecraft.getMinecraft().inGameHasFocus) { + Minecraft minecraft = Minecraft.getMinecraft(); + EntityPlayer player = minecraft.player; + + // TODO fix this + /* + if (player != null) { + if (examine.isPressed()) { + if (minecraft.objectMouseOver != null) { + + RayTraceResult o = minecraft.objectMouseOver; + + if (o.typeOfHit == RayTraceResult.Type.BLOCK) { + int x = minecraft.objectMouseOver.blockX; + int y = minecraft.objectMouseOver.blockY; + int z = minecraft.objectMouseOver.blockZ; + + if (minecraft.theWorld + .getBlock(x, y, z) == ModjamMod.blockPillar + && (minecraft.theWorld + .getBlockMetadata( + x, + y, + z) + % 2) == 1) { + y--; + } + + TileEntity te = minecraft.theWorld + .getTileEntity(x, + y, + z); + + if (te != null && te instanceof TileEntityPillar) { + Blessing bless = BlessingUtils + .getBlessingInstance( + ((TileEntityPillar) te).blessing); + + String s = "@\u00A7e " + + bless.customName() + + "\n" + + bless.description() + + "."; + + for (String s2 : s + .split("@")) { + + NewPacketHandler.SEND_MESSAGE.data = new Object[] { + s2 + }; + NewPacketHandler.SEND_MESSAGE + .executeClient(Minecraft + .getMinecraft().player); + } + + } else if (te != null + && te instanceof TileEntityTrap) { + String placedBy = ((TileEntityTrap) te).placedBy; + + String s = (placedBy != null + ? "\u00A7eThis " + ItemTrap.names[te + .getBlockMetadata() + % BlockTrap.trapTypes] + .toLowerCase() + + " was placed by " + + (placedBy.equals( + player.getCommandSenderName()) + ? "you" + : placedBy) + + "." + : "\u00A7eThis " + ItemTrap.names[te + .getBlockMetadata() + % BlockTrap.trapTypes] + .toLowerCase() + + " doesn't seem to have been placed by anyone."); + s += " \u00A7eTrap is set to " + + TileEntityTrap.settings[((TileEntityTrap) te).setting] + + "."; + + NewPacketHandler.SEND_MESSAGE.data = new Object[] { + s + }; + NewPacketHandler.SEND_MESSAGE + .executeClient(Minecraft + .getMinecraft().player); + } else { + ItemStack stack = new ItemStack( + minecraft.theWorld + .getBlock(x, y, z), + 1, + minecraft.theWorld + .getBlockMetadata( + x, + y, + z)); + + if (stack.getItem() != null) { + String name = stack + .getDisplayName() + .toLowerCase(); + + NewPacketHandler.SEND_MESSAGE.data = new Object[] { + "\u00A7eIt's a " + name + + (!name.contains( + "block") ? " block." + : ".") + }; + NewPacketHandler.SEND_MESSAGE + .executeClient(Minecraft + .getMinecraft().player); + } + } + } else if (o.typeOfHit == MovingObjectType.ENTITY + && o.entityHit != null) { + NewPacketHandler.EXAMINE_MOB + .sendToServer(o.entityHit.dimension, + o.entityHit.getEntityId()); + } + } + } + + if (activateBlessing.isPressed()) { + String blessing = player + .getEntityData() + .getString("Blessing"); + + if (blessing != null) { + FMLLog.info("Triggering blessing"); + + if (minecraft.objectMouseOver != null) { + MovingObjectPosition o = minecraft.objectMouseOver; + if (o.typeOfHit == MovingObjectType.BLOCK) { + NewPacketHandler.ACTIVATE_BLESSING + .sendToServer(minecraft.objectMouseOver.blockX, + minecraft.objectMouseOver.blockY, + minecraft.objectMouseOver.blockZ); + } + } else { + NewPacketHandler.ACTIVATE_BLESSING + .sendToServer(player.chunkCoordX, + player.chunkCoordY, + player.chunkCoordZ); + } + } + } + } + */ + } + } +} diff --git a/src/main/java/fyresmodjam/handlers/GUIHandler.java b/src/main/java/fyresmodjam/handlers/GUIHandler.java new file mode 100644 index 0000000..80d1062 --- /dev/null +++ b/src/main/java/fyresmodjam/handlers/GUIHandler.java @@ -0,0 +1,21 @@ +package fyresmodjam.handlers; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.world.World; +import net.minecraftforge.fml.common.network.IGuiHandler; + +public class GUIHandler implements IGuiHandler { + + @Override + public Object getServerGuiElement(int ID, EntityPlayer player, + World world, int x, int y, int z) { + return null; + } + + @Override + public Object getClientGuiElement(int ID, EntityPlayer player, + World world, int x, int y, int z) { + return null; + } + +} diff --git a/src/main/java/fyresmodjam/handlers/NewPacketHandler.java b/src/main/java/fyresmodjam/handlers/NewPacketHandler.java new file mode 100644 index 0000000..4fac1d5 --- /dev/null +++ b/src/main/java/fyresmodjam/handlers/NewPacketHandler.java @@ -0,0 +1,1067 @@ +package fyresmodjam.handlers; + +import java.nio.charset.Charset; +import java.util.ArrayList; + +import fyresmodjam.ModjamMod; +import fyresmodjam.blessings.BlessingUtils; +import fyresmodjam.misc.EntityStatHelper; +import fyresmodjam.misc.ItemStatHelper; +import io.netty.buffer.ByteBuf; +import io.netty.channel.ChannelHandlerContext; +import net.minecraft.client.Minecraft; +import net.minecraft.entity.Entity; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.network.INetHandler; +import net.minecraft.network.NetHandlerPlayServer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.DamageSource; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.text.TextComponentString; +import net.minecraft.world.WorldServer; +import net.minecraftforge.fml.common.FMLCommonHandler; +import net.minecraftforge.fml.common.network.FMLIndexedMessageToMessageCodec; +import net.minecraftforge.fml.common.network.FMLOutboundHandler; +import net.minecraftforge.fml.common.network.NetworkRegistry; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +@SuppressWarnings("rawtypes") +public class NewPacketHandler { + + public static BasicPacket[] packetTypes = new BasicPacket[256]; + + public static int[] potionValues = new int[12]; + public static int[] potionDurations = new int[12]; + + public static int[][] mushroomColors = new int[13][2]; + + public static String currentDisadvantage = null; + + public static String currentTask = null; + public static int currentTaskID = -1; + public static int currentTaskAmount = 0; + public static int progress = 0; + public static int tasksCompleted = 0; + public static int rewardLevels = 0; + + public static boolean enderDragonKilled = false; + public static boolean trapsDisabled = false; + + public static interface IPacket { + public void readBytes(ByteBuf bytes); + + public void writeBytes(ByteBuf bytes); + + public void executeClient(EntityPlayer player); + + public void executeServer(EntityPlayer player); + + public void executeBoth(EntityPlayer player); + } + + public static class ChannelHandler + extends FMLIndexedMessageToMessageCodec { + + public ChannelHandler() { + addDiscriminator(0, BasicPacket.class); + + } + + @Override + public void encodeInto(ChannelHandlerContext ctx, + IPacket packet, ByteBuf data) + throws Exception { + packet.writeBytes(data); + } + + @Override + public void decodeInto(ChannelHandlerContext ctx, + ByteBuf data, IPacket packet) { + packet.readBytes(data); + + if (packet instanceof BasicPacket) { + packetTypes[((BasicPacket) packet).type].data = ((BasicPacket) packet).data; + } + + EntityPlayer player = null; + + switch (FMLCommonHandler.instance() + .getEffectiveSide()) { + + case CLIENT: + + player = getClientPlayer(); + + if (player != null) { + packet.executeClient( + player); + packet.executeBoth(player); + } + + break; + + case SERVER: + + INetHandler netHandler = ctx + .channel() + .attr(NetworkRegistry.NET_HANDLER) + .get(); + player = ((NetHandlerPlayServer) netHandler).player; + + if (player != null) { + packet.executeServer( + player); + packet.executeBoth(player); + } + + break; + + default: + break; + + } + } + + @SideOnly(Side.CLIENT) + public EntityPlayer getClientPlayer() { + return Minecraft.getMinecraft().player; + } + } + + public static class BasicPacket implements IPacket { + public static Class[] validClassArray = { + Integer.class, Boolean.class, String.class, + Character.class, Byte.class, Float.class, + Double.class, int[].class, int[][].class + }; + public static ArrayList validClasses = new ArrayList(); + static { + for (Class c : validClassArray) { + validClasses.add(c); + } + } + + public Object[] data = null; + public byte type; + + public BasicPacket() { + } + + public BasicPacket(int type) { + if (type == 0 || packetTypes[type] != null) { + throw new RuntimeException("Packet slot " + + type + + " already in use."); + } + packetTypes[type] = this; + this.type = (byte) type; + } + + public BasicPacket(BasicPacket packet, Object... data) { + if (packet.type > 0 + && packet.type < packetTypes.length + && packet == packetTypes[packet.type]) { + type = packet.type; + } else { + throw new RuntimeException( + "Must supply valid packet type."); + } + + Class[] classes = getExpectedClasses(); + + if (classes != null) { + for (Class c : classes) { + if (!validClasses.contains(c)) { + throw new RuntimeException( + "Argument class not valid. (" + + c + + ")"); + } + } + + if (data == null || data.length != classes.length) { + throw new RuntimeException( + "Wrong number of arguments provided."); + } else { + for (int i = 0; i < data.length; i++) { + if (data[i].getClass() != classes[i]) { + throw new RuntimeException( + "Wrong argument class provided. (" + + data[i].getClass() + + ", expected " + + classes[i] + + ")"); + } + } + } + } + + this.data = data; + } + + @Override + public void readBytes(ByteBuf bytes) { + type = bytes.readByte(); + + Class[] classes = getExpectedClasses(); + + if (classes != null) { + data = new Object[classes.length]; + + for (int i = 0; i < classes.length; i++) { + if (classes[i] == Integer.class) { + data[i] = bytes.readInt(); + } + if (classes[i] == int[].class) { + int[] array = new int[bytes + .readInt()]; + for (int i2 = 0; i2 < array.length; i2++) { + array[i2] = bytes + .readInt(); + } + data[i] = array; + } + if (classes[i] == int[][].class) { + int[][] array = new int[bytes + .readInt()][]; + + for (int i2 = 0; i2 < array.length; i2++) { + array[i2] = new int[bytes + .readInt()]; + for (int i3 = 0; i3 < array[i2].length; i3++) { + array[i2][i3] = bytes + .readInt(); + } + } + + data[i] = array; + } else if (classes[i] == Boolean.class) { + data[i] = bytes.readBoolean(); + } else if (classes[i] == String.class) { + int length = bytes + .readInt(); + try { + byte[] stringBytes = new byte[length]; + bytes.readBytes(stringBytes); + data[i] = new String( + stringBytes, + "UTF-8"); + } catch (Exception e) { + e.printStackTrace(); + } + } else if (classes[i] == Byte.class) { + data[i] = bytes.readByte(); + } else if (classes[i] == Float.class) { + data[i] = bytes.readDouble(); + } else if (classes[i] == Double.class) { + data[i] = bytes.readFloat(); + } else if (classes[i] == Character.class) { + data[i] = bytes.readChar(); + } + } + } + } + + @Override + public void writeBytes(ByteBuf bytes) { + bytes.writeByte(type); + + if (data != null) { + for (int i = 0; i < data.length; i++) { + if (data[i] instanceof Integer) { + bytes.writeInt((Integer) data[i]); + } else if (data[i] instanceof int[]) { + bytes.writeInt(((int[]) data[i]).length); + for (int i2 = 0; i2 < ((int[]) data[i]).length; i2++) { + bytes.writeInt(((int[]) data[i])[i2]); + } + } else if (data[i] instanceof int[][]) { + int[][] values = (int[][]) data[i]; + + bytes.writeInt(values.length); + + for (int i2 = 0; i2 < values.length; i2++) { + bytes.writeInt(values[i2].length); + for (int i3 = 0; i3 < values[i2].length; i3++) { + bytes.writeInt(values[i2][i3]); + } + } + } else if (data[i] instanceof Boolean) { + bytes.writeBoolean( + (Boolean) data[i]); + } else if (data[i] instanceof String) { + byte[] stringBytes = ((String) data[i]) + .getBytes(Charset + .forName("UTF-8")); + bytes.writeInt(stringBytes.length); + bytes.writeBytes( + stringBytes); + } else if (data[i] instanceof Byte) { + bytes.writeByte((Byte) data[i]); + } else if (data[i] instanceof Float) { + bytes.writeDouble( + (Double) data[i]); + } else if (data[i] instanceof Double) { + bytes.writeFloat( + (Float) data[i]); + } else if (data[i] instanceof Character) { + bytes.writeChar((Character) data[i]); + } + } + } + } + + @Override + public void executeClient(EntityPlayer player) { + if (packetTypes[type] != this) { + packetTypes[type].executeClient(player); + } + } + + @Override + public void executeServer(EntityPlayer player) { + if (packetTypes[type] != this) { + packetTypes[type].executeServer(player); + } + } + + @Override + public void executeBoth(EntityPlayer player) { + if (packetTypes[type] != this) { + packetTypes[type].executeBoth(player); + } + } + + public Class[] getExpectedClasses() { + if (packetTypes[type] != this) { + return packetTypes[type] + .getExpectedClasses(); + } else { + return null; + } + } + + public void sendToPlayer(EntityPlayer player, + Object... data) { + sendPacketToPlayer(new BasicPacket(this, data), + player); + } + + public void sendToAllPlayers(Object... data) { + sendPacketToAllPlayers( + new BasicPacket(this, data)); + } + + public void sendToServer(Object... data) { + sendPacketToServer(new BasicPacket(this, data)); + } + } + + public static void sendPacketToPlayer(IPacket packet, + EntityPlayer player) { + ModjamMod.channels.get(Side.SERVER) + .attr(FMLOutboundHandler.FML_MESSAGETARGET) + .set(FMLOutboundHandler.OutboundTarget.PLAYER); + ModjamMod.channels.get(Side.SERVER).attr( + FMLOutboundHandler.FML_MESSAGETARGETARGS) + .set(player); + ModjamMod.channels.get(Side.SERVER).writeOutbound(packet); + } + + public static void sendPacketToAllPlayers(IPacket packet) { + ModjamMod.channels.get(Side.SERVER) + .attr(FMLOutboundHandler.FML_MESSAGETARGET) + .set(FMLOutboundHandler.OutboundTarget.ALL); + ModjamMod.channels.get(Side.SERVER).writeOutbound(packet); + } + + public static void sendPacketToServer(IPacket packet) { + ModjamMod.channels.get(Side.CLIENT) + .attr(FMLOutboundHandler.FML_MESSAGETARGET) + .set(FMLOutboundHandler.OutboundTarget.TOSERVER); + ModjamMod.channels.get(Side.CLIENT).writeOutbound(packet); + } + + public static final BasicPacket + + UPDATE_BLESSING = new BasicPacket(1) { + @Override + public void executeBoth(EntityPlayer player) { + player.getEntityData().setString("Blessing", + (String) data[0]); + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + String.class + }; + } + }, + + PLAY_SOUND = new BasicPacket(2) { + @Override + public void executeServer( + EntityPlayer player) { + String sound = (String) data[0]; + int x = (Integer) data[1], + y = (Integer) data[2], + z = (Integer) data[3]; + + // TODO fix this + // player.world.playSound(player, + // new BlockPos(x, y, z), + // "fyresmodjam:" + sound, + // 1.0F, 1.0F, false); + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + String.class, + Integer.class, + Integer.class, + Integer.class + }; + } + }, + + UPDATE_POTION_KNOWLEDGE = new BasicPacket(3) { + @Override + public void executeBoth( + EntityPlayer player) { + player.getEntityData().setIntArray( + "PotionKnowledge", + (int[]) data[0]); + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + int[].class + }; + } + }, + + SEND_MESSAGE = new BasicPacket(4) { + @Override + public void executeClient( + EntityPlayer player) { + String style = ""; + + for (String s : ((String) data[0]) + .split("@")) { + String[] words = s.split( + " "); + s = ""; + + for (String word : words) { + s += style + word + + " "; + + while (word.contains( + "\u00A7")) { + int firstOccurance = word + .indexOf("\u00A7"); + String string = word + .substring(firstOccurance, + firstOccurance + 2); + + if (style.contains( + string)) { + style = style.replace( + string, + ""); + } + style += string; + if (string.equals( + "\u00A7r")) { + style = ""; + } + + word = word.replaceFirst( + string, + ""); + } + } + + player.sendMessage( + new TextComponentString( + s)); + } + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + String.class + }; + } + }, + + UPDATE_WORLD_DATA = new BasicPacket(5) { + @Override + public void executeClient( + EntityPlayer player) { + potionValues = (int[]) data[0]; + potionDurations = (int[]) data[1]; + currentDisadvantage = (String) data[2]; + currentTask = (String) data[3]; + currentTaskID = (Integer) data[4]; + currentTaskAmount = (Integer) data[5]; + progress = (Integer) data[6]; + tasksCompleted = (Integer) data[7]; + enderDragonKilled = (Boolean) data[8]; + trapsDisabled = !((Boolean) data[9]); + rewardLevels = (Integer) data[10]; + mushroomColors = (int[][]) data[11]; + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + int[].class, + int[].class, + String.class, + String.class, + Integer.class, + Integer.class, + Integer.class, + Integer.class, + Boolean.class, + Boolean.class, + Integer.class, + int[][].class + }; + } + }, + + UPDATE_PLAYER_ITEMS = new BasicPacket(6) { + @Override + public void executeServer( + EntityPlayer player) { + for (Object stack : player.inventory.mainInventory) { + if (stack == null + || !(stack instanceof ItemStack)) { + continue; + } + ItemStatHelper.processItemStack( + (ItemStack) stack, + ModjamMod.r); + } + } + + @Override + public Class[] getExpectedClasses() { + return null; + } + }, + + DISARM_TRAP = new BasicPacket(7) { + @Override + public void executeServer( + EntityPlayer player) { + int blockX = (Integer) data[0], + blockY = (Integer) data[1], + blockZ = (Integer) data[2]; + boolean mechanic = (Boolean) data[3]; + + boolean scout = BlessingUtils + .hasBlessing(player, + "MarkScouting"); + + BlockPos blockPos = new BlockPos( + blockX, blockY, + blockZ); + TileEntity te = player.world + .getTileEntity(blockPos); + + boolean yours = false; + + if (yours || (mechanic + ? ModjamMod.r.nextInt( + 4) != 0 + : ModjamMod.r.nextInt( + 4) == 0)) { + boolean salvage = yours + || (mechanic ? ModjamMod.r + .nextBoolean() + : (ModjamMod.r.nextInt( + 4) == 0)); + + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7e\u00A7o" + (!salvage + ? "You disarmed the trap." + : "You disarm and salvage the trap.")); + + if (salvage) { + int meta = player.world + .getBlockState(blockPos) + .getBlock() + .getMetaFromState( + player.world.getBlockState( + player.getPosition())); + + ItemStack spawned = new ItemStack( + ModjamMod.itemTrap, + 1, + 0); + + player.world.spawnEntity( + new EntityItem(player.world, + blockX + 0.5F, + blockY, + blockZ + 0.5F, + spawned)); + } + + player.world.setBlockToAir( + blockPos); + } else { + int trapType = player.world + .getBlockState(blockPos) + .getBlock() + .getMetaFromState( + player.world.getBlockState( + player.getPosition())); + + // TODO use a custom damage + // type for the traps + if (trapType == 0) { + player.attackEntityFrom( + DamageSource.CACTUS, + 4.0F + (scout ? 1 + : 0)); + if (ModjamMod.r.nextInt( + 16 - (scout ? 4 + : 0)) == 0) { + // TODO + // figure + // out how + // potion + // effects + // work + + // ((EntityLivingBase) + // player) + // .addPotionEffect( + // new + // PotionEffect( + // Potion.POISON.id, + // 100 + + // (scout ? + // 25 + // : 0), + // 1)); + } + } else if (trapType == 1) { + if (!player.isBurning()) { + player.setFire(5 + (scout + ? 1 + : 0)); + } + } else if (trapType == 2) { + // TODO figure out + // how potion + // effects work + + // player.addPotionEffect( + // new + // PotionEffect( + // Potion.blindness.id, + // 100 + (scout ? + // 25 + // : 0), + // 1)); + // player.addPotionEffect( + // new + // PotionEffect( + // Potion.moveSlowdown.id, + // 100 + (scout ? + // 25 + // : 0), + // 1)); + } + + player.world.setBlockToAir( + blockPos); + + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7c\u00A7oYou failed to disarm the trap."); + + if (CommonTickHandler.worldData + .getDisadvantage() + .equals("Explosive Traps")) { + player.world.setBlockToAir( + blockPos); + player.world.createExplosion( + null, + blockX + 0.5F, + blockY + 0.5F, + blockZ + 0.5F, + 1.33F, + true); + } + + // TODO swap to advancement + // player.triggerAchievement( + // ModjamMod.whoops); + } + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + Integer.class, + Integer.class, + Integer.class, + Boolean.class + }; + } + }, + + EXAMINE_MOB = new BasicPacket(8) { + @Override + public void executeServer( + EntityPlayer player) { + int dimension = (Integer) data[0]; + int entityID = (Integer) data[1]; + + WorldServer server = null; + + for (WorldServer s : player.world + .getMinecraftServer().worlds) { + if (s.provider.getDimension() == dimension) { + server = s; + break; + } + } + + if (server != null) { + Entity entity = server + .getEntityByID(entityID); + + if (entity != null) { + String blessing2 = entity + .getEntityData() + .hasKey("Blessing") + ? entity.getEntityData() + .getString("Blessing") + : null; + + if (blessing2 != null) { + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7eYou notice " + + entity.getName() + + "\u00A7e is using " + + BlessingUtils.getBlessingInstance( + blessing2) + .customName() + + "."); + } else { + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7eThere doesn't seem to be anything special about " + + (entity instanceof EntityPlayer + ? "" + : "this ") + + entity.getName() + + "\u00A7e."); + } + } + } + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + Integer.class, + Integer.class + }; + } + }, + + LEVEL_UP = new BasicPacket(9) { + @Override + public void executeBoth( + EntityPlayer player) { + player.addExperienceLevel( + (Integer) data[0]); + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + Integer.class + }; + } + }, + + ACTIVATE_BLESSING = new BasicPacket(10) { + @Override + public void executeServer( + EntityPlayer player) { + + int x = (Integer) data[0], + y = (Integer) data[1], + z = (Integer) data[2]; + + boolean blessingActive = EntityStatHelper + .hasStat(player, "BlessingActive") + ? Boolean.parseBoolean( + EntityStatHelper.getStat( + player, + "BlessingActive")) + : false; + + if (!EntityStatHelper.hasStat( + player, + "BlessingCooldown")) { + EntityStatHelper.giveStat( + player, + "BlessingCooldown", + 0); + } + + long time = (CommonTickHandler.worldData != null + && CommonTickHandler.worldData + .getDisadvantage() + .equals("Neverending Rain")) + ? player.world.getTotalWorldTime() + : player.world.getWorldTime(); + + if (EntityStatHelper.getStat( + player, + "BlessingCooldown") + .equals("0")) { + if (!blessingActive) { + if (BlessingUtils + .hasBlessing(player)) { + if (BlessingUtils + .hasBlessing(player, + "BlessingBerserker")) { + if (hasBlessingCounters( + player)) { + blessingActive = true; + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7cYou enter berserk mode."); + } else { + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7cYou have no berserk counters."); + } + } else if (BlessingUtils + .hasBlessing(player, + "BlessingMechanic")) { + BlockPos blockPos = new BlockPos( + x, + y, + z); + + TileEntity te = player.world + .getTileEntity(blockPos); + + /* + * if + * (te + * != + * null + * && + * te + * instanceof + * TileEntityTrap) + * { + * SEND_MESSAGE + * . + * sendToPlayer( + * player, + * "\u00A7e\u00A7oYou disarm and salvage the trap." + * ); + * + * int + * meta + * = + * player + * . + * world + * .getBlockState + * ( + * blockPos) + * .getBlock + * ( + * ) + * .getMetaFromState( + * player + * . + * world + * . + * getBlockState( + * player + * . + * getPosition + * ( + * ) + * ) + * ) + * ; + * + * player + * . + * world + * . + * spawnEntity( + * new + * EntityItem + * ( + * player + * . + * world, + * x + * + + * 0 + * . + * 5F, + * y, + * z + * + + * 0 + * . + * 5F, + * new + * ItemStack + * ( + * ModjamMod + * . + * itemTrap, + * 1, + * meta + * % + * BlockTrap + * . + * trapTypes + * ) + * ) + * ) + * ; + * player + * . + * world + * . + * setBlockToAir( + * blockPos + * ) + * ; + * + * EntityStatHelper + * . + * giveStat( + * player, + * "BlessingCooldown", + * 24000 + * - + * (time + * % + * 24000 + * ) + * ) + * ; + * } + * else + * { + * SEND_MESSAGE + * . + * sendToPlayer( + * player, + * "\u00A7e\u00A7oNo selected trap." + * ); + * } + */ + } + } + } else { + blessingActive = false; + + if (BlessingUtils + .hasBlessing(player)) { + if (BlessingUtils + .hasBlessing(player, + "BlessingBerserker")) { + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7cYou calm down."); + + EntityStatHelper.giveStat( + player, + "BlessingCooldown", + 1200); + } + } + + EntityStatHelper.giveStat( + player, + "BlessingTimer", + 0); + } + } else { + SEND_MESSAGE.sendToPlayer( + player, + "\u00A7cBlessing is on cooldown. (" + + (Integer.parseInt( + EntityStatHelper.getStat( + player, + "BlessingCooldown"))) + / 20 + + "s)"); + } + + EntityStatHelper.giveStat(player, + "BlessingActive", + blessingActive); + } + + private boolean hasBlessingCounters( + EntityPlayer player) { + return EntityStatHelper.hasStat( + player, + "BlessingCounter") + && Integer.parseInt( + EntityStatHelper.getStat( + player, + "BlessingCounter")) > 0; + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + Integer.class, + Integer.class, + Integer.class + }; + } + }, + + UPDATE_STAT = new BasicPacket(11) { + @Override + public void executeBoth( + EntityPlayer player) { + EntityStatHelper.giveStat(player, + (String) data[0], + data[1]); + } + + @Override + public Class[] getExpectedClasses() { + return new Class[] { + String.class, + String.class + }; + } + }; +} diff --git a/src/main/java/fyresmodjam/misc/ArmorStatTracker.java b/src/main/java/fyresmodjam/misc/ArmorStatTracker.java new file mode 100644 index 0000000..80a8c2a --- /dev/null +++ b/src/main/java/fyresmodjam/misc/ArmorStatTracker.java @@ -0,0 +1,79 @@ +package fyresmodjam.misc; + +import java.util.Random; + +import fyresmodjam.ModjamMod; +import net.minecraft.item.ItemBow; +import net.minecraft.item.ItemStack; + +public final class ArmorStatTracker extends ItemStat { + public String[][] prefixesByRank = { + { + "Old", "Broken", "Worn", "Weak" + }, { + "Average", "Decent", "Modest", + "Ordinary" + }, { + "Polished", "Tough", "Hardened", + "Durable" + }, { + "Elite", "Astonishing", + "Reinforced", "Resilient" + }, { + "Godly", "Divine", "Fabled", + "Legendary" + } + }; + + public ArmorStatTracker(String name, Object value) { + super(name, value); + } + + @Override + public Object getNewValue(ItemStack stack, Random r) { + int i = 1; + for (; i < 5; i++) { + if (ModjamMod.r.nextInt(10) < 7) { + break; + } + } + return i; + } + + @Override + public void modifyStack(ItemStack stack, Random r) { + int rank = Integer.parseInt( + stack.getTagCompound().getString(name)); + float damageReduction = (rank - 1) + r.nextFloat() * 0.5F; + + ItemStatHelper.giveStat(stack, "DamageReduction", + String.format("%.2f", damageReduction)); + ItemStatHelper.addLore(stack, !String + .format("%.2f", damageReduction) + .equals("0.00") ? "\u00A77\u00A7o " + + (damageReduction > 0 + ? "+" + : "") + + String.format("%.2f", + damageReduction) + + "% damage reduction" + : null); + + ItemStatHelper.addLore(stack, "\u00A7eRank: " + rank); + } + + @Override + public String getAlteredStackName(ItemStack stack, Random r) { + String[] list = prefixesByRank[Integer.parseInt( + stack.getTagCompound().getString(name)) + - 1]; + String prefix = list[r.nextInt(list.length)]; + + if (prefix.equals("Sharp") + && stack.getItem() instanceof ItemBow) { + prefix = "Long"; + } + + return "\u00A7f" + prefix + " " + stack.getDisplayName(); + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/misc/CreativeTabModjamMod.java b/src/main/java/fyresmodjam/misc/CreativeTabModjamMod.java new file mode 100644 index 0000000..821af0f --- /dev/null +++ b/src/main/java/fyresmodjam/misc/CreativeTabModjamMod.java @@ -0,0 +1,81 @@ +package fyresmodjam.misc; + +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.List; + +import fyresmodjam.ModjamMod; +import net.minecraft.block.Block; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +public class CreativeTabModjamMod extends CreativeTabs { + + public CreativeTabModjamMod(int par1, String par2Str) { + super(par1, par2Str); + } + + @Override + @SideOnly(Side.CLIENT) + public ItemStack getIconItemStack() { + return new ItemStack(ModjamMod.itemTrap, 1, 0); + } + + @Override + public String getTranslatedTabLabel() { + return "The \"You Will Die\" Mod"; + } + + @Override + public void displayAllRelevantItems( + NonNullList par1List) { + try { + ArrayList list = new ArrayList(); + /* + for (Field f : ModjamMod.class.getFields()) { + if (f.getType() == Item.class) { + Item item = (Item) f.get( + ModjamMod.instance); + if (item == null || item + .getCreativeTab() == null) { + continue; + } + + } else if (f.getType() == Block.class) { + Block block = (Block) f.get( + ModjamMod.instance); + if (block == null || block + .getCreativeTabToDisplayOn() == null) { + continue; + } + block.getSubBlocks(block.getItem( + null, 0, 0, 0), + this, list); + } + } + + for (ItemStack i : list) { + if (i == null || i.getItem() == null) { + continue; + } + if (i.getItem().getIconIndex(i) != null) { + par1List.add(i); + } + } + */ + } catch (Exception e) { + e.printStackTrace(); + } + } + + @Override + public ItemStack getTabIconItem() { + return new ItemStack(Items.SPAWN_EGG); + } + +} diff --git a/src/main/java/fyresmodjam/misc/DamageSources.java b/src/main/java/fyresmodjam/misc/DamageSources.java new file mode 100644 index 0000000..b1fdc01 --- /dev/null +++ b/src/main/java/fyresmodjam/misc/DamageSources.java @@ -0,0 +1,22 @@ +package fyresmodjam.misc; + +import net.minecraft.util.DamageSource; + +public class DamageSources { + private static boolean isInitted = false; + + public static DamageSource inferno, retaliation; + + public static void doInit() { + if (isInitted) { + inferno = new DamageSource("inferno") + .setDamageBypassesArmor() + .setDamageIsAbsolute(); + + retaliation = new DamageSource("retaliation") + .setDamageBypassesArmor(); + + isInitted = true; + } + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/misc/EntityStat.java b/src/main/java/fyresmodjam/misc/EntityStat.java new file mode 100644 index 0000000..ce1247f --- /dev/null +++ b/src/main/java/fyresmodjam/misc/EntityStat.java @@ -0,0 +1,27 @@ +package fyresmodjam.misc; + +import java.util.Random; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLiving; + +public class EntityStat { + public String name; + public String value; + + public EntityStat(String name, String value) { + this.name = name; + this.value = value; + } + + public Object getNewValue(Random r) { + return value; + } + + public String getAlteredEntityName(EntityLiving entity) { + return entity.getName(); + } + + public void modifyEntity(Entity entity) { + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/misc/EntityStatHelper.java b/src/main/java/fyresmodjam/misc/EntityStatHelper.java new file mode 100644 index 0000000..7022fed --- /dev/null +++ b/src/main/java/fyresmodjam/misc/EntityStatHelper.java @@ -0,0 +1,740 @@ +package fyresmodjam.misc; + +import java.lang.reflect.Constructor; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Random; + +import fyresmodjam.ModjamMod; +import fyresmodjam.blessings.BlessingUtils; +import fyresmodjam.handlers.CommonTickHandler; +import fyresmodjam.handlers.NewPacketHandler; +import fyresmodjam.worldgen.FyresWorldData; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityList; +import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.boss.EntityDragon; +import net.minecraft.entity.monster.EntityMob; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumHand; +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.text.translation.I18n; +import net.minecraft.world.World; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.entity.EntityJoinWorldEvent; +import net.minecraftforge.event.entity.living.LivingDeathEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; + +@SuppressWarnings("rawtypes") +public class EntityStatHelper { + + public static String[] knowledge = { + "Clueless", "Novice", "Competent", "Talented", + "Expert", "Professional", "Master", "Legendary" + }; + + public static int[] killCount = { + 0, 10, 25, 50, 100, 250, 500, 1000 + }; + + public static float[] damageBonus = { + 0, 0.01F, 0.025F, 0.05F, 0.075F, 0.1F, 0.15F, 0.2F + }; + public static String[] damageBonusString = { + "0", "1", "2.5", "5", "7.5", "10", "15", "20" + }; + + public static HashMap statTrackersByClass = new HashMap(); + + public static ArrayList genericTrackers = new ArrayList(); + + public static ArrayList temp = new ArrayList(); + public static boolean b = false; + + public static void addStatTracker(EntityStatTracker statTracker) { + if (statTracker.classes != null) { + for (Class c : statTracker.classes) { + statTrackersByClass.put(c, statTracker); + } + + if (statTracker.instanceAllowed) { + genericTrackers.add(statTracker); + } + } + } + + public static String getStat(Entity entity, String name) { + String s = null; + + if (entity.getEntityData() != null + && entity.getEntityData().hasKey(name)) { + s = entity.getEntityData().getString(name); + } + + return s; + } + + public static String getUnalteredItemName(Item item) { + return I18n.translateToLocal( + item.getUnlocalizedName() + ".name"); + } + + public static String getUnalteredName(Entity entity) { + String s = EntityList.getEntityString(entity); + + if (s == null) { + s = "generic"; + } + + return I18n.translateToLocal("entity." + s + ".name"); + } + + public static Entity giveStat(Entity entity, String name, + Object value) { + if (entity != null && name != null && value != null) { + entity.getEntityData().setString(name, + value.toString()); + } + + return entity; + } + + public static boolean hasStat(Entity entity, String name) { + if (entity.getEntityData() != null + && entity.getEntityData().hasKey(name)) { + return true; + } + + return false; + } + + @SuppressWarnings("unchecked") + public static void processEntity(Entity entity, Random r) { + if (entity == null) { + return; + } + + temp.clear(); + + if (statTrackersByClass.containsKey(entity.getClass())) { + temp.add(statTrackersByClass + .get(entity.getClass())); + } + + for (EntityStatTracker e : genericTrackers) { + if (!temp.contains(e)) { + for (Class c : e.classes) { + if (c.isAssignableFrom(entity + .getClass())) { + temp.add(e); + break; + } + } + } + } + + if (!temp.isEmpty()) { + String processed = EntityStatHelper.getStat(entity, + "processed"); + + if (processed == null + || processed.equals("false")) { + EntityStatHelper.giveStat(entity, + "processed", "true"); + + for (EntityStatTracker statTracker : temp) { + for (EntityStat s : statTracker.stats) { + giveStat(entity, s.name, s + .getNewValue(r) + .toString()); + + if (entity instanceof EntityLiving) { + setName((EntityLiving) entity, + s.getAlteredEntityName( + (EntityLiving) entity)); + } + + s.modifyEntity(entity); + } + } + } + } + } + + public static void setEntitySize(Entity entity, float par1, + float par2) { + /* + * float f2; // TODO fix this if (par1 != entity.width || + * par2 != entity.height) { f2 = entity.width; entity.width + * = par1; entity.height = par2; AxisAlignedBB + * entityBoundingBox = entity.getEntityBoundingBox(); + * entityBoundingBox.maxX = entityBoundingBox.minX + + * entity.width; entityBoundingBox.maxZ = + * entityBoundingBox.minZ + entity.width; + * entityBoundingBox.maxY = entityBoundingBox.minY + + * entity.height; } + * + * f2 = par1 % 2.0F; + * + * if (f2 < 0.375D) { entity.myEntitySize = + * EnumEntitySize.SIZE_1; } else if (f2 < 0.75D) { + * entity.myEntitySize = EnumEntitySize.SIZE_2; } else if + * (f2 < 1.0D) { entity.myEntitySize = + * EnumEntitySize.SIZE_3; } else if (f2 < 1.375D) { + * entity.myEntitySize = EnumEntitySize.SIZE_4; } else if + * (f2 < 1.75D) { entity.myEntitySize = + * EnumEntitySize.SIZE_5; } else { entity.myEntitySize = + * EnumEntitySize.SIZE_6; } + */ + } + + public static Entity setName(EntityLiving entity, String name) { + entity.setCustomNameTag(name); + + return entity; + } + + private void addOnKillStats(EntityPlayer player, String mob) { + if (!player.getEntityData().hasKey("KillStats")) { + player.getEntityData().setTag("KillStats", + new NBTTagCompound()); + } + + NBTTagCompound killStats = player.getEntityData() + .getCompoundTag("KillStats"); + + if (!killStats.hasKey(mob)) { + killStats.setInteger(mob, 0); + + if (!killStats.hasKey("TrackedMobList")) { + killStats.setString("TrackedMobList", mob); + } else { + killStats.setString("TrackedMobList", + killStats.getString( + "TrackedMobList") + + ";" + + mob); + } + } + + killStats.setInteger(mob, killStats.getInteger(mob) + 1); + + if (ModjamMod.enableMobKillStats) { + for (int i = 0; i < knowledge.length; i++) { + if (killCount[i] == killStats + .getInteger(mob)) { + NewPacketHandler.SEND_MESSAGE + .sendToPlayer(player, + "\u00A7o\u00A73You've become a " + + knowledge[i].toLowerCase() + + " " + + mob.toLowerCase() + + " slayer! (+" + + damageBonusString[i] + + "% damage against " + + mob.toLowerCase() + + "s.)" + + (i < knowledge.length + - 1 ? " " + (killCount[i + 1] - killCount[i]) + " " + mob.toLowerCase() + " kills to next rank." : "")); + break; + } + } + + int count = 0; + + if (killStats.hasKey("TrackedMobList") && killStats + .getString("TrackedMobList") != null + && killStats.getString( + "TrackedMobList") + .length() > 0) { + for (String object : killStats.getString( + "TrackedMobList") + .split(";")) { + if (killStats.hasKey(object) + && killStats.getInteger( + object) >= killCount[2]) { + count++; + } + } + } + + if (count >= 5) { + // player.triggerAchievement( + // ModjamMod.theHunt); + } + } + + String weapon = "misc"; + + ItemStack heldItem = player + .getHeldItem(EnumHand.MAIN_HAND); + if (heldItem == null) { + weapon = "fist"; + } else if (heldItem.getItem() != null) { + weapon = getUnalteredItemName(heldItem.getItem()); + } + + if (!player.getEntityData().hasKey("WeaponStats")) { + player.getEntityData().setTag("WeaponStats", + new NBTTagCompound()); + } + NBTTagCompound weaponStats = player.getEntityData() + .getCompoundTag("WeaponStats"); + + if (!weaponStats.hasKey(weapon)) { + weaponStats.setInteger(weapon, 0); + + if (!weaponStats.hasKey("TrackedItemList")) { + weaponStats.setString("TrackedItemList", + weapon); + } else { + weaponStats.setString("TrackedItemList", + weaponStats.getString( + "TrackedItemList") + + ";" + + weapon); + } + } + + weaponStats.setInteger(weapon, + weaponStats.getInteger(weapon) + 1); + + if (ModjamMod.enableWeaponKillStats) { + for (int i = 0; i < knowledge.length; i++) { + if (killCount[i] * 2 == weaponStats + .getInteger(weapon)) { + NewPacketHandler.SEND_MESSAGE + .sendToPlayer(player, + "\u00A7o\u00A73You've become a " + + knowledge[i].toLowerCase() + + " " + + weapon.toLowerCase() + + " user! (+" + + damageBonusString[i] + + "% damage with " + + weapon.toLowerCase() + + "s.)" + + (i < knowledge.length + - 1 ? " " + (killCount[i + 1] * 2 - killCount[i] * 2) + " " + weapon.toLowerCase() + " kills to next rank." : "")); + break; + } + } + + int count = 0; + + if (weaponStats.hasKey("TrackedItemList") + && weaponStats.getString( + "TrackedItemList") != null + && weaponStats.getString( + "TrackedItemList") + .length() > 0) { + for (String object : weaponStats.getString( + "TrackedItemList") + .split(";")) { + if (weaponStats.hasKey(object) + && weaponStats.getInteger( + object) >= killCount[1] + * 2) { + count++; + } + } + } + + if (count >= 10) { + // player.triggerAchievement( + // ModjamMod.jackOfAllTrades); + } + } + } + + private void addPlayerStats(EntityJoinWorldEvent event) { + Entity entity = event.getEntity(); + String entityName = entity.getName(); + + if (!entity.getEntityData().hasKey("Blessing") + && CommonTickHandler.worldData.blessingByPlayer + .containsKey(entityName)) { + entity.getEntityData().setString("Blessing", + CommonTickHandler.worldData.blessingByPlayer + .get(entityName)); + + NewPacketHandler.UPDATE_BLESSING.sendToPlayer( + (EntityPlayer) entity, + entity.getEntityData().getString( + "Blessing")); + + CommonTickHandler.worldData.blessingByPlayer + .remove(entityName); + CommonTickHandler.worldData.markDirty(); + } + + if (!entity.getEntityData().hasKey("PotionKnowledge") + && CommonTickHandler.worldData.potionKnowledgeByPlayer + .containsKey(entityName)) { + entity.getEntityData().setIntArray( + "PotionKnowledge", + CommonTickHandler.worldData.potionKnowledgeByPlayer + .get(entityName)); + + NewPacketHandler.UPDATE_POTION_KNOWLEDGE + .sendToPlayer((EntityPlayer) entity, + entity.getEntityData() + .getIntArray("PotionKnowledge")); + + CommonTickHandler.worldData.potionKnowledgeByPlayer + .remove(entityName); + CommonTickHandler.worldData.markDirty(); + } + + if (!entity.getEntityData().hasKey("KillStats") + && CommonTickHandler.worldData.killStatsByPlayer + .containsKey(entityName)) { + entity.getEntityData().setTag("KillStats", + CommonTickHandler.worldData.killStatsByPlayer + .get(entityName)); + + CommonTickHandler.worldData.killStatsByPlayer + .remove(entityName); + CommonTickHandler.worldData.markDirty(); + } + + if (!entity.getEntityData().hasKey("WeaponStats") + && CommonTickHandler.worldData.weaponStatsByPlayer + .containsKey(entityName)) { + entity.getEntityData().setTag("WeaponStats", + CommonTickHandler.worldData.weaponStatsByPlayer + .get(entityName)); + + CommonTickHandler.worldData.killStatsByPlayer + .remove(entityName); + CommonTickHandler.worldData.markDirty(); + } + + if (!entity.getEntityData().hasKey("CraftingStats") + && CommonTickHandler.worldData.craftingStatsByPlayer + .containsKey(entityName)) { + entity.getEntityData().setTag("CraftingStats", + CommonTickHandler.worldData.craftingStatsByPlayer + .get(entityName)); + + CommonTickHandler.worldData.craftingStatsByPlayer + .remove(entityName); + CommonTickHandler.worldData.markDirty(); + } + } + + private void advanceKillTaskProgress(LivingDeathEvent event) { + CommonTickHandler.worldData.progress++; + + String name1 = CommonTickHandler.worldData.currentTask + .equals("Kill") ? FyresWorldData.validMobNames[CommonTickHandler.worldData.currentTaskID] + : FyresWorldData.validItems[CommonTickHandler.worldData.currentTaskID] + .getDisplayName(); + + if (name1.contains("Block")) { + if (name1.contains("Block")) { + name1 = name1.replace("Block", "Blocks") + .replace("block", + "blocks"); + } + } else { + name1 += "s"; + } + + NewPacketHandler.SEND_MESSAGE.sendToAllPlayers( + "\u00A7fCurrent Goal Progress: " + + CommonTickHandler.worldData.progress + + "/" + + CommonTickHandler.worldData.currentTaskAmount + + " " + name1 + " " + + CommonTickHandler.worldData.currentTask + + "ed."); + + if (CommonTickHandler.worldData.progress >= CommonTickHandler.worldData.currentTaskAmount) { + CommonTickHandler.worldData.progress = 0; + CommonTickHandler.worldData.tasksCompleted++; + + NewPacketHandler.LEVEL_UP.sendToAllPlayers( + CommonTickHandler.worldData.rewardLevels); + + if (!CommonTickHandler.worldData.enderDragonKilled + && event.getEntity() instanceof EntityDragon) { + CommonTickHandler.worldData.enderDragonKilled = true; + } + + CommonTickHandler.worldData.giveNewTask(); + + NewPacketHandler.SEND_MESSAGE.sendToAllPlayers( + "\u00A7eA world goal has been completed!" + + (!CommonTickHandler.worldData + .getDisadvantage() + .equals("None") ? " World disadvantage has been lifted!" + : "")); + + NewPacketHandler.SEND_MESSAGE.sendToAllPlayers( + "\u00A7eA new world goal has been set: " + + (CommonTickHandler.worldData.currentTask + + " " + + CommonTickHandler.worldData.currentTaskAmount + + " " + + (CommonTickHandler.worldData.currentTask + .equals("Kill") ? FyresWorldData.validMobNames[CommonTickHandler.worldData.currentTaskID] + : FyresWorldData.validItems[CommonTickHandler.worldData.currentTaskID] + .getDisplayName()) + + "s. (" + + CommonTickHandler.worldData.progress + + " " + + CommonTickHandler.worldData.currentTask + + "ed)")); + + CommonTickHandler.worldData.currentDisadvantage = "None"; + } + + NewPacketHandler.UPDATE_WORLD_DATA.sendToAllPlayers( + CommonTickHandler.worldData.potionValues, + CommonTickHandler.worldData.potionDurations, + CommonTickHandler.worldData + .getDisadvantage(), + CommonTickHandler.worldData.currentTask, + CommonTickHandler.worldData.currentTaskID, + CommonTickHandler.worldData.currentTaskAmount, + CommonTickHandler.worldData.progress, + CommonTickHandler.worldData.tasksCompleted, + CommonTickHandler.worldData.enderDragonKilled, + ModjamMod.spawnTraps, + CommonTickHandler.worldData.rewardLevels, + CommonTickHandler.worldData.mushroomColors); + + CommonTickHandler.worldData.markDirty(); + } + + private void cloneMob(EntityJoinWorldEvent event) { + event.getEntity().getEntityData().setBoolean("isClone", + true); + + Entity entityNew = null; + + try { + Constructor[] constructors = event.getEntity() + .getClass().getConstructors(); + + for (int i = 0; i < constructors.length; i++) { + Class[] parameters = constructors[i] + .getParameterTypes(); + + if (parameters.length == 1 && parameters[0] + .equals(World.class)) { + entityNew = (Entity) event + .getEntity() + .getClass() + .getConstructors()[i] + .newInstance(event + .getWorld()); + } + } + + } catch (Exception e) { + e.printStackTrace(); + } + + if (entityNew != null) { + entityNew.setLocationAndAngles( + event.getEntity().posX, + event.getEntity().posY, + event.getEntity().posZ, + event.getEntity().rotationYaw, + event.getEntity().rotationPitch); + + entityNew.getEntityData().setBoolean("isClone", + true); + + entityNew.dimension = event.getEntity().dimension; + + CommonTickHandler.addLater.add(entityNew); + } + } + + @SubscribeEvent + public void entityJoinWorld(EntityJoinWorldEvent event) { + if (!event.getWorld().isRemote) { + processEntity(event.getEntity(), ModjamMod.r); + + boolean isClone = isEntityClone(event); + + if (shouldCloneMob(event, isClone)) { + cloneMob(event); + } + + if (event.getEntity() instanceof EntityPlayer) { + addPlayerStats(event); + } + } + } + + private void handleBlessings(LivingDeathEvent event) { + String blessing = event.getSource().getTrueSource() + .getEntityData().getString("Blessing"); + + BlessingUtils.getBlessingInstance(blessing) + .onMobKill(event); + } + + private boolean isEntityClone(EntityJoinWorldEvent event) { + if (event.getEntity().getEntityData().hasKey("isClone")) { + return event.getEntity().getEntityData() + .getBoolean("isClone"); + } else { + return false; + } + } + + @SuppressWarnings("unchecked") + @SubscribeEvent + public void livingDeath(LivingDeathEvent event) { + if (!event.getEntity().world.isRemote) { + if (event.getEntity().world.getGameRules() + .getBoolean("doMobLoot")) { + + if (event.getEntity() instanceof EntityLivingBase + && event.getSource() != null + && event.getSource() + .getTrueSource() != null) { + if (BlessingUtils.hasBlessing(event + .getSource() + .getTrueSource())) { + handleBlessings(event); + } + } + + int level = 0; + + if (event.getEntity().getEntityData() + .hasKey("Level")) { + level = Integer.parseInt( + event.getEntity().getEntityData() + .getString("Level")); + } + + if (ModjamMod.r.nextInt(30) == 0 + || level == 5) { + event.getEntity().entityDropItem( + new ItemStack(ModjamMod.mysteryPotion, + 1, + ModjamMod.r.nextInt( + 13)), + event.getEntity().height + / 2); + } + } + + if (CommonTickHandler.worldData.currentTask + .equals("Kill") + && FyresWorldData.validMobs[CommonTickHandler.worldData.currentTaskID] + .isAssignableFrom( + event.getEntity().getClass())) { + advanceKillTaskProgress(event); + } + + if (!CommonTickHandler.worldData.enderDragonKilled + && event.getEntity() instanceof EntityDragon) { + CommonTickHandler.worldData.enderDragonKilled = true; + NewPacketHandler.UPDATE_WORLD_DATA + .sendToAllPlayers( + CommonTickHandler.worldData.potionValues, + CommonTickHandler.worldData.potionDurations, + CommonTickHandler.worldData + .getDisadvantage(), + CommonTickHandler.worldData.currentTask, + CommonTickHandler.worldData.currentTaskID, + CommonTickHandler.worldData.currentTaskAmount, + CommonTickHandler.worldData.progress, + CommonTickHandler.worldData.tasksCompleted, + CommonTickHandler.worldData.enderDragonKilled, + ModjamMod.spawnTraps, + CommonTickHandler.worldData.rewardLevels, + CommonTickHandler.worldData.mushroomColors); + CommonTickHandler.worldData.markDirty(); + } + } + + if (event.getEntity() instanceof EntityPlayer) { + EntityPlayer player = (EntityPlayer) event.getEntity(); + + //player.triggerAchievement(ModjamMod.losingIsFun); + + CommonTickHandler.worldData.blessingByPlayer.put( + player.getName(), + player.getEntityData().getString( + "Blessing")); + + CommonTickHandler.worldData.potionKnowledgeByPlayer + .put(player.getName(), + player.getEntityData() + .getIntArray("PotionKnowledge")); + + if (player.getEntityData() != null + && player.getEntityData().hasKey( + "KillStats")) { + CommonTickHandler.worldData.killStatsByPlayer + .put(player.getName(), + player.getEntityData() + .getCompoundTag("KillStats")); + } + + if (player.getEntityData() != null + && player.getEntityData().hasKey( + "WeaponStats")) { + CommonTickHandler.worldData.weaponStatsByPlayer + .put(player.getName(), + player.getEntityData() + .getCompoundTag("WeaponStats")); + } + + if (player.getEntityData() != null + && player.getEntityData().hasKey( + "CraftingStats")) { + CommonTickHandler.worldData.craftingStatsByPlayer + .put(player.getName(), + player.getEntityData() + .getCompoundTag("CraftingStats")); + } + } else if (event.getSource() != null + && event.getSource().getTrueSource() != null + && event.getSource().getTrueSource() instanceof EntityPlayer) { + EntityPlayer player = (EntityPlayer) event.getSource() + .getTrueSource(); + String mob = getUnalteredName(event.getEntity()); + + if (CommonTickHandler.worldData.getDisadvantage() + .equals("Trigger-happy") + && ModjamMod.r.nextInt(10) == 0) { + player.world.createExplosion(player, + event.getEntity().posX, + event.getEntity().posY, + event.getEntity().posZ, 1, + true); + } + + addOnKillStats(player, mob); + } + } + + public void register() { + MinecraftForge.EVENT_BUS.register(this); + } + + private boolean shouldCloneMob(EntityJoinWorldEvent event, + boolean isClone) { + return CommonTickHandler.worldData != null + && CommonTickHandler.worldData + .getDisadvantage() + .equals("Increased Mob Spawn") + && (event.getEntity() instanceof EntityMob) + && !(event.getEntity() instanceof EntityDragon) + && !isClone && ModjamMod.r.nextInt(3) == 0; + } +} diff --git a/src/main/java/fyresmodjam/misc/EntityStatTracker.java b/src/main/java/fyresmodjam/misc/EntityStatTracker.java new file mode 100644 index 0000000..f059141 --- /dev/null +++ b/src/main/java/fyresmodjam/misc/EntityStatTracker.java @@ -0,0 +1,29 @@ +package fyresmodjam.misc; + +import java.util.ArrayList; + +public class EntityStatTracker { + public Class[] classes; + + public boolean instanceAllowed = false; + + public EntityStatTracker(Class[] classes, + boolean instancesAllowed) { + this.classes = classes; + instanceAllowed = instancesAllowed; + } + + public EntityStatTracker(Class c, boolean instancesAllowed) { + this(new Class[] { + c + }, instancesAllowed); + } + + public ArrayList stats = new ArrayList(); + + public void addStat(EntityStat stat) { + if (!stats.contains(stat)) { + stats.add(stat); + } + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/misc/ItemStat.java b/src/main/java/fyresmodjam/misc/ItemStat.java new file mode 100644 index 0000000..888a34c --- /dev/null +++ b/src/main/java/fyresmodjam/misc/ItemStat.java @@ -0,0 +1,30 @@ +package fyresmodjam.misc; + +import java.util.Random; + +import net.minecraft.item.ItemStack; + +public class ItemStat { + public String name; + public String value; + + public ItemStat(String name, Object value) { + this.name = name; + this.value = value.toString(); + } + + public Object getNewValue(ItemStack stack, Random r) { + return value; + } + + public String getLore(ItemStack stack) { + return null; + } + + public String getAlteredStackName(ItemStack stack, Random r) { + return stack.getDisplayName(); + } + + public void modifyStack(ItemStack stack, Random r) { + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/misc/ItemStatHelper.java b/src/main/java/fyresmodjam/misc/ItemStatHelper.java new file mode 100644 index 0000000..9b32fd5 --- /dev/null +++ b/src/main/java/fyresmodjam/misc/ItemStatHelper.java @@ -0,0 +1,565 @@ +package fyresmodjam.misc; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Random; + +import fyresmodjam.ModjamMod; +import fyresmodjam.blessings.BlessingUtils; +import fyresmodjam.handlers.NewPacketHandler; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.monster.EntityMob; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.inventory.EntityEquipmentSlot; +import net.minecraft.item.ItemAxe; +import net.minecraft.item.ItemBow; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemSword; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.nbt.NBTTagString; +import net.minecraft.util.EnumHand; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.entity.living.LivingHurtEvent; +import net.minecraftforge.event.entity.player.PlayerDropsEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.PlayerEvent.ItemCraftedEvent; + +@SuppressWarnings("rawtypes") +public class ItemStatHelper { + public static HashMap> statTrackersByClass = new HashMap>(); + + public static ArrayList genericTrackers = new ArrayList(); + + public static ArrayList skip = new ArrayList(); + + public static void addStatTracker(ItemStatTracker statTracker) { + if (statTracker.classes != null) { + for (Class c : statTracker.classes) { + if (!statTrackersByClass.containsKey(c)) { + statTrackersByClass.put(c, + new ArrayList()); + } + + statTrackersByClass.get(c) + .add(statTracker); + } + } + + if (statTracker.instanceAllowed) { + genericTrackers.add(statTracker); + } + } + + public static ItemStack giveStat(ItemStack stack, String name, + Object value) { + if (!stack.hasTagCompound()) { + stack.setTagCompound(new NBTTagCompound()); + } + + NBTTagCompound data = stack.getTagCompound(); + data.setString(name, value.toString()); + return stack; + } + + public static ItemStack setName(ItemStack stack, String name) { + if (!stack.hasTagCompound()) { + stack.setTagCompound(new NBTTagCompound()); + } + + if (!stack.getTagCompound().hasKey("display")) { + stack.getTagCompound().setTag("display", + new NBTTagCompound()); + } + + stack.getTagCompound().getCompoundTag("display") + .setString("Name", name); + + return stack; + } + + public static ItemStack addLore(ItemStack stack, String lore) { + if (!stack.hasTagCompound()) { + stack.setTagCompound(new NBTTagCompound()); + } + + if (!stack.getTagCompound().hasKey("display")) { + stack.getTagCompound().setTag("display", + new NBTTagCompound()); + } + + if (!stack.getTagCompound().getCompoundTag("display") + .hasKey("Lore")) { + stack.getTagCompound().getCompoundTag("display") + .setTag("Lore", new NBTTagList()); + } + + if (lore != null) { + ((NBTTagList) stack.getTagCompound() + .getCompoundTag("display") + .getTag("Lore")).appendTag( + new NBTTagString( + lore)); + } + + return stack; + } + + public static String getName(ItemStack stack) { + if (stack.getTagCompound() != null + && stack.getTagCompound().hasKey("display") + && stack.getTagCompound() + .getCompoundTag("display") + .hasKey("Name")) { + return stack.getTagCompound() + .getCompoundTag("display") + .getString("Name"); + } + + return null; + } + + public static String getStat(ItemStack stack, String name) { + String s = null; + if (stack.getTagCompound() != null + && stack.getTagCompound().hasKey(name)) { + s = stack.getTagCompound().getString(name); + } + + return s; + } + + public static boolean hasStat(ItemStack stack, String name) { + if (stack.getTagCompound() != null + && stack.getTagCompound().hasKey(name)) { + return true; + } + + return false; + } + + @SubscribeEvent + public void playerDrops(PlayerDropsEvent event) { + if (!event.getEntity().world.isRemote) { + if (BlessingUtils.hasDisadvantage("Permadeath")) { + event.setCanceled(true); + } + } + } + + @SubscribeEvent + public void livingHurt(LivingHurtEvent event) { + if (!event.getEntity().world.isRemote) { + float damageMultiplier = 1.0F; + + try { + damageMultiplier = handlePlayerWeakening( + event, damageMultiplier); + } catch (NullPointerException npex) { + damageMultiplier = 1.0F; + } + + if (BlessingUtils.hasBlessing(event.getEntity())) { + damageMultiplier = BlessingUtils + .getBlessingInstance( + BlessingUtils.getBlessing( + event.getEntity())) + .onIncomingDamage(event, + damageMultiplier); + } + + if (event.isCanceled()) { + return; + } + + if (event.getEntity() instanceof EntityLivingBase) { + EntityLivingBase entity = (EntityLivingBase) event + .getEntity(); + + damageMultiplier = getArmorReduction( + damageMultiplier, entity); + } + + Entity trueSource = event.getSource() + .getTrueSource(); + + if (event.getSource() != null + && trueSource != null) { + if (trueSource instanceof EntityLivingBase) { + handleWeaponDamage(event); + } + + String mob = EntityStatHelper + .getUnalteredName(event + .getEntity()); + + if (ModjamMod.enableMobKillStats + && trueSource instanceof EntityPlayer + && trueSource.getEntityData() + .hasKey("KillStats") + && trueSource.getEntityData() + .getCompoundTag("KillStats") + .hasKey(mob)) { + damageMultiplier = handleMobKnowledgeBonus( + event, + damageMultiplier, + mob); + } + + String weapon = "misc"; + if (ModjamMod.enableWeaponKillStats + && trueSource instanceof EntityPlayer + && trueSource.getEntityData() + .hasKey("WeaponStats") + && trueSource.getEntityData() + .getCompoundTag("WeaponStats") + .hasKey(weapon)) { + damageMultiplier = handleWeaponKnowledgeBonus( + event, + damageMultiplier, + weapon); + } + + if (BlessingUtils + .hasBlessing(trueSource)) { + damageMultiplier = BlessingUtils + .getBlessingInstance( + BlessingUtils.getBlessing( + trueSource)) + .onOutgoingDamage( + event, + damageMultiplier); + } + } + + if (event.isCanceled()) { + return; + } + + if (event.getAmount() < event.getEntityLiving() + .getHealth()) { + event.setAmount((float) Math.max(0.5, event + .getAmount() + * damageMultiplier)); + } + } + } + + private float handleWeaponKnowledgeBonus(LivingHurtEvent event, + float damageMultiplier, String weapon) { + EntityPlayer player = (EntityPlayer) event.getSource() + .getTrueSource(); + + ItemStack heldItem = player + .getHeldItem(EnumHand.MAIN_HAND); + if (heldItem == null) { + weapon = "fist"; + } else if (heldItem.getItem() != null + && heldItem.getItem() instanceof ItemSword + || heldItem.getItem() instanceof ItemBow + || heldItem.getItem() instanceof ItemAxe) { + weapon = EntityStatHelper.getUnalteredItemName( + heldItem.getItem()); + } + + int kills = player.getEntityData() + .getCompoundTag("WeaponStats") + .getInteger(weapon); + + int last = 0; + for (int i = 0; i < EntityStatHelper.killCount.length; i++) { + if (kills >= EntityStatHelper.killCount[i] * 2) { + last = i; + continue; + } else { + break; + } + } + + float pickedDamageBonus = EntityStatHelper.damageBonus[last]; + + if (BlessingUtils.hasBlessing(player)) { + if (BlessingUtils.hasBlessing(player)) { + pickedDamageBonus = BlessingUtils + .getBlessingInstance( + player) + .adjustMobKnowledgeBonus( + event, + pickedDamageBonus); + } + } + + damageMultiplier += pickedDamageBonus; + return damageMultiplier; + } + + private float handleMobKnowledgeBonus(LivingHurtEvent event, + float damageMultiplier, String mob) { + Entity trueSource = event.getSource().getTrueSource(); + + int kills = trueSource.getEntityData() + .getCompoundTag("KillStats") + .getInteger(mob); + + int last = 0; + for (int i = 0; i < EntityStatHelper.killCount.length; i++) { + if (kills >= EntityStatHelper.killCount[i]) { + last = i; + continue; + } else { + break; + } + } + + float pickedDamageBonus = EntityStatHelper.damageBonus[last]; + + if (BlessingUtils.hasBlessing(trueSource)) { + if (BlessingUtils.hasBlessing(trueSource)) { + pickedDamageBonus = BlessingUtils + .getBlessingInstance( + trueSource) + .adjustMobKnowledgeBonus( + event, + pickedDamageBonus); + } + } + + damageMultiplier += pickedDamageBonus; + return damageMultiplier; + } + + private void handleWeaponDamage(LivingHurtEvent event) { + EntityLivingBase entity = (EntityLivingBase) event + .getSource().getTrueSource(); + + ItemStack held = entity.getHeldItemMainhand(); + + if (held != null && ((event.getSource().getDamageType() + .equals("player") + || event.getSource().getDamageType() + .equals("mob") + || (held.getItem() == Items.BOW && event + .getSource() + .isProjectile())))) { + String s = getStat(held, "BonusDamage"); + if (s != null) { + event.setAmount(event.getAmount() + + Float.parseFloat(s.trim() + .replace(",", "."))); + } + } + } + + private float getArmorReduction(float damageMultiplier, + EntityLivingBase entity) { + EntityEquipmentSlot slots[] = new EntityEquipmentSlot[] { + EntityEquipmentSlot.CHEST, + EntityEquipmentSlot.FEET, + EntityEquipmentSlot.HEAD, + EntityEquipmentSlot.LEGS + }; + + for (EntityEquipmentSlot slot : slots) { + ItemStack stack = entity + .getItemStackFromSlot(slot); + if (stack == null || stack.getTagCompound() == null + || !stack.getTagCompound().hasKey( + "DamageReduction")) { + continue; + } + + damageMultiplier -= Float.parseFloat(stack + .getTagCompound() + .getString("DamageReduction") + .trim().replace(",", ".")) * 0.01F; + } + return damageMultiplier; + } + + private float handlePlayerWeakening(LivingHurtEvent event, + float damageMultiplier) { + if (BlessingUtils.hasDisadvantage("Weak")) { + if (event.getSource().getDamageType() + .equals("player")) { + damageMultiplier -= 0.25F; + } + } else if (BlessingUtils.hasDisadvantage("Tougher Mobs")) { + if (event.getEntity() instanceof EntityMob) { + damageMultiplier -= 0.25F; + } + } + return damageMultiplier; + } + + public static ArrayList temp = new ArrayList(); + + @SuppressWarnings("unchecked") + public static void processItemStack(ItemStack stack, Random r) { + if (stack == null) { + return; + } + + temp.clear(); + + Class itemClass = stack.getItem().getClass(); + + if (statTrackersByClass.containsKey(itemClass)) { + temp.addAll(statTrackersByClass.get(itemClass)); + } + + for (ItemStatTracker e : genericTrackers) { + if (!temp.contains(e)) { + for (Class c : e.classes) { + if (c.isAssignableFrom( + itemClass)) { + ArrayList list = null; + + if (statTrackersByClass + .containsKey(itemClass)) { + list = new ArrayList(); + statTrackersByClass + .put(itemClass, list); + } else { + list = statTrackersByClass + .get(itemClass); + } + + try { + if (!statTrackersByClass + .get(itemClass) + .contains(e)) { + list.add(e); + } + + temp.add(e); + + break; + } catch (NullPointerException npex) { + + } + } + } + } + } + + if (!temp.isEmpty()) { + if (!stack.hasTagCompound()) { + stack.setTagCompound(new NBTTagCompound()); + } + + String processed = ItemStatHelper.getStat(stack, + "processed"); + + if (processed == null + || processed.equals("false")) { + stack.getTagCompound().setTag("Lore", + new NBTTagList()); + + ItemStatHelper.giveStat(stack, "processed", + "true"); + + for (ItemStatTracker statTracker : temp) { + for (ItemStat s : statTracker.stats) { + giveStat(stack, s.name, s + .getNewValue(stack, + r) + .toString()); + + String lore = s.getLore( + stack); + if (lore != null) { + addLore(stack, lore); + } + + setName(stack, s.getAlteredStackName( + stack, r)); + + s.modifyStack(stack, r); + } + } + } + } else { + skip.add(itemClass); + } + } + + @SubscribeEvent + public void onCrafting(ItemCraftedEvent event) { + + EntityPlayer player = event.player; + ItemStack item = event.crafting; + + if (!player.world.isRemote) { + String itemName = null; + + if (item.getItem() != null && item + .getItem() instanceof ItemSword + || item.getItem() instanceof ItemBow + || item.getItem() instanceof ItemAxe) { + itemName = EntityStatHelper + .getUnalteredItemName(item + .getItem()); + } + + if (ModjamMod.enableCraftingStats + && itemName != null) { + if (!player.getEntityData() + .hasKey("CraftingStats")) { + player.getEntityData().setTag( + "CraftingStats", + new NBTTagCompound()); + } + NBTTagCompound craftingStats = player + .getEntityData() + .getCompoundTag("CraftingStats"); + + if (!craftingStats.hasKey(itemName)) { + craftingStats.setInteger(itemName, + 0); + + if (!craftingStats.hasKey( + "TrackedItemList")) { + craftingStats.setString( + "TrackedItemList", + itemName); + } else { + craftingStats.setString( + "TrackedItemList", + craftingStats.getString( + "TrackedItemList") + + ";" + + itemName); + } + } + + craftingStats.setInteger(itemName, + craftingStats.getInteger( + itemName) + + 1); + + for (int i = 0; i < EntityStatHelper.knowledge.length; i++) { + if (EntityStatHelper.killCount[i] == craftingStats + .getInteger(itemName)) { + NewPacketHandler.SEND_MESSAGE + .sendToPlayer(player, + "\u00A7o\u00A73You've become a " + + EntityStatHelper.knowledge[i] + .toLowerCase() + + " " + + itemName.toLowerCase() + + " smith! (" + + (i < EntityStatHelper.knowledge.length + - 1 ? (EntityStatHelper.killCount[i + 1] * 2 - EntityStatHelper.killCount[i] * 2) + " " + itemName.toLowerCase() + " crafts to next rank." : "")); + break; + } + } + } + } + } + + public void register() { + MinecraftForge.EVENT_BUS.register(this); + } +} diff --git a/src/main/java/fyresmodjam/misc/ItemStatTracker.java b/src/main/java/fyresmodjam/misc/ItemStatTracker.java new file mode 100644 index 0000000..743f853 --- /dev/null +++ b/src/main/java/fyresmodjam/misc/ItemStatTracker.java @@ -0,0 +1,29 @@ +package fyresmodjam.misc; + +import java.util.ArrayList; + +public class ItemStatTracker { + public Class[] classes; + + public boolean instanceAllowed = false; + + public ItemStatTracker(Class[] classes, + boolean instanceAllowed) { + this.classes = classes; + this.instanceAllowed = instanceAllowed; + } + + public ItemStatTracker(Class c, boolean instanceAllowed) { + this(new Class[] { + c + }, instanceAllowed); + } + + public ArrayList stats = new ArrayList(); + + public void addStat(ItemStat stat) { + if (!stats.contains(stat)) { + stats.add(stat); + } + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/misc/WeaponRankStat.java b/src/main/java/fyresmodjam/misc/WeaponRankStat.java new file mode 100644 index 0000000..e844dc2 --- /dev/null +++ b/src/main/java/fyresmodjam/misc/WeaponRankStat.java @@ -0,0 +1,83 @@ +package fyresmodjam.misc; + +import java.util.Random; + +import fyresmodjam.ModjamMod; +import net.minecraft.item.ItemBow; +import net.minecraft.item.ItemStack; + +public final class WeaponRankStat extends ItemStat { + /* + * @formatter:off + */ + public String[][] prefixesByRank = { + { + "Old", "Dull", "Broken", "Worn" + }, + { + "Average", "Decent", "Modest", "Ordinary" + }, + { + "Strong", "Sharp", "Polished", "Refined" + }, + { + "Powerful", "Ruthless", "Elite", "Astonishing" + }, + { + "Godly", "Divine", "Fabled", "Legendary" + } + }; + /* + * @formatter:on + */ + public WeaponRankStat(String name, Object value) { + super(name, value); + } + + @Override + public Object getNewValue(ItemStack stack, Random r) { + int i = 1; + for (; i < 5; i++) { + if (ModjamMod.r.nextInt(10) < 7) { + break; + } + } + return i; + } + + @Override + public void modifyStack(ItemStack stack, Random r) { + int rank = Integer.parseInt( + stack.getTagCompound().getString(name)); + float bonusDamage = ((float) rank - 1) / 2 + + (r.nextInt(rank + 1) * r.nextFloat()); + + ItemStatHelper.giveStat(stack, "BonusDamage", + String.format("%.2f", bonusDamage)); + ItemStatHelper.addLore(stack, !String.format("%.2f", + bonusDamage) + .equals("0.00") ? "\u00A77\u00A7o " + + (bonusDamage > 0 ? "+" + : "") + + String.format("%.2f", + bonusDamage) + + " bonus damage" : null); + + ItemStatHelper.addLore(stack, "\u00A7eRank: " + rank); + } + + @Override + public String getAlteredStackName(ItemStack stack, Random r) { + String[] list = prefixesByRank[Integer.parseInt( + stack.getTagCompound().getString(name)) + - 1]; + String prefix = list[r.nextInt(list.length)]; + + if (prefix.equals("Sharp") + && stack.getItem() instanceof ItemBow) { + prefix = "Long"; + } + + return "\u00A7f" + prefix + " " + stack.getDisplayName(); + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/worldgen/FyresWorldData.java b/src/main/java/fyresmodjam/worldgen/FyresWorldData.java new file mode 100644 index 0000000..caf0b1f --- /dev/null +++ b/src/main/java/fyresmodjam/worldgen/FyresWorldData.java @@ -0,0 +1,480 @@ +package fyresmodjam.worldgen; + +import java.awt.Color; +import java.util.HashMap; + +import fyresmodjam.ModjamMod; +import net.minecraft.entity.boss.EntityDragon; +import net.minecraft.entity.boss.EntityWither; +import net.minecraft.entity.monster.EntityGhast; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.potion.Potion; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.ResourceLocation; +import net.minecraft.world.World; +import net.minecraft.world.storage.MapStorage; +import net.minecraft.world.storage.WorldSavedData; +import net.minecraftforge.fml.common.FMLCommonHandler; + +public class FyresWorldData extends WorldSavedData { + + /* + * @formatter:off + */ + public static String[] validDisadvantages = { + "Tougher Mobs", + "Weak", + "Explosive Traps", + "Increased Mob Spawn", + "Neverending Rain", + "Neverending Night", + "Permadeath", + "Trigger-happy", + "Diabolic", + "Organized Foes" + }; + + public static String[] disadvantageDescriptions = { + "Hostile enemies takes 25% less damage", + "-25% melee damage", + "Traps also trigger explosions when set off", + "+33% hostile mob spawn rate", + "Constantly rains", + "Constant night", + "Items dropped upon death are permanently lost", + "Mobs have a chance to explode on death", + "All mobs have a chance to recieve a random blessing", + "Mobs spawn with armor and weapons, increasing with level" + }; + + public static String[] validTasks = { + "Kill", + "Burn" + }; + + /* + * @formatter:on + */ + + public static String key = "FyresWorldData"; + + public int[] potionValues = null; + public int[] potionDurations = null; + + public int[][] mushroomColors = null; + + public String currentDisadvantage = null; + + public String currentTask = null; + public int currentTaskID = -1; + public int currentTaskAmount = 0; + public int progress = 0; + public int tasksCompleted = 0; + public int rewardLevels = -1; + + public boolean enderDragonKilled = false; + + // TODO pull these into a class instead of using parallel arrays + @SuppressWarnings("rawtypes") + public static Class[] validMobs = { + EntityDragon.class, EntityGhast.class, + EntityWither.class + }; + public static String[] validMobNames = { + "Ender Dragon", "Ghast", "Wither" + }; + public static int[][] mobNumbers = { + new int[] { + 1, 1 + }, new int[] { + 5, 15 + }, new int[] { + 1, 1 + } + }; + + public HashMap blessingByPlayer = new HashMap(); + public HashMap potionKnowledgeByPlayer = new HashMap(); + + public HashMap killStatsByPlayer = new HashMap(); + public HashMap weaponStatsByPlayer = new HashMap(); + public HashMap craftingStatsByPlayer = new HashMap(); + + public static ItemStack[] validItems = { + new ItemStack(Blocks.DIAMOND_BLOCK), + new ItemStack(Blocks.GOLD_BLOCK), + new ItemStack(Blocks.EMERALD_BLOCK), + new ItemStack(Blocks.LAPIS_BLOCK), + new ItemStack(Items.DIAMOND), + new ItemStack(Items.EMERALD), + new ItemStack(Items.GOLD_INGOT), + new ItemStack(Items.NETHER_STAR), + new ItemStack(Items.GHAST_TEAR) + }; + + public FyresWorldData() { + super(key); + } + + public FyresWorldData(String key) { + super(key); + } + + public static FyresWorldData forWorld(World world) { + + MapStorage storage = world.getPerWorldStorage(); + FyresWorldData result = (FyresWorldData) storage + .getOrLoadData(FyresWorldData.class, key); + + if (result == null) { + result = new FyresWorldData(); + storage.setData(key, result); + result.checkWorldData(); + } + + return result; + } + + @Override + public void readFromNBT(NBTTagCompound nbttagcompound) { + if (nbttagcompound.hasKey("values")) { + potionValues = nbttagcompound + .getIntArray("values"); + } + if (nbttagcompound.hasKey("durations")) { + potionDurations = nbttagcompound + .getIntArray("durations"); + } + if (nbttagcompound.hasKey("currentDisadvantage")) { + currentDisadvantage = nbttagcompound + .getString("currentDisadvantage"); + } + + if (nbttagcompound.hasKey("currentTask")) { + currentTask = nbttagcompound + .getString("currentTask"); + } + if (nbttagcompound.hasKey("currentTaskID")) { + currentTaskID = nbttagcompound + .getInteger("currentTaskID"); + } + if (nbttagcompound.hasKey("currentTaskAmount")) { + currentTaskAmount = nbttagcompound + .getInteger("currentTaskAmount"); + } + if (nbttagcompound.hasKey("progress")) { + progress = nbttagcompound.getInteger("progress"); + } + if (nbttagcompound.hasKey("tasksCompleted")) { + tasksCompleted = nbttagcompound + .getInteger("tasksCompleted"); + } + + if (nbttagcompound.hasKey("enderDragonKilled")) { + enderDragonKilled = nbttagcompound + .getBoolean("enderDragonKilled"); + } + + if (nbttagcompound.hasKey("rewardLevels")) { + rewardLevels = nbttagcompound + .getInteger("rewardLevels"); + } + + mushroomColors = new int[13][]; + for (int i = 0; i < 13; i++) { + if (nbttagcompound.hasKey( + "mushroomColors_" + (i + 1))) { + mushroomColors[i] = nbttagcompound + .getIntArray("mushroomColors_" + + (i + 1)); + } + } + + if (nbttagcompound.hasKey("TempPlayerStats")) { + NBTTagCompound tempStats = nbttagcompound + .getCompoundTag("TempPlayerStats"); + + // TODO is this what we should be doing? + for (String key : tempStats.getKeySet()) { + if (key == null || !(tempStats.getTag(key) instanceof NBTTagCompound)) { + continue; + } + NBTTagCompound player = (NBTTagCompound) tempStats.getTag(key); + + blessingByPlayer.put( + player.getString("Name"), + player.getString( + "Blessing")); + potionKnowledgeByPlayer.put( + player.getString("Name"), + player.getIntArray( + "PotionKnowledge")); + if (player.hasKey("KillStats")) { + killStatsByPlayer.put(player + .getString("Name"), + player.getCompoundTag( + "KillStats")); + } + if (player.hasKey("WeaponStats")) { + weaponStatsByPlayer.put(player + .getString("Name"), + player.getCompoundTag( + "WeaponStats")); + } + if (player.hasKey("CraftingStats")) { + craftingStatsByPlayer.put(player + .getString("Name"), + player.getCompoundTag( + "CraftingStats")); + } + } + } + + checkWorldData(); + } + + @Override + public NBTTagCompound writeToNBT(NBTTagCompound nbttagcompound) { + checkWorldData(); + + nbttagcompound.setIntArray("values", potionValues); + nbttagcompound.setIntArray("durations", potionDurations); + nbttagcompound.setString("currentDisadvantage", + currentDisadvantage); + + nbttagcompound.setString("currentTask", currentTask); + nbttagcompound.setInteger("currentTaskID", currentTaskID); + nbttagcompound.setInteger("currentTaskAmount", + currentTaskAmount); + nbttagcompound.setInteger("progress", progress); + nbttagcompound.setInteger("tasksCompleted", + tasksCompleted); + + nbttagcompound.setBoolean("enderDragonKilled", + enderDragonKilled); + + nbttagcompound.setInteger("rewardLevels", rewardLevels); + + for (int i = 0; i < 13; i++) { + nbttagcompound.setIntArray( + "mushroomColors_" + (i + 1), + mushroomColors[i]); + } + + if (!blessingByPlayer.isEmpty()) { + NBTTagCompound tempPlayerStats = new NBTTagCompound(); + + for (String s : blessingByPlayer.keySet()) { + if (s == null) { + continue; + } + + NBTTagCompound player = new NBTTagCompound(); + + player.setString("Name", s); + player.setString("Blessing", + blessingByPlayer.get(s)); + player.setIntArray("PotionKnowledge", + potionKnowledgeByPlayer + .get(s)); + if (killStatsByPlayer.containsKey(s)) { + player.setTag("KillStats", + killStatsByPlayer + .get(s)); + } + if (weaponStatsByPlayer.containsKey(s)) { + player.setTag("WeaponStats", + weaponStatsByPlayer + .get(s)); + } + if (craftingStatsByPlayer.containsKey(s)) { + player.setTag("CraftingStats", + craftingStatsByPlayer + .get(s)); + } + + tempPlayerStats.setTag(s, player); + } + + nbttagcompound.setTag("TempPlayerStats", + tempPlayerStats); + } + + return nbttagcompound; + } + + private void checkWorldData() { + if (potionValues == null) { + // TODO fix this + potionValues = new int[] { + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 + }; + /* + * for (int i = 0; i < 12; i++) { int randPotionID + * = ModjamMod.r.nextInt( + * Potion.REGISTRY.getKeys().size()); + * + * boolean stop = false; for(ResourceLocation rloc + * : Potion.REGISTRY.getKeys()) { Potion pot = + * Potion.REGISTRY.getObject(rloc); + * + * if(pot == null) continue; + * + * stop = true; randPotionID = ModjamMod.r.nextInt( + * Potion.REGISTRY.getKeys().size()); + * + * for (int i3 = 0; i3 < 12; i3++) { if + * (potionValues[i3] == randPotionID) { stop = + * false; break; } } } + * + * potionValues[i] = randPotionID; } + */ + } else { + /* + * for (int i = 0; i < 12; i++) { if + * (Potion.potionTypes[potionValues[i]] == null) { + * int randPotionID = ModjamMod.r + * .nextInt(Potion.potionTypes.length); + * + * while (Potion.potionTypes[randPotionID] == null) + * { randPotionID = ModjamMod.r + * .nextInt(Potion.potionTypes.length); } + * + * potionValues[i] = randPotionID; } } + */ + } + + if (potionDurations == null) { + potionDurations = new int[12]; + } + + for (int i = 0; i < 12; i++) { + if (potionDurations[i] != 0) { + continue; + } + potionDurations[i] = 5 + ModjamMod.r.nextInt(26); + } + + if (mushroomColors == null) { + mushroomColors = new int[13][2]; + + for (int i = 0; i < 13; i++) { + mushroomColors[i][0] = Color.HSBtoRGB( + ModjamMod.r.nextFloat(), + ModjamMod.r.nextFloat(), + ModjamMod.r.nextFloat()); + mushroomColors[i][1] = Color.HSBtoRGB( + ModjamMod.r.nextFloat(), + ModjamMod.r.nextFloat(), + ModjamMod.r.nextFloat()); + } + } + + boolean changeDisadvantage = true; + + if (currentDisadvantage != null) { + boolean valid = false; + + for (String s : validDisadvantages) { + if (s.equals(currentDisadvantage)) { + valid = true; + break; + } + } + + changeDisadvantage = !valid && !currentDisadvantage + .equals("None"); + } + + if (changeDisadvantage) { + currentDisadvantage = validDisadvantages[ModjamMod.r + .nextInt(validDisadvantages.length)]; + + MinecraftServer server = FMLCommonHandler + .instance() + .getMinecraftServerInstance(); + + while (server != null && server.isHardcore() + && currentDisadvantage.equals( + "Permadeath")) { + currentDisadvantage = validDisadvantages[ModjamMod.r + .nextInt(validDisadvantages.length)]; + } + } + + if (currentTask == null) { + giveNewTask(); + } else { + boolean changeTask = true; + + for (String s : validTasks) { + if (s.equals(currentTask)) { + changeTask = false; + break; + } + } + + if (changeTask || (currentTask != null + && currentTask.equals("Kill") + && currentTaskID == 0 + && enderDragonKilled)) { + giveNewTask(); + } else { + if (currentTask.equals("Kill")) { + currentTaskID %= validMobs.length; + } + } + } + + if (rewardLevels == -1) { + rewardLevels = 5 + ModjamMod.r.nextInt(6); + } + } + + public void giveNewTask() { + progress = 0; + + currentTask = validTasks[ModjamMod.r + .nextInt(validTasks.length)]; + + if (currentTask.equals("Kill")) { + currentTaskID = !enderDragonKilled + ? ModjamMod.r.nextInt( + validMobs.length) + : 1 + ModjamMod.r.nextInt( + validMobs.length - 1); + currentTaskAmount = mobNumbers[currentTaskID][0] + + ModjamMod.r.nextInt( + mobNumbers[currentTaskID][1]); + } else if (currentTask.equals("Burn")) { + currentTaskID = ModjamMod.r + .nextInt(validItems.length); + + if (validItems[currentTaskID] + .getItem() == Items.NETHER_STAR) { + currentTaskAmount = 1; + } else { + currentTaskAmount = 5 + + ModjamMod.r.nextInt(28); + } + + if (validItems[currentTaskID] + .getItem() instanceof ItemBlock) { + currentTaskAmount /= 4; + } + } + + rewardLevels = 5 + ModjamMod.r.nextInt(6); + + markDirty(); + } + + public String getDisadvantage() { + return ModjamMod.disableDisadvantages ? "None" + : currentDisadvantage; + } +} diff --git a/src/main/resources/assets/fyresmodjam/advancements/startTheGame.json b/src/main/resources/assets/fyresmodjam/advancements/startTheGame.json new file mode 100644 index 0000000..7a73a41 --- /dev/null +++ b/src/main/resources/assets/fyresmodjam/advancements/startTheGame.json @@ -0,0 +1,2 @@ +{ +} \ No newline at end of file diff --git a/src/main/resources/assets/fyresmodjam/lang/en_US.lang b/src/main/resources/assets/fyresmodjam/lang/en_US.lang new file mode 100644 index 0000000..a8631dc --- /dev/null +++ b/src/main/resources/assets/fyresmodjam/lang/en_US.lang @@ -0,0 +1,19 @@ +item.blockPillar.name=Pillar +item.mysteryPotion.name=Mystery Potion +item.itemTrap.name=Trap +item.mysteryMushroom.name=Mystery Mushroom +item.sceptre.name=Obsidian Sceptre +tile.blockPillar.name=Pillar Block +tile.blockTrap.name=Trap +tile.mysteryMushroomBlock.name=Mystery Mushroom +entity.MysteryPotion.name=Mystery Potion +commands.currentBlessing.usage=/currentBlessing - used to check your current blessing +commands.currentDisadvantage.usage=/currentDisadvantage - used to check your current world disadvantage +commands.currentGoal.usage=/currentGoal - used to check your current world goal +commands.creatureKnowledge.usage=/creatureKnowledge [page] - used to check your current creature knowledge stats +commands.weaponKnowledge.usage=/weaponKnowledge [page] - used to check your current weapon knowledge stats +commands.craftingKnowledge.usage=/craftingKnowledge [page] - used to check your current crafting knowledge stats +fyresmodjam.newVersion=\u00A7bA newer version of the "You Will Die" Mod has been found + +death.attack.inferno=%s had their fire doused +death.attack.retaliation=%s was killed for their crimes \ No newline at end of file diff --git a/src/main/resources/assets/fyresmodjam/sounds.json b/src/main/resources/assets/fyresmodjam/sounds.json new file mode 100644 index 0000000..348c793 --- /dev/null +++ b/src/main/resources/assets/fyresmodjam/sounds.json @@ -0,0 +1,3 @@ +{ + "pillarActivated": {"catagory":"master","sounds":[{"name":"pillarActivated","stream":"false"}]} +} \ No newline at end of file diff --git a/src/main/resources/assets/fyresmodjam/sounds/pillarActivated.ogg b/src/main/resources/assets/fyresmodjam/sounds/pillarActivated.ogg new file mode 100644 index 0000000..a6038eb Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/sounds/pillarActivated.ogg differ diff --git a/src/main/resources/assets/fyresmodjam/textures/blocks/crystal.png b/src/main/resources/assets/fyresmodjam/textures/blocks/crystal.png new file mode 100644 index 0000000..6034731 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/blocks/crystal.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/blocks/crystal_stand.png b/src/main/resources/assets/fyresmodjam/textures/blocks/crystal_stand.png new file mode 100644 index 0000000..c464d7a Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/blocks/crystal_stand.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/blocks/mushroomBlock.png b/src/main/resources/assets/fyresmodjam/textures/blocks/mushroomBlock.png new file mode 100644 index 0000000..6db8147 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/blocks/mushroomBlock.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/blocks/mushroomBlock_overlay.png b/src/main/resources/assets/fyresmodjam/textures/blocks/mushroomBlock_overlay.png new file mode 100644 index 0000000..d20bca4 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/blocks/mushroomBlock_overlay.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/blocks/pillar.png b/src/main/resources/assets/fyresmodjam/textures/blocks/pillar.png new file mode 100644 index 0000000..1a8fdba Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/blocks/pillar.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/blocks/pillarActive.png b/src/main/resources/assets/fyresmodjam/textures/blocks/pillarActive.png new file mode 100644 index 0000000..d8b817e Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/blocks/pillarActive.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/blocks/spikes.png b/src/main/resources/assets/fyresmodjam/textures/blocks/spikes.png new file mode 100644 index 0000000..d7df5d1 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/blocks/spikes.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/blocks/spikes2.png b/src/main/resources/assets/fyresmodjam/textures/blocks/spikes2.png new file mode 100644 index 0000000..b1f0d9f Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/blocks/spikes2.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/blocks/trap2.png b/src/main/resources/assets/fyresmodjam/textures/blocks/trap2.png new file mode 100644 index 0000000..8002852 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/blocks/trap2.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/blocks/trap3.png b/src/main/resources/assets/fyresmodjam/textures/blocks/trap3.png new file mode 100644 index 0000000..0998474 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/blocks/trap3.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/basic_staff.png b/src/main/resources/assets/fyresmodjam/textures/items/basic_staff.png new file mode 100644 index 0000000..361d91a Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/basic_staff.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/crystal_item.png b/src/main/resources/assets/fyresmodjam/textures/items/crystal_item.png new file mode 100644 index 0000000..b30a61b Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/crystal_item.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/crystal_stand_item.png b/src/main/resources/assets/fyresmodjam/textures/items/crystal_stand_item.png new file mode 100644 index 0000000..643d50b Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/crystal_stand_item.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/enchantedSceptre.png b/src/main/resources/assets/fyresmodjam/textures/items/enchantedSceptre.png new file mode 100644 index 0000000..43a63ac Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/enchantedSceptre.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/fire_amulet.png b/src/main/resources/assets/fyresmodjam/textures/items/fire_amulet.png new file mode 100644 index 0000000..9272fa6 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/fire_amulet.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/fire_amulet_overlay.png b/src/main/resources/assets/fyresmodjam/textures/items/fire_amulet_overlay.png new file mode 100644 index 0000000..91f3f3b Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/fire_amulet_overlay.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/itemPillar.png b/src/main/resources/assets/fyresmodjam/textures/items/itemPillar.png new file mode 100644 index 0000000..48627e6 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/itemPillar.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/itemTrap.png b/src/main/resources/assets/fyresmodjam/textures/items/itemTrap.png new file mode 100644 index 0000000..b1f0d9f Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/itemTrap.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mushroom.png b/src/main/resources/assets/fyresmodjam/textures/items/mushroom.png new file mode 100644 index 0000000..08381ef Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mushroom.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mushroom_overlay.png b/src/main/resources/assets/fyresmodjam/textures/items/mushroom_overlay.png new file mode 100644 index 0000000..26469b4 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mushroom_overlay.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_1.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_1.png new file mode 100644 index 0000000..7bc50cd Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_1.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_10.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_10.png new file mode 100644 index 0000000..1b51022 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_10.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_11.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_11.png new file mode 100644 index 0000000..055bf3b Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_11.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_12.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_12.png new file mode 100644 index 0000000..de3fe68 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_12.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_13.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_13.png new file mode 100644 index 0000000..75b7d7c Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_13.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_2.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_2.png new file mode 100644 index 0000000..e721123 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_2.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_3.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_3.png new file mode 100644 index 0000000..921351e Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_3.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_4.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_4.png new file mode 100644 index 0000000..b93bfb9 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_4.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_5.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_5.png new file mode 100644 index 0000000..a88d5d4 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_5.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_6.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_6.png new file mode 100644 index 0000000..ed9ff17 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_6.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_7.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_7.png new file mode 100644 index 0000000..31d6c00 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_7.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_8.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_8.png new file mode 100644 index 0000000..184cb72 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_8.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_9.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_9.png new file mode 100644 index 0000000..a950ceb Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotionThrowable_9.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_1.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_1.png new file mode 100644 index 0000000..2f99a45 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_1.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_10.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_10.png new file mode 100644 index 0000000..8fa7609 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_10.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_11.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_11.png new file mode 100644 index 0000000..70df62d Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_11.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_12.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_12.png new file mode 100644 index 0000000..5183149 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_12.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_13.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_13.png new file mode 100644 index 0000000..995fe1e Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_13.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_2.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_2.png new file mode 100644 index 0000000..4bb169a Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_2.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_3.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_3.png new file mode 100644 index 0000000..b46938f Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_3.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_4.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_4.png new file mode 100644 index 0000000..fbcf06a Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_4.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_5.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_5.png new file mode 100644 index 0000000..b2c10b7 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_5.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_6.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_6.png new file mode 100644 index 0000000..3852de3 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_6.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_7.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_7.png new file mode 100644 index 0000000..e75fe03 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_7.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_8.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_8.png new file mode 100644 index 0000000..ff7b53a Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_8.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_9.png b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_9.png new file mode 100644 index 0000000..a575a3d Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/mysteryPotion_9.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/sceptre.png b/src/main/resources/assets/fyresmodjam/textures/items/sceptre.png new file mode 100644 index 0000000..cce2265 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/sceptre.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/scroll.png b/src/main/resources/assets/fyresmodjam/textures/items/scroll.png new file mode 100644 index 0000000..82c7c77 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/scroll.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/star_amulet.png b/src/main/resources/assets/fyresmodjam/textures/items/star_amulet.png new file mode 100644 index 0000000..b5d0d03 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/star_amulet.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/star_amulet_overlay.png b/src/main/resources/assets/fyresmodjam/textures/items/star_amulet_overlay.png new file mode 100644 index 0000000..777eb07 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/star_amulet_overlay.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/trap2.png b/src/main/resources/assets/fyresmodjam/textures/items/trap2.png new file mode 100644 index 0000000..c4bc279 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/trap2.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/trap3.png b/src/main/resources/assets/fyresmodjam/textures/items/trap3.png new file mode 100644 index 0000000..2a75ef3 Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/trap3.png differ diff --git a/src/main/resources/assets/fyresmodjam/textures/items/unenchantedSceptre.png b/src/main/resources/assets/fyresmodjam/textures/items/unenchantedSceptre.png new file mode 100644 index 0000000..71b4f8a Binary files /dev/null and b/src/main/resources/assets/fyresmodjam/textures/items/unenchantedSceptre.png differ diff --git a/src/main/resources/mcmod.info b/src/main/resources/mcmod.info new file mode 100644 index 0000000..838359f --- /dev/null +++ b/src/main/resources/mcmod.info @@ -0,0 +1,16 @@ +[ +{ + "modid": "fyresmodjam", + "name": "The You Will Die Mod", + "description": "The You Will Die Mod by xFyreStorm.", + "version": "v0.0.3e", + "mcversion": "1.7.2", + "url": "", + "updateUrl": "", + "authors": ["xFyreStorm"], + "credits": "xFyreStorm - All", + "logoFile": "", + "screenshots": [], + "dependencies": [] +} +] diff --git a/src/main/resources/pack.mcmeta b/src/main/resources/pack.mcmeta new file mode 100644 index 0000000..4018267 --- /dev/null +++ b/src/main/resources/pack.mcmeta @@ -0,0 +1,7 @@ +{ + "pack": { + "description": "examplemod resources", + "pack_format": 3, + "_comment": "A pack_format of 3 should be used starting with Minecraft 1.11. All resources, including language files, should be lowercase (eg: en_us.lang). A pack_format of 2 will load your mod resources with LegacyV2Adapter, which requires language files to have uppercase letters (eg: en_US.lang)." + } +} -- cgit v1.2.3