Thread: Collection Log Base

There are things that can be done better. I track all npcs and their drops that's why you see a separate statement for them.

Code:

package com.elvarg.game.content.collectionlog;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;

import com.elvarg.game.World;
import com.elvarg.game.content.KillTrackManager;
import com.elvarg.game.content.NpcDropTableViewer;
import com.elvarg.game.definition.NpcDefinition;
import com.elvarg.game.definition.drop.NpcDropDefinition;
import com.elvarg.game.definition.drop.NpcDropLoader;
import com.elvarg.game.entity.impl.player.Player;
import com.elvarg.game.model.Item;
import com.elvarg.game.model.JsonIO;
import com.elvarg.net.packet.interaction.PacketInteraction;
import com.elvarg.util.Misc;
import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.reflect.TypeToken;

public class CollectionLogManager extends PacketInteraction {

	public static final Type REFERENCE = new TypeToken<HashMap<CollectionLogType, HashMap<String, HashMap<Integer, Integer>>>>() {
	}.getType();

	public HashMap<CollectionLogType, HashMap<String, HashMap<Integer, Integer>>> log = new HashMap<>();

	public static final JsonIO IO = new JsonIO("./data/saves/collectionlog/") {

		@Override
		public void init(String name, Gson builder, JsonObject reader) {
			JsonElement element = reader.get("log");

			HashMap<CollectionLogType, HashMap<String, HashMap<Integer, Integer>>> log = GSON
					.fromJson(element.toString(), REFERENCE);

			Optional<Player> p = World.getPlayerByName(name);

			if (!p.isPresent()) {
				return;
			}

			p.get().getCollectionLog().log = log;
		}

		@Override
		public JsonObject save(String name, Gson builder, JsonObject object) {

			Optional<Player> p = World.getPlayerByName(name);

			if (!p.isPresent()) {
				return object;
			}

			object.add("log", builder.toJsonTree(p.get().getCollectionLog().log, REFERENCE));
			return object;
		}
	};

	private CollectionLogType viewingType;

	public static void open(Player player, CollectionLogType type) {

		int line = 34_371;

		if (type.equals(CollectionLogType.BOSSES)) {
			int slot = 1;

			for (String s : NpcDropTableViewer.SORTED_NAME_LIST) {
				player.getPacketSender().sendString(line, (slot++) + ". " + s);
				line += 4;
			}
		} else {
			if (type.log == null) {
				return;
			}
			for (CollectionLog log : type.log) {
				player.getPacketSender().sendString(line, log.name);
				line += 4;
			}
		}

		player.getPacketSender().sendConfig(833, type.ordinal());

		int size = (line - 34_371) / 4;

		player.getPacketSender().sendScrollbarHeight(34367, size * 15);

		player.getPacketSender().clearInterfaceText(line, 35_371);

		player.getCollectionLog().viewingType = type;

		player.getPacketSender().sendInterface(34_343);
	}

	private static void viewType(Player player, int index) {
		if (player.getCollectionLog().viewingType == null) {
			return;
		}

		CollectionLogType type = player.getCollectionLog().viewingType;

		if (type.equals(CollectionLogType.BOSSES)) {
			String name = NpcDropTableViewer.SORTED_NAME_LIST.get(index);

			NpcDropDefinition drop = NpcDropLoader.FOR_NAME.get(name);

			if (drop == null) {
				return;
			}

			ArrayList<Item> droptable = NpcDropLoader.FOR_NAME_COLLECTION_LOG.get(name);

			Set<Entry<Integer, Integer>> log = getLog(player, type, name);

			int obtained = 0;

			if (log != null) {
				for (Entry<Integer, Integer> s : log) {
					droptable.add(new Item(s.getKey(), s.getValue()));
				}
				obtained = log.size();
			}

			player.getPacketSender().sendString(34_348, name);

			player.getPacketSender().sendString(34_349, "Obtained: @[email protected]" + obtained + "/" + droptable.size());

			int kills = KillTrackManager.getKills(player, name);

			player.getPacketSender().sendString(34_350, "Kills: @[email protected]" + kills);

			player.getPacketSender().sendCollectionLog(droptable, 34366);
		} else {
			player.getPacketSender().sendString(34_348, Misc.ucFirst(type.log[index].name));

			Set<Entry<Integer, Integer>> log = getLog(player, type, type.log[index].name);

			ArrayList<Item> droptable = new ArrayList<Item>();

			for (Item item : type.log[index].items) {
				droptable.add(new Item(item.getId(), 0));
			}

			int obtained = 0;

			if (log != null) {
				for (Entry<Integer, Integer> s : log) {
					droptable.add(new Item(s.getKey(), s.getValue()));
				}
				obtained = log.size();
			}

			player.getPacketSender().sendString(34_349,
					"Obtained: @[email protected]" + obtained + "/" + type.log[index].items.size());

			player.getPacketSender().sendString(34_350, "");

			player.getPacketSender().sendCollectionLog(droptable, 34366);
		}
	}

	public static void track(Player player, CollectionLogType type, String s, Item item) {
		if (player.getCollectionLog().log.get(type) == null) {
			player.getCollectionLog().log.put(type, new HashMap<String, HashMap<Integer, Integer>>());
		}

		if (player.getCollectionLog().log.get(type).get(s) == null) {
			player.getCollectionLog().log.get(type).put(s, new HashMap<Integer, Integer>());
		}

		player.getCollectionLog().log.get(type).get(s).merge(item.getId(), item.getAmount(), Integer::sum);

		IO.save(player.getUsername());
	}

	public static void trackBoss(Player player, int id, Item item) {
		NpcDefinition def = NpcDefinition.forId(id);

		if (def == null) {
			return;
		}

		track(player, CollectionLogType.BOSSES, def.getName(), item);
	}

