/** * Begins an experience gain. The amount will be affected by skill modifiers, global rate, perks, * and may be shared with the party * * @param skill Skill being used * @param xp Experience amount to process */ public void beginXpGain(SkillType skill, float xp, XPGainReason xpGainReason) { Validate.isTrue(xp >= 0.0, "XP gained should be greater than or equal to zero."); if (xp <= 0.0) { return; } if (skill.isChildSkill()) { Set<SkillType> parentSkills = FamilyTree.getParents(skill); float splitXp = xp / parentSkills.size(); for (SkillType parentSkill : parentSkills) { if (parentSkill.getPermissions(player)) { beginXpGain(parentSkill, splitXp, xpGainReason); } } return; } // Return if the experience has been shared if (party != null && ShareHandler.handleXpShare( xp, this, skill, ShareHandler.getSharedXpGainReason(xpGainReason))) { return; } beginUnsharedXpGain(skill, xp, xpGainReason); }
public static boolean handleStatsLossEvent( Player player, HashMap<String, Integer> levelChanged, HashMap<String, Float> experienceChanged) { McMMOPlayerStatLossEvent event = new McMMOPlayerStatLossEvent(player, levelChanged, experienceChanged); mcMMO.p.getServer().getPluginManager().callEvent(event); boolean isCancelled = event.isCancelled(); if (!isCancelled) { levelChanged = event.getLevelChanged(); experienceChanged = event.getExperienceChanged(); PlayerProfile playerProfile = UserManager.getPlayer(player).getProfile(); for (SkillType skillType : SkillType.NON_CHILD_SKILLS) { String skillName = skillType.toString(); int playerSkillLevel = playerProfile.getSkillLevel(skillType); playerProfile.modifySkill(skillType, playerSkillLevel - levelChanged.get(skillName)); playerProfile.removeXp(skillType, experienceChanged.get(skillName)); if (playerProfile.getSkillXpLevel(skillType) < 0) { playerProfile.setSkillXpLevel(skillType, 0); } if (playerProfile.getSkillLevel(skillType) < 0) { playerProfile.modifySkill(skillType, 0); } } } return !isCancelled; }
public Construct exec(Target t, Environment environment, Construct... args) throws ConfigRuntimeException { Static.checkPlugin("mcMMO", t); BukkitMCPlayer player = (BukkitMCPlayer) Static.GetPlayer(args[0], t); SkillType skill; int amount = 1; try { skill = SkillType.valueOf(args[1].val().toUpperCase()); } catch (Exception e) { throw new ConfigRuntimeException( "Unknown McMMO skilltype for mcmmo_add_level, " + args[1].val(), Exceptions.ExceptionType.NotFoundException, t); } if (args.length == 3) { try { amount = Integer.parseInt(args[2].val()); } catch (Exception e) { throw new ConfigRuntimeException( "Bad amount for mcmmo_add_level, " + args[2].val(), Exceptions.ExceptionType.RangeException, t); } } ExperienceAPI.addLevel(player._Player(), skill.name(), amount); return new CVoid(t); }
public static SkillType bySecondaryAbility(SecondaryAbility skillAbility) { for (SkillType type : values()) { if (type.getSkillAbilities().contains(skillAbility)) { return type; } } return null; }
public static SkillType byAbility(AbilityType ability) { for (SkillType type : values()) { if (type.getAbility() == ability) { return type; } } return null; }
/** * Creates a new mcMMO replacer. This also validates if all variables are available and can be * used in the runtime. */ public McmmoVariables() { final ImmutableSet.Builder<String> builder = ImmutableSet.builder(); // goes through all available skill types for (SkillType type : SkillType.values()) { final String skillName = type.name().toLowerCase(Locale.ENGLISH); builder.add('%' + skillName + '%'); } skillTypes = builder.build(); }
/** * Check to see if an ability can be activated. * * @param skill The skill the ability is based on */ public void checkAbilityActivation(SkillType skill) { ToolType tool = skill.getTool(); AbilityType ability = skill.getAbility(); setToolPreparationMode(tool, false); if (getAbilityMode(ability)) { return; } int timeRemaining = calculateTimeRemaining(ability); if (timeRemaining > 0) { /* * Axes and Woodcutting are odd because they share the same tool. * We show them the too tired message when they take action. */ if (skill == SkillType.WOODCUTTING || skill == SkillType.AXES) { player.sendMessage(LocaleLoader.getString("Skills.TooTired", timeRemaining)); } return; } if (EventUtils.callPlayerAbilityActivateEvent(player, skill).isCancelled()) { return; } int ticks = PerksUtils.handleActivationPerks( player, 2 + (getSkillLevel(skill) / AdvancedConfig.getInstance().getAbilityLength()), ability.getMaxLength()); // Notify people that ability has been activated ParticleEffectUtils.playAbilityEnabledEffect(player); if (useChatNotifications()) { player.sendMessage(ability.getAbilityOn()); } SkillUtils.sendSkillMessage(player, ability.getAbilityPlayer(player)); // Enable the ability profile.setAbilityDATS( ability, System.currentTimeMillis() + (ticks * Misc.TIME_CONVERSION_FACTOR)); setAbilityMode(ability, true); if (ability == AbilityType.SUPER_BREAKER || ability == AbilityType.GIGA_DRILL_BREAKER) { SkillUtils.handleAbilitySpeedIncrease(player); } new AbilityDisableTask(this, ability) .runTaskLater(mcMMO.p, ticks * Misc.TICK_CONVERSION_FACTOR); }
/** * Gets the power level of this player. * * @return the power level of the player */ public int getPowerLevel() { int powerLevel = 0; for (SkillType type : SkillType.NON_CHILD_SKILLS) { if (type.getPermissions(player)) { powerLevel += getSkillLevel(type); } } return powerLevel; }
public void processAbilityActivation(SkillType skill) { if (Config.getInstance().getAbilitiesOnlyActivateWhenSneaking() && !player.isSneaking()) { return; } ItemStack inHand = player.getItemInHand(); if (mcMMO.getModManager().isCustomTool(inHand) && !mcMMO.getModManager().getTool(inHand).isAbilityEnabled()) { return; } if (!getAbilityUse()) { return; } for (AbilityType abilityType : AbilityType.values()) { if (getAbilityMode(abilityType)) { return; } } AbilityType ability = skill.getAbility(); ToolType tool = skill.getTool(); /* * Woodcutting & Axes need to be treated differently. * Basically the tool always needs to ready and we check to see if the cooldown is over when the user takes action */ if (ability.getPermissions(player) && tool.inHand(inHand) && !getToolPreparationMode(tool)) { if (skill != SkillType.WOODCUTTING && skill != SkillType.AXES) { int timeRemaining = calculateTimeRemaining(ability); if (!getAbilityMode(ability) && timeRemaining > 0) { player.sendMessage(LocaleLoader.getString("Skills.TooTired", timeRemaining)); return; } } if (Config.getInstance().getAbilityMessagesEnabled()) { player.sendMessage(tool.getRaiseTool()); } setToolPreparationMode(tool, true); new ToolLowerTask(this, tool) .runTaskLaterAsynchronously(mcMMO.p, 4 * Misc.TICK_CONVERSION_FACTOR); } }
/* Materials */ public int getXp(SkillType skill, Material material) { return config.getInt( "Experience." + StringUtils.getCapitalized(skill.toString()) + "." + StringUtils.getPrettyItemString(material).replace(" ", "_")); }
/* * SKILL SETTINGS */ public boolean getDoubleDropsEnabled(SkillType skill, Material material) { return config.getBoolean( "Double_Drops." + StringUtils.getCapitalized(skill.toString()) + "." + StringUtils.getPrettyItemString(material).replace(" ", "_")); }
public static boolean handleVampirismEvent( Player killer, Player victim, HashMap<String, Integer> levelChanged, HashMap<String, Float> experienceChanged) { McMMOPlayerVampirismEvent eventKiller = new McMMOPlayerVampirismEvent(killer, false, levelChanged, experienceChanged); McMMOPlayerVampirismEvent eventVictim = new McMMOPlayerVampirismEvent(victim, true, levelChanged, experienceChanged); mcMMO.p.getServer().getPluginManager().callEvent(eventKiller); mcMMO.p.getServer().getPluginManager().callEvent(eventVictim); boolean isCancelled = eventKiller.isCancelled() || eventVictim.isCancelled(); if (!isCancelled) { HashMap<String, Integer> levelChangedKiller = eventKiller.getLevelChanged(); HashMap<String, Float> experienceChangedKiller = eventKiller.getExperienceChanged(); HashMap<String, Integer> levelChangedVictim = eventVictim.getLevelChanged(); HashMap<String, Float> experienceChangedVictim = eventVictim.getExperienceChanged(); McMMOPlayer killerPlayer = UserManager.getPlayer(killer); PlayerProfile victimProfile = UserManager.getPlayer(victim).getProfile(); for (SkillType skillType : SkillType.NON_CHILD_SKILLS) { String skillName = skillType.toString(); int victimSkillLevel = victimProfile.getSkillLevel(skillType); killerPlayer.addLevels(skillType, levelChangedKiller.get(skillName)); killerPlayer.beginUnsharedXpGain( skillType, experienceChangedKiller.get(skillName), XPGainReason.VAMPIRISM); victimProfile.modifySkill(skillType, victimSkillLevel - levelChangedVictim.get(skillName)); victimProfile.removeXp(skillType, experienceChangedVictim.get(skillName)); if (victimProfile.getSkillXpLevel(skillType) < 0) { victimProfile.setSkillXpLevel(skillType, 0); } if (victimProfile.getSkillLevel(skillType) < 0) { victimProfile.modifySkill(skillType, 0); } } } return !isCancelled; }
public static McMMOPlayerAbilityDeactivateEvent callAbilityDeactivateEvent( Player player, AbilityType ability) { McMMOPlayerAbilityDeactivateEvent event = new McMMOPlayerAbilityDeactivateEvent(player, SkillType.byAbility(ability)); mcMMO.p.getServer().getPluginManager().callEvent(event); return event; }
protected String[] calculateLengthDisplayValues(Player player, float skillValue) { int maxLength = skill.getAbility().getMaxLength(); int length = 2 + (int) (skillValue / AdvancedConfig.getInstance().getAbilityLength()); int enduranceLength = PerksUtils.handleActivationPerks(player, length, maxLength); if (maxLength != 0) { length = Math.min(length, maxLength); } return new String[] {String.valueOf(length), String.valueOf(enduranceLength)}; }
static { List<SkillType> childSkills = new ArrayList<SkillType>(); List<SkillType> nonChildSkills = new ArrayList<SkillType>(); ArrayList<String> names = new ArrayList<String>(); for (SkillType skill : values()) { if (skill.isChildSkill()) { childSkills.add(skill); } else { nonChildSkills.add(skill); } names.add(skill.getName()); } Collections.sort(names); SKILL_NAMES = ImmutableList.copyOf(names); CHILD_SKILLS = ImmutableList.copyOf(childSkills); NON_CHILD_SKILLS = ImmutableList.copyOf(nonChildSkills); }
@Override protected void loadKeys() { config.setDefaults(YamlConfiguration.loadConfiguration(plugin.getResource("child.yml"))); FamilyTree.clearRegistrations(); // when reloading, need to clear statics for (SkillType skill : SkillType.CHILD_SKILLS) { plugin.debug("Finding parents of " + skill.name()); EnumSet<SkillType> parentSkills = EnumSet.noneOf(SkillType.class); boolean useDefaults = false; // If we had an error we back out and use defaults for (String name : config.getStringList(StringUtils.getCapitalized(skill.name()))) { try { SkillType parentSkill = SkillType.valueOf(name.toUpperCase()); FamilyTree.enforceNotChildSkill(parentSkill); parentSkills.add(parentSkill); } catch (IllegalArgumentException ex) { plugin.getLogger().warning(name + " is not a valid skill type, or is a child skill!"); useDefaults = true; break; } } if (useDefaults) { parentSkills.clear(); for (String name : config.getDefaults().getStringList(StringUtils.getCapitalized(skill.name()))) { /* We do less checks in here because it's from inside our jar. * If they're dedicated enough to have modified it, they can have the errors it may produce. * Alternatively, this can be used to allow child skills to be parent skills, provided there are no circular dependencies this is an advanced sort of configuration. */ parentSkills.add(SkillType.valueOf(name.toUpperCase())); } } // Register them for (SkillType parentSkill : parentSkills) { plugin.debug("Registering " + parentSkill.name() + " as parent of " + skill.name()); FamilyTree.registerParent(skill, parentSkill); } } FamilyTree.closeRegistration(); }
/** * Applies an experience gain * * @param skillType Skill being used * @param xp Experience amount to add */ public void applyXpGain(SkillType skillType, float xp, XPGainReason xpGainReason) { if (!skillType.getPermissions(player)) { return; } if (skillType.isChildSkill()) { Set<SkillType> parentSkills = FamilyTree.getParents(skillType); for (SkillType parentSkill : parentSkills) { applyXpGain(parentSkill, xp / parentSkills.size(), xpGainReason); } return; } if (!EventUtils.handleXpGainEvent(player, skillType, xp, xpGainReason)) { return; } isUsingUnarmed = (skillType == SkillType.UNARMED); checkXp(skillType, xpGainReason); }
public static SkillType getSkill(String skillName) { if (!Config.getInstance().getLocale().equalsIgnoreCase("en_US")) { for (SkillType type : values()) { if (skillName.equalsIgnoreCase( LocaleLoader.getString(StringUtils.getCapitalized(type.name()) + ".SkillName"))) { return type; } } } for (SkillType type : values()) { if (type.name().equalsIgnoreCase(skillName)) { return type; } } if (!skillName.equalsIgnoreCase("all")) { mcMMO.p.getLogger().warning("Invalid mcMMO skill (" + skillName + ")"); // TODO: Localize } return null; }
/** * Modifies an experience gain using skill modifiers, global rate and perks * * @param skillType Skill being used * @param xp Experience amount to process * @return Modified experience */ private float modifyXpGain(SkillType skillType, float xp) { if (player.getGameMode() == GameMode.CREATIVE || (skillType.getMaxLevel() <= getSkillLevel(skillType)) || (Config.getInstance().getPowerLevelCap() <= getPowerLevel())) { return 0; } xp = (float) (xp / skillType.getXpModifier() * ExperienceConfig.getInstance().getExperienceGainsGlobalMultiplier()); if (Config.getInstance().getToolModsEnabled()) { CustomTool tool = mcMMO.getModManager().getTool(player.getItemInHand()); if (tool != null) { xp *= tool.getXpMultiplier(); } } return PerksUtils.handleXpPerks(player, xp, skillType); }
public McMMOPlayer(Player player, PlayerProfile profile) { String playerName = player.getName(); UUID uuid = player.getUniqueId(); this.player = player; playerMetadata = new FixedMetadataValue(mcMMO.p, playerName); this.profile = profile; if (profile.getUniqueId() == null) { profile.setUniqueId(uuid); } /* * I'm using this method because it makes code shorter and safer (we don't have to add all SkillTypes manually), * but I actually have no idea about the performance impact, if there is any. * If in the future someone wants to remove this, don't forget to also remove what is in the SkillType enum. - bm01 */ try { for (SkillType skillType : SkillType.values()) { skillManagers.put( skillType, skillType.getManagerClass().getConstructor(McMMOPlayer.class).newInstance(this)); } } catch (Exception e) { e.printStackTrace(); mcMMO.p.getPluginLoader().disablePlugin(mcMMO.p); } for (AbilityType abilityType : AbilityType.values()) { abilityMode.put(abilityType, false); abilityInformed.put(abilityType, true); // This is intended } for (ToolType toolType : ToolType.values()) { toolMode.put(toolType, false); } }
public boolean getDoubleDropsDisabled(SkillType skill) { String skillName = StringUtils.getCapitalized(skill.toString()); ConfigurationSection section = config.getConfigurationSection("Double_Drops." + skillName); if (section == null) return false; Set<String> keys = section.getKeys(false); boolean disabled = true; for (String key : keys) { if (config.getBoolean("Double_Drops." + skillName + "." + key)) { disabled = false; break; } } return disabled; }
/** * Check the XP of a skill. * * @param skillType The skill to check */ private void checkXp(SkillType skillType, XPGainReason xpGainReason) { if (getSkillXpLevelRaw(skillType) < getXpToLevel(skillType)) { return; } int levelsGained = 0; float xpRemoved = 0; while (getSkillXpLevelRaw(skillType) >= getXpToLevel(skillType)) { if (hasReachedLevelCap(skillType)) { setSkillXpLevel(skillType, 0); break; } xpRemoved += profile.levelUp(skillType); levelsGained++; } if (!EventUtils.handleLevelChangeEvent( player, skillType, levelsGained, xpRemoved, true, xpGainReason)) { return; } if (Config.getInstance().getLevelUpSoundsEnabled()) { player.playSound( player.getLocation(), Sound.ENTITY_EXPERIENCE_ORB_PICKUP, Misc.LEVELUP_VOLUME, Misc.LEVELUP_PITCH); } player.sendMessage( LocaleLoader.getString( StringUtils.getCapitalized(skillType.toString()) + ".Skillup", levelsGained, getSkillLevel(skillType))); }
public boolean getPVEEnabled(SkillType skill) { return config.getBoolean( "Skills." + StringUtils.getCapitalized(skill.toString()) + ".Enabled_For_PVE", true); }
public int getLevelCap(SkillType skill) { int cap = config.getInt("Skills." + StringUtils.getCapitalized(skill.toString()) + ".Level_Cap"); return (cap <= 0) ? Integer.MAX_VALUE : cap; }
public void setHardcoreVampirismEnabled(SkillType skillType, boolean enabled) { config.set( "Hardcore.Vampirism.Enabled." + StringUtils.getCapitalized(skillType.toString()), enabled); }
public boolean getHardcoreVampirismEnabled(SkillType skillType) { return config.getBoolean( "Hardcore.Vampirism.Enabled." + StringUtils.getCapitalized(skillType.toString()), false); }
public void setHardcoreStatLossEnabled(SkillType skillType, boolean enabled) { config.set( "Hardcore.Death_Stat_Loss.Enabled." + StringUtils.getCapitalized(skillType.toString()), enabled); }
/* Skill modifiers */ public double getFormulaSkillModifier(SkillType skill) { return config.getDouble( "Experience_Formula.Modifier." + StringUtils.getCapitalized(skill.toString())); }
/* Hardcore Mode */ public boolean getHardcoreStatLossEnabled(SkillType skillType) { return config.getBoolean( "Hardcore.Death_Stat_Loss.Enabled." + StringUtils.getCapitalized(skillType.toString()), false); }
@Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (CommandUtils.noConsoleUsage(sender)) { return true; } switch (args.length) { case 0: Player player = (Player) sender; McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player); boolean isLucky = Permissions.lucky(player, skill); boolean hasEndurance = (PerksUtils.handleActivationPerks(player, 0, 0) != 0); float skillValue = mcMMOPlayer.getSkillLevel(skill); permissionsCheck(player); dataCalculations(player, skillValue, isLucky); if (Config.getInstance().getSkillUseBoard()) { ScoreboardManager.enablePlayerSkillScoreboard(player, skill); } if (!skill.isChildSkill()) { player.sendMessage(LocaleLoader.getString("Skills.Header", skillName)); player.sendMessage( LocaleLoader.getString( "Commands.XPGain", LocaleLoader.getString( "Commands.XPGain." + StringUtils.getCapitalized(skill.toString())))); player.sendMessage( LocaleLoader.getString( "Effects.Level", (int) skillValue, mcMMOPlayer.getSkillXpLevel(skill), mcMMOPlayer.getXpToLevel(skill))); } else { player.sendMessage( LocaleLoader.getString( "Skills.Header", skillName + " " + LocaleLoader.getString("Skills.Child"))); player.sendMessage( LocaleLoader.getString( "Commands.XPGain", LocaleLoader.getString("Commands.XPGain.Child"))); player.sendMessage(LocaleLoader.getString("Effects.Child", (int) skillValue)); player.sendMessage( LocaleLoader.getString("Skills.Header", LocaleLoader.getString("Skills.Parents"))); Set<SkillType> parents = FamilyTree.getParents(skill); for (SkillType parent : parents) { player.sendMessage( parent.getName() + " - " + LocaleLoader.getString( "Effects.Level", mcMMOPlayer.getSkillLevel(parent), mcMMOPlayer.getSkillXpLevel(parent), mcMMOPlayer.getXpToLevel(parent))); } } List<String> effectMessages = effectsDisplay(); if (!effectMessages.isEmpty()) { player.sendMessage( LocaleLoader.getString("Skills.Header", LocaleLoader.getString("Effects.Effects"))); if (isLucky) { String perkPrefix = LocaleLoader.getString("MOTD.PerksPrefix"); player.sendMessage( perkPrefix + LocaleLoader.getString( "Effects.Template", LocaleLoader.getString("Perks.Lucky.Name"), LocaleLoader.getString("Perks.Lucky.Desc", skillName))); } for (String message : effectMessages) { player.sendMessage(message); } } List<String> statsMessages = statsDisplay(player, skillValue, hasEndurance, isLucky); if (!statsMessages.isEmpty()) { player.sendMessage( LocaleLoader.getString( "Skills.Header", LocaleLoader.getString("Commands.Stats.Self"))); for (String message : statsMessages) { player.sendMessage(message); } } player.sendMessage( LocaleLoader.getString("Guides.Available", skillName, skillName.toLowerCase())); return true; default: return skillGuideCommand.onCommand(sender, command, label, args); } }