Player.java

  1. package com.jadventure.game.entities;

  3. import java.io.File;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileReader;
  6. import java.io.FileWriter;
  7. import java.io.IOException;
  8. import java.io.Reader;
  9. import java.io.Writer;
  10. import java.nio.file.Files;
  11. import java.nio.file.Path;
  12. import java.nio.file.Paths;
  13. import java.nio.file.StandardCopyOption;
  14. import java.util.ArrayList;
  15. import java.util.HashMap;
  16. import java.util.Iterator;
  17. import java.util.List;
  18. import java.util.Map;
  19. import java.util.Map.Entry;
  20. import java.util.Random;
  21. import java.util.Set;

  23. import com.google.gson.Gson;
  24. import com.google.gson.JsonArray;
  25. import com.google.gson.JsonElement;
  26. import com.google.gson.JsonObject;
  27. import com.google.gson.JsonParser;
  28. import com.google.gson.JsonArray;
  29. import com.google.gson.JsonPrimitive;
  30. import com.google.gson.reflect.TypeToken;
  31. import com.jadventure.game.DeathException;
  32. import com.jadventure.game.GameBeans;
  33. import com.jadventure.game.QueueProvider;
  34. import com.jadventure.game.items.Item;
  35. import com.jadventure.game.items.ItemStack;
  36. import com.jadventure.game.items.Storage;
  37. import com.jadventure.game.menus.BattleMenu;
  38. import com.jadventure.game.monsters.Monster;
  39. import com.jadventure.game.navigation.Coordinate;
  40. import com.jadventure.game.navigation.ILocation;
  41. import com.jadventure.game.navigation.LocationType;
  42. import com.jadventure.game.repository.ItemRepository;
  43. import com.jadventure.game.repository.LocationRepository;

  45. /**
  46.  * This class deals with the player and all of its properties.
  47.  * Any method that changes a character or interacts with it should
  48.  * be placed within this class. If a method deals with entities in general or
  49.  * with variables not unique to the player, place it in the entity class.
  50.  */
  51. public class Player extends Entity {
  52.     // @Resource
  53.     protected static ItemRepository itemRepo = GameBeans.getItemRepository();
  54.     protected static LocationRepository locationRepo = GameBeans.getLocationRepository();
  55.     private ILocation location;
  56.     private int xp;
  57.     /** Player type */
  58.     private String type;
  59.     private static HashMap<String, Integer>characterLevels = new HashMap<String, Integer>();

  61.     public Player() {
  62.     }

  64.     protected static void setUpCharacterLevels() {
  65.         characterLevels.put("Sewer Rat", 5);
  66.         characterLevels.put("Recruit", 3);
  67.         characterLevels.put("Syndicate Member", 4);
  68.         characterLevels.put("Brotherhood Member", 4);
  69.     }

  71.     public HashMap<String, Integer> getCharacterLevels() {
  72.         return characterLevels;
  73.     }

  75.     public void setCharacterLevels(HashMap<String, Integer> newCharacterLevels) {
  76.         this.characterLevels = newCharacterLevels;
  77.     }

  79.     public String getCurrentCharacterType() {
  80.         return this.type;
  81.     }
  82.     
  83.     public void setCurrentCharacterType(String newCharacterType) {
  84.         this.type = newCharacterType;
  85.     }

  87.     public void setCharacterLevel(String characterType, int level) {
  88.         this.characterLevels.put(characterType, level);
  89.     }

  91.     public int getCharacterLevel(String characterType) {
  92.         int characterLevel = this.characterLevels.get(characterType);
  93.         return characterLevel;
  94.     }

  96.     protected static String getProfileFileName(String name) {
  97.         return "json/profiles/" + name + "/" + name + "_profile.json";
  98.     }

  100.     public static boolean profileExists(String name) {
  101.         File file = new File(getProfileFileName(name));
  102.         return file.exists();
  103.     }

  105.     public static Player load(String name) {
  106.         player = new Player();
  107.         JsonParser parser = new JsonParser();
  108.         String fileName = getProfileFileName(name);
  109.         try {
  110.             Reader reader = new FileReader(fileName);
  111.             JsonObject json = parser.parse(reader).getAsJsonObject();
  112.             player.setName(json.get("name").getAsString());
  113.             player.setHealthMax(json.get("healthMax").getAsInt());
  114.             player.setHealth(json.get("health").getAsInt());
  115.             player.setArmour(json.get("armour").getAsInt());
  116.             player.setDamage(json.get("damage").getAsInt());
  117.             player.setLevel(json.get("level").getAsInt());
  118.             player.setXP(json.get("xp").getAsInt());
  119.             player.setStrength(json.get("strength").getAsInt());
  120.             player.setIntelligence(json.get("intelligence").getAsInt());
  121.             player.setDexterity(json.get("dexterity").getAsInt());
  122.             player.setLuck(json.get("luck").getAsInt());
  123.             player.setStealth(json.get("stealth").getAsInt());
  124.             player.setCurrentCharacterType(json.get("type").getAsString());
  125.             HashMap<String, Integer> charLevels = new Gson().fromJson(json.get("types"), new TypeToken<HashMap<String, Integer>>(){}.getType());
  126.             player.setCharacterLevels(charLevels);
  127.             if (json.has("equipment")) {
  128.                 Map<String, EquipmentLocation> locations = new HashMap<>();
  129.                 locations.put("head", EquipmentLocation.HEAD);
  130.                 locations.put("chest", EquipmentLocation.CHEST);
  131.                 locations.put("leftArm", EquipmentLocation.LEFT_ARM);
  132.                 locations.put("leftHand", EquipmentLocation.LEFT_HAND);
  133.                 locations.put("rightArm", EquipmentLocation.RIGHT_ARM);
  134.                 locations.put("rightHand", EquipmentLocation.RIGHT_HAND);
  135.                 locations.put("bothHands", EquipmentLocation.BOTH_HANDS);
  136.                 locations.put("bothArms", EquipmentLocation.BOTH_ARMS);
  137.                 locations.put("legs", EquipmentLocation.LEGS);
  138.                 locations.put("feet", EquipmentLocation.FEET);
  139.                 HashMap<String, String> equipment = new Gson().fromJson(json.get("equipment"), new TypeToken<HashMap<String, String>>(){}.getType());
  140.                Map<EquipmentLocation, Item> equipmentMap = new HashMap<>();
  141.                for(Map.Entry<String, String> entry : equipment.entrySet()) {
  142.                    EquipmentLocation el = locations.get(entry.getKey());
  143.                    Item i = itemRepo.getItem(entry.getValue());
  144.                    equipmentMap.put(el, i);
  145.                }
  146.                player.setEquipment(equipmentMap);
  147.             }
  148.             if (json.has("items")) {
  149.                 HashMap<String, Integer> items = new Gson().fromJson(json.get("items"), new TypeToken<HashMap<String, Integer>>(){}.getType());
  150.                 ArrayList<ItemStack> itemList = new ArrayList<>();
  151.                 for (Map.Entry<String, Integer> entry : items.entrySet()) {
  152.                     String itemID = entry.getKey();
  153.                     int amount = entry.getValue();
  154.                     Item item = itemRepo.getItem(itemID);
  155.                     ItemStack itemStack = new ItemStack(amount, item);
  156.                     itemList.add(itemStack);
  157.                 }
  158.                 float maxWeight = (float)Math.sqrt(player.getStrength()*300);
  159.                 player.setStorage(new Storage(maxWeight, itemList));
  160.             }
  161.             Coordinate coordinate = new Coordinate(json.get("location").getAsString());
  162.             locationRepo = GameBeans.getLocationRepository(player.getName());
  163.             player.setLocation(locationRepo.getLocation(coordinate));
  164.             reader.close();
  165.             setUpCharacterLevels();
  166.         } catch (FileNotFoundException ex) {
  167.             QueueProvider.offer( "Unable to open file '" + fileName + "'.");
  168.         } catch (IOException ex) {
  169.             ex.printStackTrace();
  170.         }

  172.         return player;
  173.     }

  175.     // This is known as the singleton pattern. It allows for only 1 instance of a player.
  176.     private static Player player;
  177.     
  178.     public static Player getInstance(String playerClass){
  179.         player = new Player();
  180.         JsonParser parser = new JsonParser();
  181.         String fileName = "json/original_data/npcs.json";
  182.         try {
  183.             Reader reader = new FileReader(fileName);
  184.             JsonObject npcs = parser.parse(reader).getAsJsonObject().get("npcs").getAsJsonObject();
  185.             JsonObject json = new JsonObject();
  186.             for (Map.Entry<String, JsonElement> entry : npcs.entrySet()) {
  187.                 if (entry.getKey().equals(playerClass)) {
  188.                     json = entry.getValue().getAsJsonObject();
  189.                 }
  190.             }

  192.             player.setName(json.get("name").getAsString());
  193.             player.setHealthMax(json.get("healthMax").getAsInt());
  194.             player.setHealth(json.get("health").getAsInt());
  195.             player.setArmour(json.get("armour").getAsInt());
  196.             player.setDamage(json.get("damage").getAsInt());
  197.             player.setLevel(json.get("level").getAsInt());
  198.             player.setXP(json.get("xp").getAsInt());
  199.             player.setStrength(json.get("strength").getAsInt());
  200.             player.setIntelligence(json.get("intelligence").getAsInt());
  201.             player.setDexterity(json.get("dexterity").getAsInt());
  202.             setUpVariables(player);
  203.             JsonArray items = json.get("items").getAsJsonArray();
  204.             for (JsonElement item : items) {
  205.                 player.addItemToStorage(itemRepo.getItem(item.getAsString()));
  206.             }
  207.             Random rand = new Random();
  208.             int luck = rand.nextInt(3) + 1;
  209.             player.setLuck(luck);
  210.             player.setStealth(json.get("stealth").getAsInt());
  211.             player.setIntro(json.get("intro").getAsString());
  212.             if (player.getName().equals("Recruit")) {
  213.                 player.type = "Recruit";
  214.             } else if (player.getName().equals("Sewer Rat")) {
  215.                 player.type = "Sewer Rat";
  216.             } else {
  217.                 QueueProvider.offer("Not a valid class");
  218.             }
  219.             reader.close();
  220.             setUpCharacterLevels();
  221.         } catch (FileNotFoundException ex) {
  222.             QueueProvider.offer( "Unable to open file '" + fileName + "'.");
  223.         } catch (IOException ex) {
  224.             ex.printStackTrace();
  225.         }

  227.         return player;
  228.     } 

  230.     public int getXP() {
  231.         return xp;
  232.     }

  234.     public void setXP(int xp) {
  235.         this.xp = xp;
  236.     }

  238.     public static void setUpVariables(Player player) {
  239.         float maxWeight = (float)Math.sqrt(player.getStrength()*300);
  240.         player.setStorage(new Storage(maxWeight));
  241.     }

  243.     public void getStats(){
  244.         Item weapon = itemRepo.getItem(getWeapon());
  245.         String weaponName = weapon.getName();
  246.         if (weaponName.equals(null)) {
  247.             weaponName = "hands";
  248.         }
  249.         String message = "\nPlayer name: " + getName();
  250.               message += "\nType: " + type;
  251.               message += "\nCurrent weapon: " + weaponName;
  252.               message += "\nGold: " + getGold();
  253.               message += "\nHealth/Max: " + getHealth() + "/" + getHealthMax();
  254.               message += "\nDamage/Armour: " + getDamage() + "/" + getArmour();
  255.               message += "\nStrength: " + getStrength();
  256.               message += "\nIntelligence: " + getIntelligence();
  257.               message += "\nDexterity: " + getDexterity();
  258.               message += "\nLuck: " + getLuck();
  259.               message += "\nStealth: " + getStealth();
  260.               message += "\nXP: " + getXP();
  261.               message += "\n" + getName() + "'s level: " + getLevel();
  262.         QueueProvider.offer(message);
  263.     }

  265.     public void printBackPack() {
  266.         storage.display();
  267.     }

  269.     public void save() {
  270.         Gson gson = new Gson();
  271.         JsonObject jsonObject = new JsonObject();
  272.         jsonObject.addProperty("name", getName());
  273.         jsonObject.addProperty("healthMax", getHealthMax());
  274.         jsonObject.addProperty("health", getHealthMax());
  275.         jsonObject.addProperty("armour", getArmour());
  276.         jsonObject.addProperty("damage", getDamage());
  277.         jsonObject.addProperty("level", getLevel());
  278.         jsonObject.addProperty("xp", getXP());
  279.         jsonObject.addProperty("strength", getStrength());
  280.         jsonObject.addProperty("intelligence", getIntelligence());
  281.         jsonObject.addProperty("dexterity", getDexterity());
  282.         jsonObject.addProperty("luck", getLuck());
  283.         jsonObject.addProperty("stealth", getStealth());
  284.         jsonObject.addProperty("weapon", getWeapon());
  285.         jsonObject.addProperty("type", getCurrentCharacterType());
  286.         HashMap<String, Integer> items = new HashMap<String, Integer>();
  287.         for (ItemStack item : getStorage().getItemStack()) {
  288.             items.put(item.getItem().getId(), item.getAmount());
  289.         }
  290.         JsonElement itemsJsonObj = gson.toJsonTree(items);
  291.         jsonObject.add("items", itemsJsonObj);
  292.         Map<EquipmentLocation, String> locations = new HashMap<>();
  293.         locations.put(EquipmentLocation.HEAD, "head");
  294.         locations.put(EquipmentLocation.CHEST, "chest");
  295.         locations.put(EquipmentLocation.LEFT_ARM, "leftArm");
  296.         locations.put(EquipmentLocation.LEFT_HAND, "leftHand");
  297.         locations.put(EquipmentLocation.RIGHT_ARM, "rightArm");
  298.         locations.put(EquipmentLocation.RIGHT_HAND, "rightHand");
  299.         locations.put(EquipmentLocation.BOTH_HANDS, "BothHands");
  300.         locations.put(EquipmentLocation.BOTH_ARMS, "bothArms");
  301.         locations.put(EquipmentLocation.LEGS, "legs");
  302.         locations.put(EquipmentLocation.FEET, "feet");
  303.         HashMap<String, String> equipment = new HashMap<>();
  304.         Item hands = itemRepo.getItem("hands");
  305.         for (Map.Entry<EquipmentLocation, Item> item : getEquipment().entrySet()) {
  306.             if (item.getKey() != null && !hands.equals(item.getValue()) && item.getValue() != null) {
  307.                 equipment.put(locations.get(item.getKey()), item.getValue().getId());
  308.             }
  309.         }
  310.         JsonElement equipmentJsonObj = gson.toJsonTree(equipment);
  311.         jsonObject.add("equipment", equipmentJsonObj);
  312.         JsonElement typesJsonObj = gson.toJsonTree(getCharacterLevels());
  313.         jsonObject.add("types", typesJsonObj);
  314.         Coordinate coordinate = getLocation().getCoordinate();
  315.         String coordinateLocation = coordinate.x+","+coordinate.y+","+coordinate.z;
  316.         jsonObject.addProperty("location", coordinateLocation);

  318.         String fileName = getProfileFileName(getName());
  319.         new File(fileName).getParentFile().mkdirs();
  320.         try {
  321.             Writer writer = new FileWriter(fileName);
  322.             gson.toJson(jsonObject, writer);
  323.             writer.close();
  324.             locationRepo = GameBeans.getLocationRepository(getName());
  325.             locationRepo.writeLocations();
  326.             QueueProvider.offer("\nYour game data was saved.");
  327.         } catch (IOException ex) {
  328.             QueueProvider.offer("\nUnable to save to file '" + fileName + "'.");
  329.         }
  330.     }

  332.     public List<Item> searchItem(String itemName, List<Item> itemList) {
  333.         List<Item> items = new ArrayList<>();
  334.         for (Item item : itemList) {
  335.             String testItemName = item.getName();
  336.             if (testItemName.equalsIgnoreCase(itemName)) {
  337.                 items.add(item);
  338.             }
  339.         }
  340.         return items;
  341.     }

  343.     public List<Item> searchItem(String itemName, Storage storage) {
  344.         return storage.search(itemName);
  345.     }
  346.     
  347.     public List<Item> searchEquipment(String itemName, Map<EquipmentLocation, Item> equipment) {
  348.         List<Item> items = new ArrayList<>();
  349.         for (Item item : equipment.values()) {
  350.             if (item != null && item.getName().equals(itemName)) {
  351.                 items.add(item);
  352.             }
  353.         }
  354.         return items;
  355.     }

  357.     public void pickUpItem(String itemName) {
  358.         List<Item> items = searchItem(itemName, getLocation().getItems());
  359.         if (! items.isEmpty()) {
  360.             Item item = items.get(0);
  361.             addItemToStorage(item);
  362.             location.removeItem(item);
  363.             QueueProvider.offer(item.getName()+ " picked up");
  364.         }
  365.     }

  367.     public void dropItem(String itemName) {
  368.         List<Item> itemMap = searchItem(itemName, getStorage());
  369.         if (itemMap.isEmpty()) {
  370.             itemMap = searchEquipment(itemName, getEquipment());
  371.         }
  372.         if (!itemMap.isEmpty()) {
  373.             Item item = itemMap.get(0);
  374.             Item itemToDrop = itemRepo.getItem(item.getId());
  375.             Item weapon = itemRepo.getItem(getWeapon());
  376.             String wName = weapon.getName();

  378.             if (itemName.equals(wName)) {
  379.                 dequipItem(wName);
  380.             }
  381.             removeItemFromStorage(itemToDrop);
  382.             location.addItem(itemToDrop);
  383.             QueueProvider.offer(item.getName() + " dropped");
  384.         }
  385.     }

  387.     public void equipItem(String itemName) {
  388.         List<Item> items = searchItem(itemName, getStorage());
  389.         if (!items.isEmpty()) {
  390.             Item item = items.get(0);
  391.             if (getLevel() >= item.getLevel()) {
  392.                 Map<String, String> change = equipItem(item.getPosition(), item);
  393.                 QueueProvider.offer(item.getName()+ " equipped");
  394.                 printStatChange(change);
  395.             } else {
  396.                 QueueProvider.offer("You do not have the required level to use this item");
  397.             }
  398.         } else {
  399.             QueueProvider.offer("You do not have that item");
  400.         }
  401.     }

  403.     public void dequipItem(String itemName) {
  404.          List<Item> items = searchEquipment(itemName, getEquipment());
  405.          if (!items.isEmpty()) {
  406.             Item item = items.get(0);
  407.             Map<String, String> change = unequipItem(item);
  408.             QueueProvider.offer(item.getName()+" unequipped");
  409.             printStatChange(change);
  410.          }
  411.     }

  413.     private void printStatChange(Map<String, String> stats) {
  414.          Set<Entry<String, String>> set = stats.entrySet();
  415.          Iterator<Entry<String, String>> iter = set.iterator();
  416.          while (iter.hasNext()) {
  417.               Entry<String, String> me = iter.next();
  418.               double value = Double.parseDouble((String) me.getValue());
  419.               switch ((String) me.getKey()) {
  420.                   case "damage": {
  421.                           if (value >= 0.0) {
  422.                               QueueProvider.offer(me.getKey() + ": " + this.getDamage() + " (+" + me.getValue() + ")");
  423.                           } else {
  424.                               QueueProvider.offer(me.getKey() + ": " + this.getDamage() + " (" + me.getValue() + ")");
  425.                           }
  426.                           break;
  427.                     }
  428.                     case "health": {
  429.                           if (value >= 0) {
  430.                               QueueProvider.offer(me.getKey() + ": " + this.getHealth() + " (+" + me.getValue() + ")");
  431.                           } else {
  432.                               QueueProvider.offer(me.getKey() + ": " + this.getHealth() + " (" + me.getValue() + ")");
  433.                           }
  434.                           break;
  435.                     }
  436.                     case "armour": {
  437.                           if (value >= 0) {
  438.                               QueueProvider.offer(me.getKey() + ": " + this.getArmour() + " (+" + me.getValue() + ")");
  439.                           } else {
  440.                               QueueProvider.offer(me.getKey() + ": " + this.getArmour() + " (" + me.getValue() + ")");
  441.                           }
  442.                           break;
  443.                     }
  444.                     case "maxHealth": {
  445.                           if (value  >= 0) {
  446.                               QueueProvider.offer(me.getKey() + ": " + this.getHealthMax() + " (+" + me.getValue() + ")");
  447.                           } else {
  448.                               QueueProvider.offer(me.getKey() + ": " + this.getHealthMax() + " (" + me.getValue() + ")");
  449.                           }
  450.                           break;
  451.                     }
  452.               }
  453.          }
  454.     }

  456.     public void inspectItem(String itemName) {
  457.         List<Item> itemMap = searchItem(itemName, getStorage());
  458.         if (itemMap.isEmpty()) {
  459.             itemMap = searchItem(itemName, getLocation().getItems());
  460.         }
  461.         if (!itemMap.isEmpty()) {
  462.             Item item = itemMap.get(0);
  463.             item.display();
  464.         } else {
  465.             QueueProvider.offer("Item doesn't exist within your view.");
  466.         }
  467.     }

  469.     public ILocation getLocation() {
  470.         return location;
  471.     }

  473.     public void setLocation(ILocation location) {
  474.         this.location = location;
  475.     }

  477.     public LocationType getLocationType() {
  478.         return getLocation().getLocationType();
  479.     }

  481.     public void attack(String opponentName) throws DeathException {
  482.         Monster monsterOpponent = null;
  483.         NPC npcOpponent = null;
  484.         List<Monster> monsters = getLocation().getMonsters();
  485.         List<NPC> npcs = getLocation().getNpcs();
  486.         for (int i = 0; i < monsters.size(); i++) {
  487.              if (monsters.get(i).monsterType.equalsIgnoreCase(opponentName)) {
  488.                  monsterOpponent = monsters.get(i);
  489.              }
  490.         }
  491.         for (int i=0; i < npcs.size(); i++) {
  492.             if (npcs.get(i).getName().equalsIgnoreCase(opponentName)) {
  493.                 npcOpponent = npcs.get(i);
  494.             }
  495.         }
  496.         if (monsterOpponent != null) {
  497.             monsterOpponent.setName(monsterOpponent.monsterType);
  498.             new BattleMenu(monsterOpponent, this);
  499.         } else if (npcOpponent != null) {
  500.             new BattleMenu(npcOpponent, this);
  501.         } else {
  502.              QueueProvider.offer("Opponent not found");
  503.         }
  504.     }

  506.     public boolean hasItem(Item item) {
  507.         List<Item> searchEquipment = searchEquipment(item.getName(), getEquipment());
  508.         List<Item> searchStorage = searchItem(item.getName(), getStorage());
  509.         return !(searchEquipment.size() == 0 && searchStorage.size() == 0);
  510.     }
  511. }
Created with JaCoCo 0.8.1.201803210924