Initial Commit

Initial commit of project.

src/core/rpg/RPGArmor.java

@@ -0,0 +1,14 @@
+package core.rpg;
+
+public class RPGArmor extends RPGItem
+{
+	int defense;
+	
+	public RPGArmor() 
+	{
+		super("Tattered Clothes", "The remains of your first sewing project. You did a pretty good job!", 5);
+		defense = 1;
+	}
+	
+	public long GetDefense() { return defense; }
+}

src/core/rpg/RPGBattleContext.java

@@ -0,0 +1,11 @@
+package core.rpg;
+
+public class RPGBattleContext
+{
+	public RPGState stateRef;
+	
+	public RPGBattleContext(RPGState state)
+	{
+		this.stateRef = state;
+	}
+}

src/core/rpg/RPGCommand.java

@@ -0,0 +1,9 @@
+package core.rpg;
+
+public abstract class RPGCommand
+{
+	public RPGCommand() { }
+	
+	// OVERRIDE ME
+	public abstract String OnRun(RPGState state, RPGInput input);
+}

src/core/rpg/RPGEnemy.java

@@ -0,0 +1,9 @@
+package core.rpg;
+
+public class RPGEnemy extends RPGUnit
+{
+	RPGWeapon attack;
+	RPGArmor armor; 
+	
+	long expValue;
+}

src/core/rpg/RPGExpTable.java

@@ -0,0 +1,65 @@
+package core.rpg;
+
+public final class RPGExpTable
+{
+	public static long EXPFloor(long level)
+	{
+		if(level > Levels.length - 1)
+			level = Levels.length - 1;
+		
+		else if (level <= 0)
+			level = 1;
+		
+		return Levels[(int) level];
+	}
+	
+	public static long EXPCeil(long level)
+	{
+		if(level > Levels.length - 1)
+			level = Levels.length - 1;
+		
+		else if (level <= 0)
+			level = 1;
+		
+		return Levels[(int) (level + 1)];
+	}
+	public static long LevelFromEXP(long exp)
+	{
+		if(exp < 0)
+			exp = 0;
+		
+		for(int i = 0; i < Levels.length; ++i)
+		{
+			if(Levels[i] > exp)
+				return i - 1;
+		}
+
+		return Levels.length - 1;
+	}
+	
+	// Based on D&D Pathfinder levels
+	public static long Levels[] = 
+	{
+		0,       // level 0
+		0,       // level 1
+		3000,    // level 2
+		7500,    // level 3
+		14000,   // level 4
+		23000,   // level 5
+		35000,   // level 6
+		53000,   // level 7
+		77000,   // level 8
+		115000,  // level 9
+		160000,  // level 10
+		235000,  // level 11
+		330000,  // level 12
+		475000,  // level 13
+		665000,  // level 14
+		955000,  // level 15
+		1350000, // level 16
+		1900000, // level 17
+		2700000, // level 18
+		3850000, // level 19
+		5350000  // level 20
+	};
+}

src/core/rpg/RPGFramework.java

