From 3eb8c7a8fca3f22475d53e30f0b90a6737f313fa Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Thu, 24 May 2018 15:53:20 -0400 Subject: Initial commit --- .../main/java/fyresmodjam/blessings/Blessing.java | 143 ++++++++++++++ .../java/fyresmodjam/blessings/BlessingType.java | 30 +++ .../java/fyresmodjam/blessings/BlessingUtils.java | 216 +++++++++++++++++++++ .../blessings/marks/ArcaneNullityMark.java | 39 ++++ .../blessings/marks/BerserkingMark.java | 31 +++ .../fyresmodjam/blessings/marks/FalseLifeMark.java | 59 ++++++ .../fyresmodjam/blessings/marks/GuardingMark.java | 31 +++ .../fyresmodjam/blessings/marks/HolyLightMark.java | 35 ++++ .../fyresmodjam/blessings/marks/HuntingMark.java | 40 ++++ .../java/fyresmodjam/blessings/marks/Mark.java | 28 +++ .../blessings/marks/RetaliationMark.java | 53 +++++ .../fyresmodjam/blessings/marks/ScoutingMark.java | 17 ++ .../fyresmodjam/blessings/marks/VampirismMark.java | 75 +++++++ .../java/fyresmodjam/blessings/marks/WarMark.java | 31 +++ .../blessings/standard/AlchemistBlessing.java | 19 ++ .../blessings/standard/BerserkerBlessing.java | 46 +++++ .../blessings/standard/DiverBlessing.java | 21 ++ .../blessings/standard/GuardianBlessing.java | 26 +++ .../blessings/standard/HunterBlessing.java | 35 ++++ .../blessings/standard/InfernoBlessing.java | 61 ++++++ .../blessings/standard/LonerBlessing.java | 32 +++ .../blessings/standard/LooterBlessing.java | 29 +++ .../blessings/standard/LumberjackBlessing.java | 54 ++++++ .../blessings/standard/MechanicBlessing.java | 20 ++ .../blessings/standard/MinerBlessing.java | 55 ++++++ .../blessings/standard/NinjaBlessing.java | 49 +++++ .../blessings/standard/PaladinBlessing.java | 25 +++ .../blessings/standard/ParatrooperBlessing.java | 27 +++ .../blessings/standard/PorcupineBlessing.java | 43 ++++ .../blessings/standard/ScholarBlessing.java | 27 +++ .../blessings/standard/StandardBlessing.java | 19 ++ .../blessings/standard/SwampBlessing.java | 30 +++ .../blessings/standard/ThickSkinnedBlessing.java | 22 +++ .../blessings/standard/ThiefBlessing.java | 26 +++ .../blessings/standard/VampireBlessing.java | 27 +++ .../blessings/standard/WarriorBlessing.java | 36 ++++ 36 files changed, 1557 insertions(+) create mode 100644 YWD/src/main/java/fyresmodjam/blessings/Blessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/BlessingType.java create mode 100755 YWD/src/main/java/fyresmodjam/blessings/BlessingUtils.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/marks/ArcaneNullityMark.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/marks/BerserkingMark.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/marks/FalseLifeMark.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/marks/GuardingMark.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/marks/HolyLightMark.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/marks/HuntingMark.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/marks/Mark.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/marks/RetaliationMark.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/marks/ScoutingMark.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/marks/VampirismMark.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/marks/WarMark.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/AlchemistBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/BerserkerBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/DiverBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/GuardianBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/HunterBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/InfernoBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/LonerBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/LooterBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/LumberjackBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/MechanicBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/MinerBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/NinjaBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/PaladinBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/ParatrooperBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/PorcupineBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/ScholarBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/StandardBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/SwampBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/ThickSkinnedBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/ThiefBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/VampireBlessing.java create mode 100644 YWD/src/main/java/fyresmodjam/blessings/standard/WarriorBlessing.java (limited to 'YWD/src/main/java/fyresmodjam/blessings') diff --git a/YWD/src/main/java/fyresmodjam/blessings/Blessing.java b/YWD/src/main/java/fyresmodjam/blessings/Blessing.java new file mode 100644 index 0000000..afa167a --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/Blessing.java @@ -0,0 +1,143 @@ +package fyresmodjam.blessings; + +import cpw.mods.fml.common.gameevent.TickEvent.ServerTickEvent; +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; + +/** + * Represents a blessing bestowed to a player. + * + * @author bjculkin + */ +public abstract class Blessing { + private static int nextOrdinal = 0; + + public final int ordinal; + + public final String shortName; + + protected Blessing(String name) { + this(name, true); + } + + protected Blessing(String name, boolean mobAppropriate) { + ordinal = nextOrdinal++; + + shortName = name; + + BlessingUtils.playerBlessings.put(name, this); + if (mobAppropriate) { + BlessingUtils.mobBlessings.put(name, this); + } + } + + public boolean hasCustomName() { + return true; + } + + public String customName() { + return type().displayPrefix + name(); + } + + /** + * Get the type of this blessing. + * + * @return The type of the blessing + */ + public abstract BlessingType type(); + + /** + * Get the name of this blessing. + * + * @return The name of this blessing. + */ + public String name() { + return shortName; + } + + /** + * 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/YWD/src/main/java/fyresmodjam/blessings/BlessingType.java b/YWD/src/main/java/fyresmodjam/blessings/BlessingType.java new file mode 100644 index 0000000..21bc72c --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/BlessingType.java @@ -0,0 +1,30 @@ +package fyresmodjam.blessings; + +/** + * Represents the different types of blessings. + * + * @author bjculkin + */ +public enum BlessingType { + /** + * A standard blessing. + * + * Normal scale benefit. + */ + STANDARD("Blessing", "Blessing of the"), + + /** + * A blessing with a down-side. + * + * Stronger benefit, weak down-side. + */ + MARK("Mark", "Mark of"); + + public final String internalPrefix; + public final String displayPrefix; + + private BlessingType(String internalPrefix, String displayPrefix) { + this.internalPrefix = internalPrefix; + this.displayPrefix = displayPrefix; + } +} \ No newline at end of file diff --git a/YWD/src/main/java/fyresmodjam/blessings/BlessingUtils.java b/YWD/src/main/java/fyresmodjam/blessings/BlessingUtils.java new file mode 100755 index 0000000..c240a7a --- /dev/null +++ b/YWD/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/YWD/src/main/java/fyresmodjam/blessings/marks/ArcaneNullityMark.java b/YWD/src/main/java/fyresmodjam/blessings/marks/ArcaneNullityMark.java new file mode 100644 index 0000000..594bafd --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/marks/ArcaneNullityMark.java @@ -0,0 +1,39 @@ +package fyresmodjam.blessings.marks; + +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class ArcaneNullityMark extends Mark { + public ArcaneNullityMark() { + super("Arcane Nullity"); + } + + @Override + public String benefit() { + return "Take no damage from magic"; + } + + @Override + public String drawback() { + return "Deal no damage with magic"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent lhev, + float damageMultiplier) { + if (lhev.source.isMagicDamage()) { + lhev.setCanceled(true); + } + + return damageMultiplier; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent lhev, + float damageMultiplier) { + if (lhev.source.isMagicDamage()) { + lhev.setCanceled(true); + } + + return damageMultiplier; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/marks/BerserkingMark.java b/YWD/src/main/java/fyresmodjam/blessings/marks/BerserkingMark.java new file mode 100644 index 0000000..6ac0ca1 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/marks/BerserkingMark.java @@ -0,0 +1,31 @@ +package fyresmodjam.blessings.marks; + +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class BerserkingMark extends Mark { + public BerserkingMark() { + super("Berserking"); + } + + @Override + public String benefit() { + return "Deal greatly increased damage"; + } + + @Override + public String drawback() { + return "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/YWD/src/main/java/fyresmodjam/blessings/marks/FalseLifeMark.java b/YWD/src/main/java/fyresmodjam/blessings/marks/FalseLifeMark.java new file mode 100644 index 0000000..74bda57 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/marks/FalseLifeMark.java @@ -0,0 +1,59 @@ +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 { + public FalseLifeMark() { + super("False Life", false); + } + + @Override + public String benefit() { + return "Rally from a fatal injury"; + } + + @Override + public String drawback() { + return "Lose permanent health to do so"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, + float damageMultiplier) { + float totalAmount = Math.max(0.5f, + event.ammount * damageMultiplier); + + if (totalAmount > event.entityLiving.getMaxHealth()) { + event.setCanceled(true); + + event.entityLiving.getEntityAttribute( + SharedMonsterAttributes.maxHealth) + .setBaseValue(event.entityLiving + .getMaxHealth() + / 0.75f); + + event.entityLiving.setHealth( + event.entityLiving.getMaxHealth()); + + event.entityLiving + .addPotionEffect(new PotionEffect( + Potion.moveSpeed.id, + 30, 1)); + event.entityLiving + .addPotionEffect(new PotionEffect( + Potion.resistance.id, + 20, 1)); + event.entityLiving + .addPotionEffect(new PotionEffect( + Potion.damageBoost.id, + 20, 1)); + + return 0; + } + + return damageMultiplier; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/marks/GuardingMark.java b/YWD/src/main/java/fyresmodjam/blessings/marks/GuardingMark.java new file mode 100644 index 0000000..1914dcc --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/marks/GuardingMark.java @@ -0,0 +1,31 @@ +package fyresmodjam.blessings.marks; + +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class GuardingMark extends Mark { + public GuardingMark() { + super("Guarding"); + } + + @Override + public String benefit() { + return "Take less damage"; + } + + @Override + public String drawback() { + return "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/YWD/src/main/java/fyresmodjam/blessings/marks/HolyLightMark.java b/YWD/src/main/java/fyresmodjam/blessings/marks/HolyLightMark.java new file mode 100644 index 0000000..4895b79 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/marks/HolyLightMark.java @@ -0,0 +1,35 @@ +package fyresmodjam.blessings.marks; + +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class HolyLightMark extends Mark { + public HolyLightMark() { + super("Holy Light", false); + } + + @Override + public String benefit() { + return "Deal greatly increased damage to undead"; + } + + @Override + public String drawback() { + return "Heal non-undead for a small amount of the damage you deal to them"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.entityLiving.isEntityUndead()) { + return damageMultiplier + .5f; + } + + float healed = Math.max(0.5f, + (event.ammount * damageMultiplier) + * 0.25f); + + event.entityLiving.heal(healed); + + return damageMultiplier; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/marks/HuntingMark.java b/YWD/src/main/java/fyresmodjam/blessings/marks/HuntingMark.java new file mode 100644 index 0000000..c3349b8 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/marks/HuntingMark.java @@ -0,0 +1,40 @@ +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 { + public HuntingMark() { + super("Hunting"); + } + + @Override + public String benefit() { + return "Deal greatly increased damage with projectile weapons"; + } + + @Override + public String drawback() { + return "Deal less damage from all other sources"; + } + + @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.source.isProjectile()) { + return damageMultiplier + 0.4f; + } + + return damageMultiplier - 0.2f; + } + +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/marks/Mark.java b/YWD/src/main/java/fyresmodjam/blessings/marks/Mark.java new file mode 100644 index 0000000..b768dfa --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/marks/Mark.java @@ -0,0 +1,28 @@ +package fyresmodjam.blessings.marks; + +import fyresmodjam.blessings.Blessing; +import fyresmodjam.blessings.BlessingType; + +public abstract class Mark extends Blessing { + protected Mark(String name) { + this(name, true); + } + + protected Mark(String name, boolean mobAppropriate) { + super(name, mobAppropriate); + } + + public abstract String benefit(); + + public abstract String drawback(); + + @Override + public String description() { + return String.format("BENEFIT - %s\nDRAWBACK - %s", benefit(), drawback()); + } + + @Override + public BlessingType type() { + return BlessingType.MARK; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/marks/RetaliationMark.java b/YWD/src/main/java/fyresmodjam/blessings/marks/RetaliationMark.java new file mode 100644 index 0000000..c138d11 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/marks/RetaliationMark.java @@ -0,0 +1,53 @@ +package fyresmodjam.blessings.marks; + +import fyresmodjam.ModjamMod; +import fyresmodjam.misc.ConfigData; +import fyresmodjam.misc.DamageSources; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class RetaliationMark extends Mark { + public RetaliationMark() { + super("Retaliation"); + } + + @Override + public String benefit() { + return "Have a chance to reflect attacks"; + } + + @Override + public String drawback() { + return "Have a chance for your attacks to be reflected"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + doRetaliation(event, damageMultiplier); + + return damageMultiplier; + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, + float damageMultiplier) { + doRetaliation(event, damageMultiplier); + + return damageMultiplier; + } + + private void doRetaliation(LivingHurtEvent event, + float damageMultiplier) { + if (!event.source.damageType.equals("retaliation")) { + // Don't retaliate for retaliation + if (ModjamMod.r.nextDouble() < ConfigData.RETALIATION_CHANCE) { + event.entityLiving.attackEntityFrom( + DamageSources.retaliation, + Math.max(0.5f, event.ammount + * damageMultiplier)); + + event.setCanceled(true); + } + } + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/marks/ScoutingMark.java b/YWD/src/main/java/fyresmodjam/blessings/marks/ScoutingMark.java new file mode 100644 index 0000000..d1afdb0 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/marks/ScoutingMark.java @@ -0,0 +1,17 @@ +package fyresmodjam.blessings.marks; + +public class ScoutingMark extends Mark { + public ScoutingMark() { + super("Scouting", false); + } + + @Override + public String benefit() { + return "You can see traps without sneaking"; + } + + @Override + public String drawback() { + return "Take increased damage from traps"; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/marks/VampirismMark.java b/YWD/src/main/java/fyresmodjam/blessings/marks/VampirismMark.java new file mode 100644 index 0000000..63d242f --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/marks/VampirismMark.java @@ -0,0 +1,75 @@ +package fyresmodjam.blessings.marks; + +import cpw.mods.fml.common.gameevent.TickEvent.ServerTickEvent; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.world.World; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class VampirismMark extends Mark { + public VampirismMark() { + super("Vampirism", false); + } + + @Override + public String benefit() { + return "Heal a substantial amount of the damage done to enemies"; + } + + @Override + public String drawback() { + return "Greatly weakened during the day and ignited in direct sunlight"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, + float damageMultiplier) { + Entity targetEntity = event.entity; + + if (targetEntity.getBrightness(1.0F) > 0.5F + && canSeeTheWorld(targetEntity.worldObj, + targetEntity)) { + return damageMultiplier + 0.4F; + } + + return damageMultiplier; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + Entity sourceEntity = event.source.getEntity(); + + if (sourceEntity instanceof EntityLivingBase) { + ((EntityLivingBase) sourceEntity).heal( + (event.ammount * damageMultiplier) + * 0.25F); + + boolean seeTheSky = canSeeTheWorld( + sourceEntity.worldObj, + sourceEntity); + + if (sourceEntity.getBrightness(1.0F) > 0.5F + && seeTheSky) { + return damageMultiplier - 0.4F; + } + } + + return damageMultiplier; + } + + @Override + public void commonTick(ServerTickEvent stev, EntityPlayer play) { + if (play.getBrightness(1.0f) > 0.5f + && canSeeTheWorld(play.worldObj, play) + && play.ticksExisted % 20 == 0) { + play.setFire(5); + } + } + + private boolean canSeeTheWorld(World wld, Entity ent) { + return wld.canBlockSeeTheSky((int) (ent.posX), + (int) (ent.posY), (int) (ent.posZ)); + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/marks/WarMark.java b/YWD/src/main/java/fyresmodjam/blessings/marks/WarMark.java new file mode 100644 index 0000000..208a1e4 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/marks/WarMark.java @@ -0,0 +1,31 @@ +package fyresmodjam.blessings.marks; + +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class WarMark extends Mark { + public WarMark() { + super("War"); + } + + @Override + public String benefit() { + return "Deal greatly increased damage with melee weapons"; + } + + @Override + public String drawback() { + return "Deal less damage from all other sources"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if ((event.source.getDamageType().equals("player") + || event.source.getDamageType() + .equals("mob"))) { + return damageMultiplier + 0.4f; + } + + return damageMultiplier - 0.2f; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/AlchemistBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/AlchemistBlessing.java new file mode 100644 index 0000000..aed4e0e --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/AlchemistBlessing.java @@ -0,0 +1,19 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; + +public class AlchemistBlessing extends StandardBlessing { + public AlchemistBlessing() { + super("Alchemist", false); + } + + @Override + public String name() { + return "Alchemist"; + } + + @Override + public String description() { + return "All mystery potions act like wildcard potions"; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/BerserkerBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/BerserkerBlessing.java new file mode 100644 index 0000000..fc11ebf --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/BerserkerBlessing.java @@ -0,0 +1,46 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import fyresmodjam.blessings.BlessingUtils; +import fyresmodjam.misc.EntityStatHelper; +import net.minecraftforge.event.entity.living.LivingDeathEvent; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class BerserkerBlessing extends StandardBlessing { + public BerserkerBlessing() { + super("Berserker", false); + } + + @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.source.getEntity())) { + return damageMultiplier + 0.3f; + } + + return damageMultiplier; + } + + @Override + public void onMobKill(LivingDeathEvent event) { + if (!EntityStatHelper.hasStat(event.source.getEntity(), + "BlessingCounter")) { + EntityStatHelper.giveStat(event.source.getEntity(), + "BlessingCounter", 0); + } + + EntityStatHelper.giveStat(event.source.getEntity(), + "BlessingCounter", + Math.min(10, Integer.parseInt( + EntityStatHelper.getStat( + event.source.getEntity(), + "BlessingCounter")) + + 1)); + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/DiverBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/DiverBlessing.java new file mode 100644 index 0000000..e8d39ec --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/DiverBlessing.java @@ -0,0 +1,21 @@ +package fyresmodjam.blessings.standard; + +import cpw.mods.fml.common.gameevent.TickEvent.ServerTickEvent; +import fyresmodjam.blessings.Blessing; +import net.minecraft.entity.player.EntityPlayer; + +public class DiverBlessing extends StandardBlessing { + public DiverBlessing() { + super("Diver", false); + } + + @Override + public String description() { + return "Breathe underwater"; + } + + @Override + public void commonTick(ServerTickEvent stev, EntityPlayer play) { + play.setAir(0); + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/GuardianBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/GuardianBlessing.java new file mode 100644 index 0000000..a103221 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/GuardianBlessing.java @@ -0,0 +1,26 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class GuardianBlessing extends StandardBlessing { + public GuardianBlessing() { + super("Guardian"); + } + + @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/YWD/src/main/java/fyresmodjam/blessings/standard/HunterBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/HunterBlessing.java new file mode 100644 index 0000000..88100e1 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/HunterBlessing.java @@ -0,0 +1,35 @@ +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 StandardBlessing { + public HunterBlessing() { + super("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.source.isProjectile()) { + return damageMultiplier + 0.2f; + } + + return damageMultiplier; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/InfernoBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/InfernoBlessing.java new file mode 100644 index 0000000..c3d3b3f --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/InfernoBlessing.java @@ -0,0 +1,61 @@ +package fyresmodjam.blessings.standard; + +import cpw.mods.fml.common.gameevent.TickEvent.ServerTickEvent; +import fyresmodjam.blessings.Blessing; +import fyresmodjam.misc.DamageSources; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +// TODO +// replace this with a blessing that nullifies fire, and a mark that +// does that plus the damage boost +public class InfernoBlessing extends StandardBlessing { + public InfernoBlessing() { + super("Inferno"); + } + + @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.source.isFireDamage() + || event.source.getDamageType() + .equals("inFire") + || event.source.getDamageType() + .equals("onFire") + || event.source.getDamageType() + .equals("lava")) { + event.setCanceled(true); + + return 0; + } + + return damageMultiplier; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.source.getEntity().isBurning()) { + return damageMultiplier + 0.35f; + } + + return damageMultiplier; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/LonerBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/LonerBlessing.java new file mode 100644 index 0000000..fa44795 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/LonerBlessing.java @@ -0,0 +1,32 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraft.entity.EntityLivingBase; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class LonerBlessing extends StandardBlessing { + public LonerBlessing() { + super("Loner"); + } + + @Override + public String description() { + return "Do higher damage the lower your health is"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.source.getEntity() instanceof EntityLivingBase) { + float scaleFactor = 1.0F + - (((EntityLivingBase) event.source + .getEntity()).getHealth() + / ((EntityLivingBase) event.source + .getEntity()).getMaxHealth()); + + return damageMultiplier + 0.35F * scaleFactor; + } + + return damageMultiplier; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/LooterBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/LooterBlessing.java new file mode 100644 index 0000000..80fed2b --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/LooterBlessing.java @@ -0,0 +1,29 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.ModjamMod; +import fyresmodjam.blessings.Blessing; +import net.minecraftforge.common.ChestGenHooks; +import net.minecraftforge.event.entity.living.LivingDeathEvent; + +public class LooterBlessing extends StandardBlessing { + public LooterBlessing() { + super("Looter", false); + } + + @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) { + if (!event.entity.worldObj.isRemote) { + event.entity.dropItem(ChestGenHooks + .getOneItem(ChestGenHooks.DUNGEON_CHEST, + ModjamMod.r) + .getItem(), 1); + } + } + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/LumberjackBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/LumberjackBlessing.java new file mode 100644 index 0000000..e4136dc --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/LumberjackBlessing.java @@ -0,0 +1,54 @@ +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.minecraftforge.event.entity.living.LivingHurtEvent; +import net.minecraftforge.event.entity.player.PlayerEvent.BreakSpeed; + +public class LumberjackBlessing extends StandardBlessing { + public LumberjackBlessing() { + super("Lumberjack", false); + } + + @Override + public String description() { + return "Increased breaking speed on wooden blocks, and increased damage with axes"; + } + + @Override + public void checkBreakSpeed(BreakSpeed pebsev) { + if (pebsev.block.getMaterial() == Material.wood) { + pebsev.newSpeed = pebsev.originalSpeed * 1.25F; + } + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + ItemStack held = null; + + if (event.source.getEntity() instanceof EntityLivingBase) { + held = ((EntityLivingBase) event.source + .getEntity()).getHeldItem(); + } + + 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/YWD/src/main/java/fyresmodjam/blessings/standard/MechanicBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/MechanicBlessing.java new file mode 100644 index 0000000..e992d17 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/MechanicBlessing.java @@ -0,0 +1,20 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; + +public class MechanicBlessing extends StandardBlessing { + public MechanicBlessing() { + super("Mechanic", false); + } + + @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/YWD/src/main/java/fyresmodjam/blessings/standard/MinerBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/MinerBlessing.java new file mode 100644 index 0000000..a73d019 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/MinerBlessing.java @@ -0,0 +1,55 @@ +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.minecraftforge.event.entity.living.LivingHurtEvent; +import net.minecraftforge.event.entity.player.PlayerEvent.BreakSpeed; + +public class MinerBlessing extends StandardBlessing { + public MinerBlessing() { + super("Miner", false); + } + + @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.block.getMaterial() == Material.rock + || pebsev.block.getMaterial() == Material.iron) { + pebsev.newSpeed = pebsev.originalSpeed * 1.25F; + } + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + ItemStack held = null; + + if (event.source.getEntity() instanceof EntityLivingBase) { + held = ((EntityLivingBase) event.source + .getEntity()).getHeldItem(); + } + + 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/YWD/src/main/java/fyresmodjam/blessings/standard/NinjaBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/NinjaBlessing.java new file mode 100644 index 0000000..1d61065 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/NinjaBlessing.java @@ -0,0 +1,49 @@ +package fyresmodjam.blessings.standard; + +import cpw.mods.fml.common.gameevent.TickEvent.ServerTickEvent; +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; + +public class NinjaBlessing extends StandardBlessing { + public NinjaBlessing() { + super("Ninja", false); + } + + @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()) { + 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) { + if (event.entityLiving != null + && event.source.getEntity().isSneaking() + && event.entityLiving + .getHealth() == event.entityLiving + .getMaxHealth()) { + return damageMultiplier + 1.0F; + } + + return damageMultiplier; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/PaladinBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/PaladinBlessing.java new file mode 100644 index 0000000..b5be58b --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/PaladinBlessing.java @@ -0,0 +1,25 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class PaladinBlessing extends StandardBlessing { + public PaladinBlessing() { + super("Paladin", false); + } + + @Override + public String description() { + return "Deal bonus damage to undead"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.entityLiving.isEntityUndead()) { + return damageMultiplier + .2f; + } + + return damageMultiplier; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/ParatrooperBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/ParatrooperBlessing.java new file mode 100644 index 0000000..ec02d76 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/ParatrooperBlessing.java @@ -0,0 +1,27 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class ParatrooperBlessing extends StandardBlessing { + public ParatrooperBlessing() { + super("Paratrooper"); + } + + @Override + public String description() { + return "Take no fall damage"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, + float damageMultiplier) { + if(event.source.damageType.equals("fall")) { + event.setCanceled(true); + + return 0; + } + + return damageMultiplier; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/PorcupineBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/PorcupineBlessing.java new file mode 100644 index 0000000..73f5dc2 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/PorcupineBlessing.java @@ -0,0 +1,43 @@ +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 StandardBlessing { + public PorcupineBlessing() { + super("Porcupine"); + } + + @Override + public String description() { + return "Deal retaliation damage to melee attackers"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent event, + float damageMultiplier) { + DamageSource damageSource = event.source; + + Entity source = damageSource.getEntity(); + + if (source != null && source instanceof EntityLivingBase + && !damageSource.isProjectile() + && (damageSource.getDamageType() + .equals("mob") + || damageSource.getDamageType() + .equals("player"))) { + + DamageSource damage = DamageSource + .causeThornsDamage(source); + + ((EntityLivingBase) source).attackEntityFrom( + damage, event.ammount * 0.07F); + } + + return damageMultiplier; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/ScholarBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/ScholarBlessing.java new file mode 100644 index 0000000..f4cbe65 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/ScholarBlessing.java @@ -0,0 +1,27 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class ScholarBlessing extends StandardBlessing { + public ScholarBlessing() { + super("Scholar", false); + } + + @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/YWD/src/main/java/fyresmodjam/blessings/standard/StandardBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/StandardBlessing.java new file mode 100644 index 0000000..51a3766 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/StandardBlessing.java @@ -0,0 +1,19 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import fyresmodjam.blessings.BlessingType; + +public abstract class StandardBlessing extends Blessing { + protected StandardBlessing(String name) { + this(name, true); + } + + protected StandardBlessing(String name, boolean mobAppropriate) { + super(name, mobAppropriate); + } + + @Override + public BlessingType type() { + return BlessingType.STANDARD; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/SwampBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/SwampBlessing.java new file mode 100644 index 0000000..21c3fc8 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/SwampBlessing.java @@ -0,0 +1,30 @@ +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 StandardBlessing { + public SwampBlessing() { + super("Swamp"); + } + + @Override + public String description() { + return "Attacks slow enemies"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.entityLiving != null) { + event.entityLiving + .addPotionEffect(new PotionEffect( + Potion.moveSlowdown.id, + 100, 1, false)); + } + + return damageMultiplier; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/ThickSkinnedBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/ThickSkinnedBlessing.java new file mode 100644 index 0000000..9504eb0 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/ThickSkinnedBlessing.java @@ -0,0 +1,22 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.blessings.Blessing; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class ThickSkinnedBlessing extends StandardBlessing { + public ThickSkinnedBlessing() { + super("Thick-Skinned"); + } + + @Override + public String description() { + return "Reduce damage taken by a flat amount"; + } + + @Override + public float onIncomingDamage(LivingHurtEvent lhev, float damageMultiplier) { + lhev.ammount = Math.max(0.5f, lhev.ammount - 1f); + + return damageMultiplier; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/ThiefBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/ThiefBlessing.java new file mode 100644 index 0000000..267054f --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/ThiefBlessing.java @@ -0,0 +1,26 @@ +package fyresmodjam.blessings.standard; + +import fyresmodjam.ModjamMod; +import net.minecraft.init.Items; +import net.minecraftforge.event.entity.living.LivingDeathEvent; + +public class ThiefBlessing extends StandardBlessing { + public ThiefBlessing() { + super("Thief", false); + } + + @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.entity.worldObj.isRemote) { + event.entity.dropItem(Items.gold_nugget, + 1); + } + } + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/VampireBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/VampireBlessing.java new file mode 100644 index 0000000..914f9c6 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/VampireBlessing.java @@ -0,0 +1,27 @@ +package fyresmodjam.blessings.standard; + +import net.minecraft.entity.EntityLivingBase; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class VampireBlessing extends StandardBlessing { + public VampireBlessing() { + super("Vampire"); + } + + @Override + public String description() { + return "Heal a small percentage of damage dealt to enemies"; + } + + @Override + public float onOutgoingDamage(LivingHurtEvent event, + float damageMultiplier) { + if (event.source.getEntity() instanceof EntityLivingBase) { + ((EntityLivingBase) event.source.getEntity()).heal( + (event.ammount * damageMultiplier) + * 0.07F); + } + + return damageMultiplier; + } +} diff --git a/YWD/src/main/java/fyresmodjam/blessings/standard/WarriorBlessing.java b/YWD/src/main/java/fyresmodjam/blessings/standard/WarriorBlessing.java new file mode 100644 index 0000000..83fed42 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/blessings/standard/WarriorBlessing.java @@ -0,0 +1,36 @@ +package fyresmodjam.blessings.standard; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.IRangedAttackMob; +import net.minecraftforge.event.entity.living.LivingHurtEvent; + +public class WarriorBlessing extends StandardBlessing { + public WarriorBlessing() { + super("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.source.getDamageType().equals("player") + || event.source.getDamageType() + .equals("mob"))) { + return damageMultiplier + 0.2f; + } + + return damageMultiplier; + } +} -- cgit v1.2.3