	private static Set<Entry<Integer, Integer>> getLog(Player player, CollectionLogType type, String s) {
		if (player.getCollectionLog().log.get(type) == null) {
			return null;
		}

		if (player.getCollectionLog().log.get(type).get(s) == null) {
			return null;
		}

		return player.getCollectionLog().log.get(type).get(s).entrySet();
	}

	@Override
	public boolean handleButtonInteraction(Player player, int button) {
		if (button >= 34_368 && button <= 35_612) {
			int index = button - 34_368;

			if (index > 0) {
				index /= 4;
			}

			viewType(player, index);
			return true;
		}

		switch (button) {
		case 33_689:
		case 34352:
			open(player, CollectionLogType.BOSSES);
			return true;
		case 34353:
			open(player, CollectionLogType.RAIDS);
			return true;
		case 34354:
			open(player, CollectionLogType.CLUES);
			return true;
		case 34355:
			open(player, CollectionLogType.MINIGAMES);
			return true;
		case 34356:
			open(player, CollectionLogType.OTHER);
			return true;
		}
		return false;
	}
}

Code:

package com.elvarg.game.content.collectionlog;

import java.util.ArrayList;

import com.elvarg.game.model.Item;

public class CollectionLog {

	public String name;

	public ArrayList<Item> items;

	public CollectionLog(String name) {
		this.name = name;
		this.items = new ArrayList<Item>();
	}
	
	public CollectionLog add(Item item) {
		this.items.add(item);
		return this;
	}
}

Code:

package com.elvarg.game.content.collectionlog;

import com.elvarg.game.model.Item;

public enum CollectionLogType {

	BOSSES(),

	RAIDS(),

	CLUES(),

	MINIGAMES(new CollectionLog[] {

	}),

	OTHER(new CollectionLog[] { new CollectionLog("Hello").add(new Item(4151)).add(new Item(4153)), }),

	;

	public CollectionLog[] log;

	CollectionLogType(CollectionLog[] log) {
		this.log = log;
	}

	CollectionLogType() {

	}
}

Additional classes may be required:

Code:

package com.elvarg.game.model;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.lang.reflect.Type;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.logging.Level;

import com.elvarg.Server;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.reflect.TypeToken;

public abstract class JsonIO {

	public static final Type HASH_STRING_INTEGER = new TypeToken<HashMap<String, Integer>>() {
	}.getType();

	public static final Gson GSON = new Gson();

	private String location;

	public String name;

	public JsonIO(String location, String name) {
		this.location = location;
		this.name = name;
	}

	public JsonIO(String location) {
		this(location, "");
	}

	public abstract void init(String name, Gson builder, JsonObject reader);

	public abstract JsonObject save(String name, Gson builder, JsonObject object);

	public void initAll() {
		File[] files = new File(location).listFiles();

		if (files.length == 0) {
			return;
		}

		for (File f : files) {
			if (f == null) {
				continue;
			}
			init(f.getName().replaceAll(".json", ""));
		}

		System.out.println("Init directory: " + location + ". Found: " + files.length + " files.");
	}

	public void init() {
		init(name);
	}

	public void init(String name) {

		final Path path = Paths.get(location + "" + name + ".json");
		final File file = path.toFile();

		if (!file.exists()) {
			return;
		}

		try (FileReader fileReader = new FileReader(file)) {
			final JsonParser fileParser = new JsonParser();
			final Gson builder = new GsonBuilder().create();
			final JsonObject reader = (JsonObject) fileParser.parse(fileReader);

			init(name, builder, reader);

		} catch (final Exception e) {
			e.printStackTrace();
		}
	}

	public void saveFile(String file) {
		save(name + "/" + file);
	}

	public void save() {
		save(name);
	}

	public void save(String name) {
		final Path path = Paths.get(location + "" + name + ".json");
		final File file = path.toFile();
		

		if (!file.getParentFile().exists()) {
			try {
				file.getParentFile().mkdirs();
			} catch (final SecurityException e) {
			}
		}file.getParentFile().setWritable(true);
		try (FileWriter writer = new FileWriter(file)) {

			final Gson builder = new GsonBuilder().setPrettyPrinting().create();
			final JsonObject object = new JsonObject();

			writer.write(builder.toJson(save(name, builder, object)));
			writer.close();

		} catch (final Exception e) {
			Server.getLogger().log(Level.WARNING,
					"An error has occured while saving " + location + " " + name + " file!", e);
		}
	}

	public String getFile() {
		return location + "" + name + ".json";
	}
}

I have a custom system for interfaces

Code:

package com.runescape.cache.graphics.widget.impl;

import com.runescape.cache.graphics.widget.custom.CustomWidget;

public class CollectionLogWidget extends CustomWidget {

	private static final String[] TYPES = { "Bosses", "Raids", "Clues", "Minigames", "Other", };

	public CollectionLogWidget() {
		super(34_343);
	}

	@Override
	public String getName() {
		return "Collection Log";
	}

	@Override
	public void init() {
		addBackground(882);
		add(addText("#", 2), 210, 68);
		add(addText("#", 0, 0xFFFFFF), 210, 88);
		add(addText("#", 0, 0xFFFFFF), 350, 88);
		add(addButtonConfigList(TYPES, 883, 884, 0, false, 833), 15, 45);
		add(addTextList(TYPES, 2, OR1, true, 96, false), -6, 48);
		add(addScrollbarWithItem(7, 10, 13, 0, new String[] {"Check KC"}, 211, 267), 212, 103);
		add(addScrollbarWithClickTextBackground("#", "Select", 0, OR1, 1390, 1391, 1392, 247, 174, 350), 15, 67);
	}

}

Sprites:
[Only registered and activated users can see links. ]