@@ -0,0 +1,82 @@
+package core.rpg;
+
+import java.util.HashMap;
+
+import commands.rpg.RPGCommandBattleFight;
+import commands.rpg.RPGCommandBattleRun;
+import commands.rpg.RPGCommandExplore;
+import commands.rpg.RPGCommandInfo;
+import commands.rpg.RPGCommandStats;
+import core.rpg.RPGInput;
+
+// Holds the framework for the text RPG, for any number of users
+public class RPGFramework
+{
+	// User ID to user state. Users are conceptually just an ID.
+	public HashMap<String, RPGState> gameStates;
+	public HashMap<String, RPGCommand> gameCommands;
+	
+	// Ctor
+	public RPGFramework()
+	{
+		this.gameStates = new HashMap<String, RPGState>();
+		this.gameCommands = new HashMap<String, RPGCommand>();
+		
+		RegisterCommand("stats", new RPGCommandStats());
+		RegisterCommand("about", new RPGCommandInfo());
+		RegisterCommand("info", new RPGCommandInfo());
+		RegisterCommand("explore", new RPGCommandExplore());
+		RegisterCommand("run", new RPGCommandBattleRun());
+		RegisterCommand("fight", new RPGCommandBattleFight());
+	}
+	
+	// Primary external
+	public String Run(String userID, String inputRaw)
+	{
+		RPGState state = LookupState(userID);
+		RPGInput input = new RPGInput(inputRaw);
+		return ExecuteCommand(input.key, state, input);
+	}
+
+	// Get state for executing a command
+	public RPGState LookupState(String userID)
+	{
+		RPGState state;
+		synchronized(gameStates)
+		{
+			// Note: Hardcoded right now. Later: Extract.
+			state = gameStates.get(userID);
+			
+			if(state == null)
+			{
+				state = new RPGState(userID);
+				gameStates.put(userID, state);
+			}
+		}
+		
+		return state;
+	}
+
+	// Registers a command
+	private void RegisterCommand(String commandName, RPGCommand command)
+	{
+		commandName = commandName.toLowerCase();
+		if(gameCommands.put(commandName, command) != null)
+			RPGLog.Log("Managed to register the same RPG command twice! Not ideal!");
+		
+		RPGLog.Log("Registered " + commandName);
+	}
+	
+	private String ExecuteCommand(String name, RPGState state, RPGInput input)
+	{
+		synchronized(gameCommands)
+		{
+			RPGCommand command = gameCommands.get(name.toLowerCase());
+			
+			if(command != null && state != null)
+				return command.OnRun(state,  input);
+		}
+		
+		return null; 
+	}
+}

src/core/rpg/RPGInput.java

@@ -0,0 +1,42 @@
+package core.rpg;
+
+public class RPGInput
+{
+	public String raw;
+	public String key;
+	public String value;
+	
+	public RPGInput(String raw)
+	{
+		this.raw = raw;
+		this.key = "";
+		this.value = "";
+		
+		if(raw == null || raw.length() == 0)
+			return;
+		
+		raw = raw.trim();
+		int whitespacePos = FindFirstWhitespace(raw);
+		
+		if(whitespacePos == -1)
+		{
+			key = raw;
+			return;
+		}
+		
+		key = raw.substring(0, whitespacePos).trim();
+		value = raw.substring(whitespacePos).trim();
+	}
+	
+	// Finds first whitespace in the string
+	private int FindFirstWhitespace(String str)
+	{
+		for (int i = 0; i < str.length(); ++i) 
+		{
+			if (Character.isWhitespace(str.charAt(i)))
+				return i;
+		}
+	
+		return -1;
+	}
+}

src/core/rpg/RPGItem.java

@@ -0,0 +1,25 @@
+package core.rpg;
+
+public abstract class RPGItem
+{
+	protected String name;
+	protected String description;
+	protected int value;
+	
+	// Defaults
+	public RPGItem() { this("unknown"); } 
+	public RPGItem(String name) { this(name, "nothig is known about this item"); }
+	public RPGItem(String name, String description) { this(name, description, 1); }
+
+	// Ctor
+	public RPGItem(String name, String description, int value)
+	{
+		this.name = name;
+		this.description = description;
+		this.value = value;
+	}
+	
+	public String GetName() { return name; }
+	public String GetDescription() { return description; }
+	public long GetValue() { return value; }
+}

src/core/rpg/RPGLog.java

@@ -0,0 +1,12 @@
+package core.rpg;
+
+import utils.GlobalLog;
+import utils.LogFilter;
+
+public class RPGLog 
+{
+	public static void Log(String toWrite)
+	{
+		GlobalLog.Log(LogFilter.Command, "[RPG] " + toWrite);
+	}
+}

src/core/rpg/RPGMain.java

