More work on the new player knowledge system - getting close

src/main/java/com/pahimar/ee3/EquivalentExchange3.java

@@ -123,7 +123,7 @@ public class EquivalentExchange3
         EnergyValueRegistry.INSTANCE.save();
 
         TransmutationKnowledgeRegistry.getInstance().clear();
-        PlayerKnowledgeRegistry.INSTANCE.save();
+        PlayerKnowledgeRegistry.INSTANCE.saveAll();
 
         AbilityRegistry.getInstance().save();
     }

src/main/java/com/pahimar/ee3/knowledge/PlayerKnowledge.java

@@ -33,7 +33,12 @@ public class PlayerKnowledge {
     }
 
     public boolean isKnown(ItemStack itemStack) {
-        return knownItemStacks.contains(ItemHelper.clone(itemStack, 1));
+
+        if (itemStack != null) {
+            return knownItemStacks.contains(ItemHelper.clone(itemStack, 1));
+        }
+
+        return false;
     }
 
     public Set<ItemStack> getKnownItemStacks() {
@@ -50,8 +55,10 @@ public class PlayerKnowledge {
 
     public void learn(Collection<ItemStack> itemStacks) {
 
-        for (ItemStack itemStack : itemStacks) {
+        if (itemStacks != null) {
-            learn(itemStack);
+            for (ItemStack itemStack : itemStacks) {
+                learn(itemStack);
+            }
         }
     }
 
@@ -65,8 +72,10 @@ public class PlayerKnowledge {
 
     public void forget(Collection<ItemStack> itemStacks) {
 
-        for (ItemStack itemStack : itemStacks) {
+        if (itemStacks != null) {
-            forget(itemStack);
+            for (ItemStack itemStack : itemStacks) {
+                forget(itemStack);
+            }
         }
     }
 

src/main/java/com/pahimar/ee3/knowledge/PlayerKnowledgeRegistry.java

@@ -1,6 +1,7 @@
 package com.pahimar.ee3.knowledge;
 
 import com.google.gson.JsonSyntaxException;
+import com.pahimar.ee3.api.knowledge.AbilityRegistryProxy;
 import com.pahimar.ee3.handler.ConfigurationHandler;
 import com.pahimar.ee3.reference.Comparators;
 import com.pahimar.ee3.reference.Files;
@@ -8,11 +9,11 @@ import com.pahimar.ee3.util.SerializationHelper;
 import cpw.mods.fml.common.FMLCommonHandler;
 import cpw.mods.fml.relauncher.Side;
 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
 
 import java.io.File;
 import java.io.FileNotFoundException;
+import java.util.Collection;
 import java.util.TreeMap;
 
 public class PlayerKnowledgeRegistry {
@@ -22,36 +23,138 @@ public class PlayerKnowledgeRegistry {
     private final TreeMap<String, PlayerKnowledge> playerKnowledgeMap;
     private final PlayerKnowledge templatePlayerKnowledge;
 
-    private static final String TEMPLATE_PLAYER_KNOWLEDGE_FILEPATH = "knowledge" + File.separator + "transmutation" + Files.TEMPLATE_JSON_FILENAME;
     public static File templatePlayerKnowledgeFile;
 
     private PlayerKnowledgeRegistry() {
 
         playerKnowledgeMap = new TreeMap<>(Comparators.STRING_COMPARATOR);
         templatePlayerKnowledge = new PlayerKnowledge();
-
-        // Init some data for testing
-        PlayerKnowledge playerKnowledge = new PlayerKnowledge();
-        playerKnowledge.learn(new ItemStack(Items.apple));
-        playerKnowledge.learn(new ItemStack(Items.arrow));
-        playerKnowledge.learn(new ItemStack(Items.baked_potato));
-        playerKnowledge.learn(new ItemStack(Items.blaze_powder));
-        playerKnowledge.learn(new ItemStack(Items.blaze_rod));
-        playerKnowledge.learn(new ItemStack(Items.chainmail_boots));
-        playerKnowledge.learn(new ItemStack(Items.carrot));
-        playerKnowledge.learn(new ItemStack(Items.carrot_on_a_stick));
-        playerKnowledge.learn(new ItemStack(Items.chainmail_boots));
-        playerKnowledgeMap.put("pahimar", playerKnowledge);
     }
 
-    /**
+    public PlayerKnowledge getTemplatePlayerKnowledge() {
-     *
+        return templatePlayerKnowledge;
-     *  doesKnow
+    }
-     *  canLearn
+
-     *  teach
+    public boolean doesPlayerKnow(EntityPlayer player, ItemStack itemStack) {
-     *  makeForget
+
-     *  makeForgetAll
+        if (player != null) {
-     */
+            return doesPlayerKnow(player.getDisplayName(), itemStack);
+        }
+
+        return false;
+    }
+
+    public boolean doesPlayerKnow(String playerName, ItemStack itemStack) {
+
+        if (getPlayerKnowledge(playerName) != null) {
+            return getPlayerKnowledge(playerName).isKnown(itemStack);
+        }
+
+        return false;
+    }
+
+    public boolean canPlayerLearn(EntityPlayer entityPlayer, ItemStack itemStack) {
+
+        if (entityPlayer != null) {
+            return canPlayerLearn(entityPlayer.getDisplayName(), itemStack);
+        }
+
+        return false;
+    }
+
+    public boolean canPlayerLearn(String playerName, ItemStack itemStack) {
+
+        if (getPlayerKnowledge(playerName) != null) {
+            return !getPlayerKnowledge(playerName).isKnown(itemStack) && AbilityRegistryProxy.isLearnable(itemStack);
+        }
+
+        return false;
+    }
+
+    public void teachPlayer(EntityPlayer entityPlayer, ItemStack itemStack) {
+
+        if (entityPlayer != null) {
+            teachPlayer(entityPlayer.getDisplayName(), itemStack);
+        }
+    }
+
+    public void teachPlayer(String playerName, ItemStack itemStack) {
+
+        if (itemStack != null && getPlayerKnowledge(playerName) != null) {
+            getPlayerKnowledge(playerName).learn(itemStack);
+            save(playerName);
+        }
+    }
+
+    public void teachPlayer(EntityPlayer entityPlayer, Collection<ItemStack> itemStacks) {
+
+        if (entityPlayer != null) {
+            teachPlayer(entityPlayer.getDisplayName(), itemStacks);
+        }
+    }
+
+    public void teachPlayer(String playerName, Collection<ItemStack> itemStacks) {
+
+        if (itemStacks != null) {
+
+            PlayerKnowledge playerKnowledge = getPlayerKnowledge(playerName);
+
+            if (playerKnowledge != null) {
+                itemStacks.forEach(playerKnowledge::learn);
+                save(playerName);
+            }
+        }
+    }
+
+    public void makePlayerForget(EntityPlayer entityPlayer, ItemStack itemStack) {
+
+        if (entityPlayer != null) {
+            makePlayerForget(entityPlayer.getDisplayName(), itemStack);
+        }
+    }
+
+    public void makePlayerForget(String playerName, ItemStack itemStack) {
+
+        if (getPlayerKnowledge(playerName) != null) {
+            getPlayerKnowledge(playerName).forget(itemStack);
+            save(playerName);
+        }
+    }
+
+    public void makePlayerForget(EntityPlayer entityPlayer, Collection<ItemStack> itemStacks) {
+
+        if (entityPlayer != null) {
+            makePlayerForget(entityPlayer.getDisplayName(), itemStacks);
+        }
+    }
+
+    public void makePlayerForget(String playerName, Collection<ItemStack> itemStacks) {
+
+        if (itemStacks != null) {
+
+            PlayerKnowledge playerKnowledge = getPlayerKnowledge(playerName);
+
+            if (playerKnowledge != null) {
+                itemStacks.forEach(playerKnowledge::forget);
+                save(playerName);
+            }
+        }
+    }
+
+    public void makePlayerForgetAll(EntityPlayer entityPlayer) {
+
+        if (entityPlayer != null) {
+            makePlayerForgetAll(entityPlayer.getDisplayName());
+        }
+    }
+
+    public void makePlayerForgetAll(String playerName) {
+
+        if (playerName != null && !playerName.isEmpty()) {
+            playerKnowledgeMap.put(playerName, new PlayerKnowledge());
+            save(playerName);
+        }
+    }
 
     /**
      * TODO Finish JavaDoc
@@ -64,9 +167,8 @@ public class PlayerKnowledgeRegistry {
         if (entityPlayer != null) {
             return getPlayerKnowledge(entityPlayer.getDisplayName());
         }
-        else {
+
-            throw new IllegalArgumentException("EntityPlayer must be non-null");
+        return null;
-        }
     }
 
     /**
@@ -80,20 +182,19 @@ public class PlayerKnowledgeRegistry {
         // TODO Logging
         if (playerName != null && !playerName.isEmpty()) {
             if (!playerKnowledgeMap.containsKey(playerName)) {
-                playerKnowledgeMap.put(playerName, load(getPlayerKnowledgeFile(playerName)));
+                playerKnowledgeMap.put(playerName, load(getPlayerKnowledgeFile(playerName), false));
             }
 
             return playerKnowledgeMap.get(playerName);
         }
-        else {
+
-            throw new IllegalArgumentException("Invalid player name - must not be null and must be longer than 0 characters");
+        return null;
-        }
     }
 
     /**
      * TODO Finish JavaDoc
      */
-    public void save() {
+    public void saveAll() {
 
         if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) {
 
@@ -102,11 +203,23 @@ public class PlayerKnowledgeRegistry {
 
             // Save every currently loaded player knowledge to file
             for (String playerName : playerKnowledgeMap.keySet()) {
-                if (playerName != null && !playerName.isEmpty()) {
+                save(playerName);
-                    File playerKnowledgeFile = getPlayerKnowledgeFile(playerName);
+            }
-                    if (playerKnowledgeFile != null) {
+        }
-                        SerializationHelper.writeJsonFile(playerKnowledgeFile, SerializationHelper.GSON.toJson(playerKnowledgeMap.get(playerName)));
+    }
-                    }
+
+    /**
+     * TODO Finish JavaDoc
+     *
+     * @param playerName
+     */
+    private void save(String playerName) {
+
+        if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) {
+            if (playerName != null && !playerName.isEmpty()) {
+                File playerKnowledgeFile = getPlayerKnowledgeFile(playerName);
+                if (playerKnowledgeFile != null) {
+                    SerializationHelper.writeJsonFile(playerKnowledgeFile, SerializationHelper.GSON.toJson(playerKnowledgeMap.get(playerName)));
                 }
             }
         }
@@ -119,7 +232,12 @@ public class PlayerKnowledgeRegistry {
 
         // Load template knowledge
         if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) {
-            // FIXME Priority Number 2
+
+            templatePlayerKnowledge.forgetAll();
+            templatePlayerKnowledge.learn(load(templatePlayerKnowledgeFile, true).getKnownItemStacks());
+
+            // Reset the player knowledge map
+            playerKnowledgeMap.clear();
         }
     }
 
@@ -129,7 +247,7 @@ public class PlayerKnowledgeRegistry {
      * @param file
      * @return
      */
-    private PlayerKnowledge load(File file) {
+    private PlayerKnowledge load(File file, boolean isTemplate) {
 
         if (file != null) {
             try {
@@ -144,7 +262,7 @@ public class PlayerKnowledgeRegistry {
             }
         }
 
-        if (ConfigurationHandler.Settings.playerKnowledgeTemplateEnabled) {
+        if (ConfigurationHandler.Settings.playerKnowledgeTemplateEnabled && !isTemplate) {
             return new PlayerKnowledge(templatePlayerKnowledge);
         }
         else {
@@ -163,8 +281,7 @@ public class PlayerKnowledgeRegistry {
         if (playerName != null && !playerName.isEmpty()) {
             return new File(Files.playerDataDirectory, "knowledge" + File.separator + "transmutation" + File.separator + playerName + ".json");
         }
-        else {
+
-            throw new IllegalArgumentException("Invalid player name - must not be null and must be longer than 0 characters");
+        return null;
-        }
     }
 }