Merge branch 'slayer-improvements' into 'master'

Slayer improvements

See merge request 2009scape/2009scape!214

Server/src/main/java/core/game/interaction/inter/JewelleryInterface.java

@@ -186,7 +186,7 @@ public final class JewelleryInterface extends ComponentPlugin {
 			});
 			return true;
 		}
-		if(!player.getSlayer().getLearned()[1] && data.equals(JewelleryItem.SLAYER_RING)){
+		if(!player.getSlayer().flags.isRingUnlocked()){
 			player.sendMessages("You don't know how to make this. Talk to any Slayer master in order to learn the", "ability that creates Slayer rings.");
 			return true;
 		}

Server/src/main/java/core/game/node/entity/skill/fletching/items/arrow/ArrowHeadPulse.java

@@ -43,7 +43,7 @@ public class ArrowHeadPulse extends SkillPulse<Item> {
 	@Override
 	public boolean checkRequirements() {
 		if (arrow.unfinished == 4160) {
-			if (!player.getSlayer().getLearned()[0]) {
+			if (!player.getSlayer().flags.isBroadsUnlocked()) {
 				player.getDialogueInterpreter().sendDialogue("You need to unlock the ability to create broad arrows.");
 				return false;
 			}

Server/src/main/java/core/game/node/entity/skill/fletching/items/bolts/BoltPulse.java

@@ -60,7 +60,7 @@ public final class BoltPulse extends SkillPulse<Item> {
 	@Override
 	public boolean checkRequirements() {
 		if (bolt.getUnfinished().getId() == 13279) {
-			if (!player.getSlayer().getLearned()[0]) {
+			if (!player.getSlayer().flags.isBroadsUnlocked()) {
 				player.getDialogueInterpreter().sendDialogue("You need to unlock the ability to create broad bolts.");
 				return false;
 			}

Server/src/main/java/core/game/node/entity/skill/slayer/EnchantedGemDialogue.java

@@ -93,8 +93,7 @@ public final class EnchantedGemDialogue extends DialoguePlugin {
 				break;
 			}
 			interpreter.sendDialogues(player.getSlayer().getMaster().getNpc(), FacialExpression.HALF_GUILTY, "You're currently assigned to kill "  + (player.getSlayer().getTask() == Tasks.JAD ? " TzTok-Jad!" : NPCDefinition.forId((player.getSlayer().getTask().getNpcs()[0])).getName().toLowerCase() + "'s;"), "only " + player.getSlayer().getAmount() + " more to go.");
-			player.varpManager.get(2502).setVarbit(1,player.getSlayer().getTask().ordinal());
+			player.varpManager.get(2502).setVarbit(0,player.getSlayer().flags.getTaskFlags() >> 4).send(player);
-			player.varpManager.get(2502).setVarbit(8,player.getSlayer().getAmount()).send(player);
 			stage = 11;
 			break;
 		case 11:

Server/src/main/java/core/game/node/entity/skill/slayer/SlayerEquipmentFlags.kt

@@ -28,47 +28,47 @@ object SlayerEquipmentFlags {
 
         if((ContentAPI.getItemFromEquipment(player, EquipmentSlot.AMULET)?.id ?: 0) == Items.WITCHWOOD_ICON_8923) flags = flags or (1 shl 7)
         if((ContentAPI.getItemFromEquipment(player, EquipmentSlot.SHIELD)?.id ?: 0) == Items.MIRROR_SHIELD_4156) flags = flags or (1 shl 8)
-        player.slayer.equipmentFlags = flags
+        player.slayer.flags.equipmentFlags = flags
     }
 
     @JvmStatic
     fun hasNosePeg(player: Player): Boolean{
-        return player.slayer.equipmentFlags and 1 == 1
+        return player.slayer.flags.equipmentFlags and 1 == 1
     }
 
     @JvmStatic
     fun hasEarmuffs(player: Player): Boolean {
-        return (player.slayer.equipmentFlags shr 1) and 1 == 1
+        return (player.slayer.flags.equipmentFlags shr 1) and 1 == 1
     }
 
     @JvmStatic
     fun hasFaceMask(player: Player): Boolean {
-        return (player.slayer.equipmentFlags shr 2) and 1 == 1
+        return (player.slayer.flags.equipmentFlags shr 2) and 1 == 1
     }
 
     @JvmStatic
     fun hasBlackMask(player: Player): Boolean {
-        return (player.slayer.equipmentFlags shr 3) and 1 == 1
+        return (player.slayer.flags.equipmentFlags shr 3) and 1 == 1
     }
 
     @JvmStatic
     fun hasSpinyHelmet(player: Player): Boolean {
-        return (player.slayer.equipmentFlags shr 4) and 1 == 1
+        return (player.slayer.flags.equipmentFlags shr 4) and 1 == 1
     }
 
     @JvmStatic
     fun hasWitchwoodIcon(player: Player): Boolean {
-        return (player.slayer.equipmentFlags shr 7) and 1 == 1
+        return (player.slayer.flags.equipmentFlags shr 7) and 1 == 1
     }
 
     @JvmStatic
     fun hasMirrorShield(player: Player): Boolean {
-        return (player.slayer.equipmentFlags shr 8) and 1 == 1
+        return (player.slayer.flags.equipmentFlags shr 8) and 1 == 1
     }
 
     @JvmStatic
     fun getDamAccBonus(player: Player): Double {
-        val isCape = player.slayer.equipmentFlags == 0x3F
+        val isCape = player.slayer.flags.equipmentFlags == 0x3F
         val hasMask = hasBlackMask(player)
 
         return if(isCape) 1.075

Server/src/main/java/core/game/node/entity/skill/slayer/SlayerManager.java

@@ -8,6 +8,7 @@ import core.game.node.entity.skill.Skills;
 import core.tools.RandomFunction;
 import org.json.simple.JSONArray;
 import org.json.simple.JSONObject;
+import rs09.game.node.entity.skill.slayer.SlayerFlags;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -26,49 +27,9 @@ public final class SlayerManager {
 	private final Player player;
 
 	/**
-	 * The current slayer master used.
+	 * The player's slayer flags
 	 */
-	private Master master;
+	public final SlayerFlags flags;
-
-	/**
-	 * The current task.
-	 */
-	private Tasks task;
-
-	/**
-	 * The amount of the hunted killed.
-	 */
-	private int amount;
-
-	/**
-	 * The slayer points.
-	 */
-	private int slayerPoints;
-
-	/**
-	 * The task streak.
-	 */
-	private int taskCount;
-
-	/**
-	 * Total tasks completed
-	 */
-	private int taskTotal;
-
-	/**
-	 * The learned rewards.
-	 */
-	private final boolean[] learned = new boolean[3];
-
-	/**
-	 * The removed tasks.
-	 */
-	private final List<Tasks> removed = new ArrayList<>(4);
-
-	/**
-	 * The equipment flags for the given player
-	 */
-	public int equipmentFlags = 0;
 
 	/**
 	 * Constructs a new {@Code SlayerManager} {@Code Object}
@@ -76,39 +37,66 @@ public final class SlayerManager {
 	 */
 	public SlayerManager(Player player) {
 		this.player = player;
+		this.flags = new SlayerFlags(player);
 	}
 
-	/**
-	 * If the player can earn points (taskTotal > 4)
-	 */
-	private boolean canEarnPoints = false;
-
 	public void parse(JSONObject slayerData){
 		Object m = slayerData.get("master");
-		if(m != null)
+		if(m != null) {
-			this.master = Master.forId(Integer.parseInt(m.toString()));
+			flags.setMaster(Master.forId(Integer.parseInt(m.toString())));
+		}
 		Object t = slayerData.get("taskId");
 		if(t != null)
-			task = Tasks.values()[Integer.parseInt(t.toString())];
+			flags.setTask(Tasks.values()[Integer.parseInt(t.toString())]);
 		Object a = slayerData.get("taskAmount");
 		if(a != null)
-			amount = Integer.parseInt(a.toString());
+			flags.setTaskAmount(Integer.parseInt(a.toString()));
-		slayerPoints = Integer.parseInt( slayerData.get("points").toString());
+		Object points = slayerData.get("points");
-		taskCount = Integer.parseInt( slayerData.get("taskStreak").toString());
+		if(points != null){
+			flags.setPoints(Integer.parseInt(points.toString()));
+		}
+		Object taskStreak = slayerData.get("taskStreak");
+		if(taskStreak != null){
+			flags.setTaskStreak(Integer.parseInt(taskStreak.toString()));
+		}
+		Object la = slayerData.get("learned_rewards");
+		if(la != null) {
 			JSONArray learnedArray = (JSONArray) slayerData.get("learned_rewards");
-		for(int i = 0; i < learnedArray.size(); i++){
+			for (int i = 0; i < learnedArray.size(); i++) {
-			learned[i] = (boolean) learnedArray.get(i);
+				boolean unlocked = (boolean) learnedArray.get(i);
+				switch(i){
+					case 0:
+						if(unlocked) flags.unlockBroads();
+						break;
+					case 1:
+						if(unlocked) flags.unlockRing();
+						break;
+					case 2:
+						if(unlocked) flags.unlockHelm();
+						break;
+					default:
+						break;
+				}
+			}
 		}
 		JSONArray removedTasks = (JSONArray) slayerData.get("removedTasks");
 		if(removedTasks != null){
 			for(int i = 0; i < removedTasks.size(); i++){
-				removed.add(Tasks.values()[Integer.parseInt(removedTasks.get(i).toString())]);
+				flags.getRemoved().add(Tasks.values()[Integer.parseInt(removedTasks.get(i).toString())]);
 			}
 		}
-		taskTotal = Integer.parseInt( slayerData.get("totalTasks").toString());
+		Object completedTasks = slayerData.get("totalTasks").toString();
-		canEarnPoints = (boolean) slayerData.get("canEarnPoints");
+		if(completedTasks != null) flags.setCompletedTasks(Integer.parseInt(completedTasks.toString()));
+		if(flags.getCompletedTasks() >= 4) flags.flagCanEarnPoints();
+
+		//New system parsing
 		if(slayerData.containsKey("equipmentFlags"))
-			equipmentFlags = Integer.parseInt(slayerData.get("equipmentFlags").toString());
+			flags.setEquipmentFlags(Integer.parseInt(slayerData.get("equipmentFlags").toString()));
+		if(slayerData.containsKey("taskFlags"))
+			flags.setTaskFlags(Integer.parseInt(slayerData.get("taskFlags").toString()));
+		if(slayerData.containsKey("rewardFlags"))
+			flags.setRewardFlags(Integer.parseInt(slayerData.get("rewardFlags").toString()));
+
 	}
 
 	/**
@@ -121,25 +109,25 @@ public final class SlayerManager {
 		decrementAmount(1);
 		if (!hasTask()) {
 			clear();
-			taskCount++;
+			flags.setTaskStreak(flags.getTaskStreak() + 1);
-			taskTotal++;
+			flags.setCompletedTasks(flags.getCompletedTasks() + 1);
-			if ((taskCount > 4 || canEarnPoints ) && master != Master.TURAEL && slayerPoints < 64000) {
+			if ((flags.getCompletedTasks() > 4 || flags.canEarnPoints() ) && flags.getMaster() != Master.TURAEL && flags.getPoints() < 64000) {
-				int points = master.getTaskPoints()[0];
+				int points = flags.getMaster().getTaskPoints()[0];
-				if (taskCount % 10 == 0) {
+				if (flags.getTaskStreak() % 10 == 0) {
-					points = master.getTaskPoints()[1];
+					points = flags.getMaster().getTaskPoints()[1];
-				} else if (taskCount % 50 == 0) {
+				} else if (flags.getTaskStreak() % 50 == 0) {
-					points = master.getTaskPoints()[2];
+					points = flags.getMaster().getTaskPoints()[2];
 				}
-				slayerPoints += points;
+				flags.incrementPoints(points);
-				if (slayerPoints > 64000) {
+				if (flags.getPoints() > 64000) {
-					slayerPoints = 64000;
+					flags.setPoints(64000);
 				}
-				player.sendMessages("You've completed " + taskCount + " tasks in a row and received " + points + " points, with a total of " + player.getSlayer().getSlayerPoints(),"You have completed " + taskTotal + " tasks in total. Return to a Slayer master.");
+				player.sendMessages("You've completed " + flags.getTaskStreak() + " tasks in a row and received " + points + " points, with a total of " + flags.getPoints(),"You have completed " + flags.getCompletedTasks() + " tasks in total. Return to a Slayer master.");
-			} else if(taskCount == 4){
+			} else if(flags.getCompletedTasks() == 4){
 				player.sendMessage("You've completed your task; you will start gaining points on your next task!");
-				canEarnPoints = true;
+				flags.flagCanEarnPoints();
 			} else {
-				player.sendMessages("You've completed your task; Complete " + (4 - taskCount) + " more task(s) to start gaining points.", "Return to a Slayer master.");
+				player.sendMessages("You've completed your task; Complete " + (4 - flags.getCompletedTasks()) + " more task(s) to start gaining points.", "Return to a Slayer master.");
 			}
 		} else {
 			//player.sendMessage("You're assigned to kill " + NPCDefinition.forId((player.getSlayer().getTask().getNpcs()[0])).getName().toLowerCase() + "s; Only " + getAmount() + " more to go.");
@@ -160,8 +148,7 @@ public final class SlayerManager {
 		} else if (master == Master.VANNAKA) {
 			player.getAchievementDiaryManager().finishTask(player, DiaryType.VARROCK, 1, 14);
 		}
-		getPlayer().varpManager.get(2502).setVarbit(1,task.ordinal());
+		getPlayer().varpManager.get(2502).setVarbit(0, flags.getTaskFlags() >> 4).send(player);
-		getPlayer().varpManager.get(2502).setVarbit(8,getAmount()).send(player);
 	}
 
 	/**
@@ -185,14 +172,13 @@ public final class SlayerManager {
 	}
 
 	public boolean canBeAssigned(Tasks task){
-		return player.getSkills().getLevel(Skills.SLAYER) >= task.levelReq && !removed.contains(task);
+		return player.getSkills().getLevel(Skills.SLAYER) >= task.levelReq && !flags.getRemoved().contains(task);
 	}
 
 	/**
 	 * Clears the task.
 	 */
 	public void clear() {
-		setTask(null);
 		setAmount(0);
 	}
 
@@ -210,14 +196,12 @@ public final class SlayerManager {
 	 * @return the name.
 	 */
 	public String getTaskName() {
-		if (task == null) {
+		Tasks task = flags.getTask();
-			return "null";
-		}
 		if (task.getNpcs() == null) {
 			return "no npcs report me";
 		}
 		if (task.getNpcs().length < 1) {
-			return "npc length to small report me";
+			return "npc length too small report me";
 		}
 		return NPCDefinition.forId(task.getNpcs()[0]).getName().toLowerCase();
 	}
@@ -227,15 +211,15 @@ public final class SlayerManager {
 	 * @return The task.
 	 */
 	public Tasks getTask() {
-		return task;
+		return flags.getTask();
 	}
 
 	/**
 	 * Sets the task.
 	 * @param task The task to set.
 	 */
-	public void setTask(Tasks task) {
+	public void setTask(Tasks task){
-		this.task = task;
+		flags.setTask(task);
 	}
 
 	/**
@@ -251,7 +235,7 @@ public final class SlayerManager {
 	 * @return The master.
 	 */
 	public Master getMaster() {
-		return master;
+		return flags.getMaster();
 	}
 
 	/**
@@ -259,7 +243,7 @@ public final class SlayerManager {
 	 * @param master The master to set.
 	 */
 	public void setMaster(Master master) {
-		this.master = master;
+		flags.setMaster(master);
 	}
 
 	/**
@@ -267,13 +251,7 @@ public final class SlayerManager {
 	 * @return {@code True} if so.
 	 */
 	public boolean hasTask() {
-		if (task == null) {
+		return getAmount() != 0;
-			return false;
-		}
-		if (getAmount() == 0) {
-			return false;
-		}
-		return true;
 	}
 
 	/**
@@ -281,7 +259,7 @@ public final class SlayerManager {
 	 * @return <code>True</code> if so.
 	 */
 	public boolean isCompleted() {
-		return amount <= 0;
+		return flags.getTaskAmount() <= 0;
 	}
 
 	/**
@@ -289,7 +267,7 @@ public final class SlayerManager {
 	 * @return The amount.
 	 */
 	public int getAmount() {
-		return amount;
+		return flags.getTaskAmount();
 	}
 
 	/**
@@ -297,7 +275,7 @@ public final class SlayerManager {
 	 * @param amount The amount to set.
 	 */
 	public void setAmount(int amount) {
-		this.amount = amount;
+		flags.setTaskAmount(amount);
 	}
 
 	/**
@@ -305,10 +283,8 @@ public final class SlayerManager {
 	 * @param amount the amount.
 	 */
 	public void decrementAmount(int amount) {
-		this.amount -= amount;
+		flags.decrementTaskAmount(amount);
-		if(player.varpManager.get(2502).getVarbit(1) == null) player.varpManager.get(2502).setVarbit(1,task.ordinal());
+		player.varpManager.get(2502).setVarbit(0, flags.getTaskFlags() >> 4).send(player);
-		player.varpManager.get(2502).setVarbit(8,getAmount());
-		player.varpManager.get(2502).send(player);
 	}
 
 	/**
@@ -316,7 +292,7 @@ public final class SlayerManager {
 	 * @return {@code True} if so.
 	 */
 	public boolean hasStarted() {
-		return master != null;
+		return flags.getCompletedTasks() > 0 || flags.getTaskAmount() > 0;
 	}
 
 	/**
@@ -324,7 +300,7 @@ public final class SlayerManager {
 	 * @return the slayerPoints.
 	 */
 	public int getSlayerPoints() {
-		return slayerPoints;
+		return flags.getPoints();
 	}
 
 	/**
@@ -332,7 +308,7 @@ public final class SlayerManager {
 	 * @param slayerPoints the slayerPoints to set
 	 */
 	public void setSlayerPoints(int slayerPoints) {
-		this.slayerPoints = slayerPoints;
+		flags.setPoints(slayerPoints);
 	}
 
 	/**
@@ -340,7 +316,7 @@ public final class SlayerManager {
 	 * @return the taskCount.
 	 */
 	public int getTaskCount() {
-		return taskCount;
+		return flags.getTaskStreak();
 	}
 
 	/**
@@ -348,15 +324,7 @@ public final class SlayerManager {
 	 * @param taskCount the taskCount to set
 	 */
 	public void setTaskCount(int taskCount) {
-		this.taskCount = taskCount;
+		flags.setTaskStreak(taskCount);
-	}
-
-	/**
-	 * Gets the learned.
-	 * @return the learned.
-	 */
-	public boolean[] getLearned() {
-		return learned;
 	}
 
 	/**
@@ -364,13 +332,13 @@ public final class SlayerManager {
 	 * @return the removed.
 	 */
 	public List<Tasks> getRemoved() {
-		return removed;
+		return flags.getRemoved();
 	}
 
-	public int getTotalTasks() {return taskTotal;}
+	public int getTotalTasks() {return flags.getCompletedTasks();}
 
 	public boolean isCanEarnPoints(){
-		return canEarnPoints;
+		return flags.canEarnPoints();
 	}
 
 }

Server/src/main/java/core/game/node/entity/skill/slayer/SlayerRewardPlugin.java

@@ -132,34 +132,34 @@ public class SlayerRewardPlugin extends ComponentPlugin {
 				break;
 			case 22://Broad arrows
 			case 29:
-				if (player.getSlayer().getLearned()[0]) {
+				if (player.getSlayer().flags.isBroadsUnlocked()) {
 					player.sendMessage("You don't need to learn this ability again.");
 					break;
 				}
 				if (purchase(player, 300)) {
-					player.getSlayer().getLearned()[0] = true;
+					player.getSlayer().flags.unlockBroads();
 					updateInterface(player, component);
 				}
 				break;
 			case 23://Slayer ring
 			case 30:
-				if (player.getSlayer().getLearned()[1]) {
+				if (player.getSlayer().flags.isRingUnlocked()) {
 					player.sendMessage("You don't need to learn this ability again.");
 					break;
 				}
 				if (purchase(player, 300)) {
-					player.getSlayer().getLearned()[1] = true;
+					player.getSlayer().flags.unlockRing();
 					updateInterface(player, component);
 				}
 				break;
 			case 24://Slayer helm
 			case 31:
-				if (player.getSlayer().getLearned()[2]) {
+				if (player.getSlayer().flags.isHelmUnlocked()) {
 					player.sendMessage("You don't need to learn this ability again.");
 					break;
 				}
 				if (purchase(player, 400)) {
-					player.getSlayer().getLearned()[2] = true;
+					player.getSlayer().flags.unlockHelm();
 					updateInterface(player, component);
 				}
 				break;
@@ -268,8 +268,20 @@ public class SlayerRewardPlugin extends ComponentPlugin {
 			player.getPacketDispatch().sendString(space + player.getSlayer().getSlayerPoints(), open.getId(), 19);
 			break;
 		case 163://learn
-			for (int i = 0; i < player.getSlayer().getLearned().length; i++) {
+			for (int i = 0; i < 3; i++) {
-				player.getPacketDispatch().sendInterfaceConfig(open.getId(), 25 + i, !player.getSlayer().getLearned()[i]);
+				switch(i){
+					case 0:
+						player.getPacketDispatch().sendInterfaceConfig(open.getId(), 25 + i, !player.getSlayer().flags.isBroadsUnlocked());
+						break;
+					case 1:
+						player.getPacketDispatch().sendInterfaceConfig(open.getId(), 25 + i, !player.getSlayer().flags.isRingUnlocked());
+						break;
+					case 2:
+						player.getPacketDispatch().sendInterfaceConfig(open.getId(), 25 + i, !player.getSlayer().flags.isHelmUnlocked());
+						break;
+					default:
+						break;
+				}
 			}
 			player.getPacketDispatch().sendString(space + player.getSlayer().getSlayerPoints(), open.getId(), 18);
 			break;
@@ -370,7 +382,7 @@ public class SlayerRewardPlugin extends ComponentPlugin {
 				player.sendMessage("You need a Crafting level of at least 55 in order to do this.");
 				return true;
 			}
-			if (!player.getSlayer().getLearned()[2]) {
+			if (!player.getSlayer().flags.isHelmUnlocked()) {
 				player.sendMessage("You need to unlock the ability to do that first.");
 				return true;
 			}

Server/src/main/kotlin/rs09/game/node/entity/player/info/login/PlayerSaver.kt

@@ -700,20 +700,6 @@ class PlayerSaver (val player: Player){
     fun saveSlayer(root: JSONObject){
         val slayer = JSONObject()
         val slayerManager = player.slayer
-        if(slayerManager.hasStarted()){
-            slayer.put("master",slayerManager.master.npc.toString())
-        }
-        if(slayerManager.hasTask()){
-            slayer.put("taskId",slayerManager.task.ordinal.toString())
-            slayer.put("taskAmount",slayerManager.amount.toString())
-        }
-        slayer.put("points",slayerManager.slayerPoints.toString())
-        slayer.put("taskStreak",slayerManager.taskCount.toString())
-        val learnedRewards = JSONArray()
-        slayerManager.learned.map {
-            learnedRewards.add(it)
-        }
-        slayer.put("learned_rewards",learnedRewards)
         if(slayerManager.removed.isNotEmpty()) {
             val removedTasks = JSONArray()
             slayerManager.removed.map {
@@ -721,9 +707,11 @@ class PlayerSaver (val player: Player){
             }
             slayer.put("removedTasks",removedTasks)
         }
+        slayer.put("taskStreak",slayerManager.taskCount.toString())
         slayer.put("totalTasks",slayerManager.totalTasks.toString())
-        slayer.put("canEarnPoints",slayerManager.isCanEarnPoints)
+        slayer.put("equipmentFlags",slayerManager.flags.equipmentFlags)
-        slayer.put("equipmentFlags",slayerManager.equipmentFlags)
+        slayer.put("taskFlags", slayerManager.flags.taskFlags)
+        slayer.put("rewardFlags", slayerManager.flags.rewardFlags)
         root.put("slayer",slayer)
     }
 

Server/src/main/kotlin/rs09/game/node/entity/skill/slayer/SlayerFlags.kt

@@ -0,0 +1,152 @@
+package rs09.game.node.entity.skill.slayer
+
+import core.game.node.entity.player.Player
+import core.game.node.entity.skill.slayer.Master
+import core.game.node.entity.skill.slayer.Tasks
+
+/**
+ * Bitflag-based system for storing slayer-related data for a player and various helper functions.
+ * @author Ceikry
+ */
+class SlayerFlags(val player: Player) {
+    var taskFlags = 0
+    var rewardFlags = 0
+    var equipmentFlags = 0
+    var completedTasks = 0
+    var taskStreak = 0
+
+    /**
+     * The removed tasks.
+     */
+    val removed: List<Tasks> = ArrayList(4)
+
+    /**
+     * Get/set master flags
+     */
+    fun getMaster(): Master {
+        val ordinal = taskFlags and 0xF
+        return Master.values()[ordinal]
+    }
+
+    fun setMaster(master: Master){
+        taskFlags = (taskFlags - (taskFlags and 0xF)) or master.ordinal
+    }
+
+    /**
+     *==============================================
+     */
+
+
+    /**
+     * Get/set task flags
+     */
+    fun getTask(): Tasks {
+        val ordinal = (taskFlags shr 4) and 0x7F
+        return Tasks.values()[ordinal]
+    }
+
+    fun setTask(tasks: Tasks){
+        taskFlags = (taskFlags - (getTask().ordinal shl 4)) or (tasks.ordinal shl 4)
+    }
+
+    /**
+     *==============================================
+     */
+
+    /**
+     * Get/set/decrement task amount flag
+     */
+    fun getTaskAmount(): Int {
+        return (taskFlags shr 11) and 0xFF
+    }
+
+    fun setTaskAmount(amount: Int) {
+        taskFlags = (taskFlags - (getTaskAmount() shl 11)) or (amount shl 11)
+    }
+
+    fun decrementTaskAmount(amount: Int){
+        setTaskAmount(getTaskAmount() - amount)
+    }
+    /**
+     *==============================================
+     */
+
+    /**
+     * Get/Set canEarnPoints flag
+     */
+    fun canEarnPoints(): Boolean {
+        return (taskFlags shr 16) and 1 == 1
+    }
+
+    fun flagCanEarnPoints() {
+        taskFlags = taskFlags or (1 shl 16)
+    }
+    /**
+     *==============================================
+     */
+
+    /**
+     * Get/set reward unlock flags
+     */
+    fun isBroadsUnlocked(): Boolean{
+        return rewardFlags and 1 == 1
+    }
+
+    fun unlockBroads() {
+        rewardFlags = rewardFlags or 1
+    }
+
+    fun isRingUnlocked(): Boolean {
+        return (rewardFlags shr 1) and 1 == 1
+    }
+
+    fun unlockRing() {
+        rewardFlags = rewardFlags or (1 shl 1)
+    }
+
+    fun isHelmUnlocked(): Boolean {
+        return (rewardFlags shr 2) and 1 ==1
+    }
+
+    fun unlockHelm() {
+        rewardFlags = rewardFlags or (1 shl 2)
+    }
+
+    /**
+     *==============================================
+     */
+
+    /**
+     * Get/set/increment points flag
+     */
+    fun setPoints(amount: Int) {
+        rewardFlags = (rewardFlags - (getPoints() shl 15)) or (amount shl 15)
+    }
+
+    fun getPoints(): Int {
+        return (rewardFlags shr 15) and 0xFFFF
+    }
+
+    fun incrementPoints(amount: Int){
+        setPoints(getPoints() + amount)
+    }
+    /**
+     *==============================================
+     */
+
+    /**
+     * Reset task and task amount to 0
+     */
+    fun clearTask() {
+        setTask(Tasks.values()[0])
+        setTaskAmount(0)
+    }
+
+    /**
+     * Checks if we have a task
+     */
+    fun hasTask(): Boolean{
+        return getTaskAmount() != 0
+    }
+
+}