@@ -0,0 +1,38 @@
+package core.rpg;
+
+import java.util.Scanner;
+
+public class RPGMain
+{
+	private static RPGFramework framework;
+	private static Scanner scanner;
+	
+	public static void RPGmain(String[] args)
+	{
+		Init();
+		while(Run()) { };
+		Shutdown();
+	}
+	
+	// Initializes stuff (small factory, ish)
+	private static void Init()
+	{
+		framework = new RPGFramework();
+		scanner = new Scanner(System.in);
+	}
+	
+	// Main loop
+	private static boolean Run()
+	{
+		// move outside
+		String out = framework.Run("Test", scanner.nextLine()); 
+		RPGLog.Log(out);
+		return true;
+	}
+	
+	// Cleanup
+	private static void Shutdown()
+	{
+		scanner.close();
+	}
+}

src/core/rpg/RPGPlayer.java

@@ -0,0 +1,58 @@
+package core.rpg;
+
+public class RPGPlayer extends RPGUnit 
+{
+	private String name;
+	private long gold;
+	private long exp;
+	
+	RPGWeapon weapon;
+	RPGArmor armor;
+	
+	public RPGPlayer()
+	{
+		super();
+		
+		name = "Wanderer";
+		healthCurrent = 5;
+		healthMax = 5;
+		gold = 0;
+		weapon = new RPGWeapon();
+		armor = new RPGArmor();
+	}
+	
+	// Getters
+	public long GetEXP() { return exp; }
+	public long GetGold() { return gold; }
+	public String GetName() { return name; }
+	public RPGArmor GetArmor() { return armor; };
+	public RPGWeapon GetWeapon() { return weapon; };
+	
+	// Setters
+	public void SetName(String name) { this.name = name; }
+	
+	// Interactions
+	public void ApplyEXP(int expToGive)
+	{
+		if(expToGive < 0)
+			expToGive = 0;
+		
+		exp += expToGive;
+	}
+	
+	public void GiveGold(long amount) 
+	{
+		if(amount < 0)
+			amount = 0;
+		
+		gold += amount;
+	}
+	
+	public void SpendGold(long amount)
+	{
+		if(amount < 0)
+			amount = 0;
+		
+		gold -= amount;
+	}
+}

src/core/rpg/RPGState.java

@@ -0,0 +1,19 @@
+package core.rpg;
+
+// Holds specific state information for a given user and their world
+public class RPGState
+{
+	// General
+	public String userID;
+	
+	// Stats and gameplay
+	public RPGPlayer player;
+	public RPGBattleContext battleContext;
+	
+	public RPGState(String userID)
+	{
+		this.userID = userID;
+		this.player = new RPGPlayer();
+		this.battleContext = null;
+	}
+}

src/core/rpg/RPGUnit.java

@@ -0,0 +1,34 @@
+package core.rpg;
+
+public abstract class RPGUnit 
+{
+	protected int healthMax;
+	protected int healthCurrent;
+	
+	public int GetHealthMax() { return healthMax; }
+	public int GetHealthCurrent() { return healthCurrent; }
+	public boolean IsAlive() { return healthCurrent > 0; }
+
+	// Generic implementation. Consider implementing armor in 
+	// derived classes, for example.
+	public void ApplyDamage(int value) 
+	{ 
+		if(value < 0)
+			value = 0;
+		
+		healthCurrent -= value; 
+	}
+	
+	// Generic implementation. Consider applying boosts in
+	// derived classes, for example.
+	public void ApplyHealing(int value) 
+	{
+		if(value < 0)
+			value = 0;
+		
+		healthCurrent += value;
+		
+		if(healthCurrent > healthMax)
+			healthCurrent = healthMax;
+	}
+}

src/core/rpg/RPGWeapon.java

@@ -0,0 +1,17 @@
+package core.rpg;
+
+public class RPGWeapon extends RPGItem
+{
+	private long attack;
+	private double accuracy;
+	
+	RPGWeapon() 
+	{
+		super("Singed Stick", "A really cool stick that you found! You poked at your campfire last night with it a bit, so the end is a bit toasty.", 2);
+		attack = 1;
+		accuracy = 0.8;
+	}
+	
+	public long GetAttack() { return attack; }
+	public double GetAccuracy() { return accuracy; }
+}