diff --git a/resources/config.yml b/resources/config.yml
new file mode 100644
index 0000000..0a9ad4d
--- /dev/null
+++ b/resources/config.yml
@@ -0,0 +1,245 @@
+prefix: '&6&lRPGHorses &8\u00BB &7'
+
+# Defines how {XP} should look like
+progress-bar:
+  # Character for each percentage point of the progress bar
+  character: '\u2B1B'
+  # Color for the completed bars
+  completed-color: '&a'
+  # Color for the uncompleted bars
+  missing-color: '&c'
+  # Number of bars per progress bar (ex. 10 == 10% per bar)
+  count: 10
+
+stable-options:
+  title: '&6&lStable'
+  rows: 3
+  # This item will fill all empty slots within the stable gui
+  fill-item:
+    material: STAINED_GLASS_PANE
+    data: 15
+  previous-page-item:
+    material: PAPER
+    name: '&6&lPrevious page'
+    lore: '&7Click to view the previous page'
+  next-page-item:
+    material: PAPER
+    name: '&6&lNext page'
+    lore: '&7Click to view the next page'
+  alive-horse-item:
+    material: SKULL_ITEM
+    skin-value: 'eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNDJlYjk2N2FiOTRmZGQ0MWE2MzI1ZjEyNzdkNmRjMDE5MjI2ZTVjZjM0OTc3ZWVlNjk1OTdmYWZjZjVlIn19fQ==\'
+    name: '&8\u00BB &7{HORSE-NAME} &8\u00AB'
+    lore:
+      - '   &7Movement Speed: &6{MOVEMENT-SPEED} &7miles/second'
+      - '   &7Jump Strength: &6{JUMP-STRENGTH}'
+      - '   &7Health: &6{HEALTH}&7/&6{MAX-HEALTH}'
+      - '   &7Tier: &6{TIER}'
+      - '   &7XP: (&a{XP}&7)'
+  dead-horse-item:
+    material: SKULL_ITEM
+    skin-value: 'eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNWM2ZDVhYmJmNjhjY2IyMzg2YmYxNmFmMjVhYzM4ZDhiNzdiYjBlMDQzMTUyNDYxYmQ5N2YzZjYzMGRiYjhiYyJ9fX0=\'
+    name: '&c\u00BB &7{HORSE-NAME} &c\u00AB'
+    lore:
+      - '   &7Death cooldown: &6{DEATH-COOLDOWN}'
+  market-horse-item:
+    material: SKULL_ITEM
+    skin-value: 'eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYmZlNTY3MjgyZTc4NjA3ZjJjYTJhZWY1ODNiOGVmZWJjOTE5NTlmODRjYWU0YTgzYmVkMTBkY2Q1YjBjZmNjZCJ9fX0='
+    name: '&8\u00BB &7{HORSE-NAME} &8\u00AB'
+    lore:
+      - '&7RPGHorse is in market'
+
+upgrade-options:
+  title: '&6&lUpgrade RPGHorse'
+  rows: 3
+  # This item will fill all empty slots within the stable gui
+  fill-item:
+    material: STAINED_GLASS_PANE
+    data: 15
+  upgrade-item:
+    material: WOOL
+    data: 5
+    name: '&a&lUpgrade RPGHorse'
+    lore:
+      - '&7Click to upgrade your RPGHorse'
+      - '   &7Success Rate: &6{SUCCESS-CHANCE}'
+      - '   &7Tier: &6{TIER}'
+      - '   &7Cost: &6{COST}'
+      - '   &7Horse: &6{HORSE-NAME}'
+    x-cord: 5
+    y-cord: 2
+  success-sound:
+    sound: ENTITY_PLAYER_LEVELUP
+    volume: 1.0
+    pitch: 1.0
+  failure-sound:
+    sound: BLOCK_NOTE_PLING
+    volume: 1.0
+    pitch: 1.0
+
+horse-tiers:
+  # 1 defines the upgrades that occur from 1 -> 2
+  1:
+    movement-speed-multiplier: 1.3
+    jump-strength-multiplier: 1.3
+    success-chance: 100
+    cost: 100
+    exp-cost: 10000
+  2:
+    movement-speed-multiplier: 1.2
+    jump-strength-multiplier: 1.2
+    success-chance: 80
+    cost: 500
+    exp-cost: 40000
+  3:
+    movement-speed-multiplier: 1.1
+    jump-strength-multiplier: 1.1
+    success-chance: 90
+    cost: 160000
+
+market-options:
+  title: '&6&lRPGHorse Market'
+  rows: 3
+  fill-item:
+    material: STAINED_GLASS_PANE
+    data: 15
+  previous-page-item:
+    material: PAPER
+    name: '&6&lPrevious page'
+    lore: '&7Click to view the previous page'
+  next-page-item:
+    material: PAPER
+    name: '&6&lNext page'
+    lore: '&7Click to view the next page'
+  horse-item:
+    material: SKULL_ITEM
+    skin-value: 'eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNDJlYjk2N2FiOTRmZGQ0MWE2MzI1ZjEyNzdkNmRjMDE5MjI2ZTVjZjM0OTc3ZWVlNjk1OTdmYWZjZjVlIn19fQ==\'
+    name: '&8\u00BB &7{HORSE-NAME} &8\u00AB'
+    lore:
+      - '   &7Movement Speed: &6{MOVEMENT-SPEED} &7miles/second'
+      - '   &7Jump Strength: &6{JUMP-STRENGTH}'
+      - '   &7Health: &6{HEALTH}&7/&6{MAX-HEALTH}'
+      - '   &7Tier: &6{TIER}'
+      - '   &7Price: &6${PRICE}'
+      - '   &7Owner: &6{HORSE-OWNER}'
+  your-horses-item:
+    material: SKULL_ITEM
+    skin-value: 'eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYmZlNTY3MjgyZTc4NjA3ZjJjYTJhZWY1ODNiOGVmZWJjOTE5NTlmODRjYWU0YTgzYmVkMTBkY2Q1YjBjZmNjZCJ9fX0='
+    name: '&8\u00BB &6Your Market Horses &8\u00AB'
+    lore:
+      - '&7Click to view the horses you''re selling in the market'
+    x-cord: 5
+    y-cord: 3
+  back-item:
+    material: SKULL_ITEM
+    skin-value: 'eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYmZlNTY3MjgyZTc4NjA3ZjJjYTJhZWY1ODNiOGVmZWJjOTE5NTlmODRjYWU0YTgzYmVkMTBkY2Q1YjBjZmNjZCJ9fX0='
+    name: '&c&lBack'
+    lore:
+      - '&7Click to go back to the market'
+    x-cord: 5
+    y-cord: 3
+
+horse-crates:
+  crate1:
+    price: 1000
+    horse-info:
+      health: 20.0-40.0
+      movement-speed: 0.5-1.0
+      jump-strength: 1.0-2.0
+      type: HORSE
+      color: BROWN
+      style: NONE
+      tier: 1
+
+horse-options:
+  default-name: '&6{PLAYER}''s &7Horse'
+  death-cooldown: 300
+  idle-time: 300
+  particles:
+    # How long should the interval be between particles (20 = 1 second)
+    interval: 3
+    # How many particles should appear at once
+    volume: 3
+    y-offset: 1
+
+time-options:
+  minute: 'minute'
+  minutes: 'minutes'
+  second: 'second'
+  seconds: 'seconds'
+
+listall-format:
+  header: '&8&m-------------&8< &7Listing Active RPGHorses &8>&m-------------'
+  body: ' &6{PLAYER} &8- &7Horse &6#{HORSE-NUMBER} &8(&7{LOCATION}&8)'
+  footer: '&8&m--------------------------------------------------'
+
+check-format:
+  header: '&8&m---------&8< &7Listing Active RPGHorses Within &6{RADIUS}m &8>&m---------'
+  body: ' &6{PLAYER} &8- &7Horse &6#{HORSE-NUMBER} &8(&7{LOCATION}&8)'
+  footer: '&8&m-------------------------------------------------'
+
+# Commands to be run upon spawning, despawning or upgrading a horse (success or failure).
+command-options:
+  on-spawn: []
+  on-despawn: []
+  on-upgrade-success: []
+  on-upgrade-fail: []
+
+messages:
+  max-xp: '{PREFIX}&6{HORSE-NAME} &7has reached max XP, &6shift + right-click &7your horse in your stable to upgrade it'
+  not-enough-xp: '{PREFIX}&6{HORSE-NAME} &7doesn''t have enough XP to level up'
+  no-permission-particle: '{PREFIX}You haven''t unlocked the &6{PARTICLE} &7particle effect'
+  particle-set: '{PREFIX}Trail for RPGHORSE &8(&6{HORSE-NUMBER}&8) &7set to &6{PARTICLE}'
+  particle-fail: '{PREFIX}You must call a RPGHorse to set it''s trail'
+  horse-crate-bought: '{PREFIX}&6{HORSE-CRATE} &7bought for &6${PRICE}'
+  cant-afford-crate: '{PREFIX}You can''t afford that crate'
+  market-horse-removed: '{PREFIX}RPGHorse &8(&6{HORSE-NUMBER}&8) &7removed from the market'
+  market-horse-limit: '{PREFIX}You have too many RPGHorses to buy another one'
+  market-horse-sold: '{PREFIX}Your horse has been sold to &6{PLAYER} &7for &6${PRICE}'
+  market-horse-bought: '{PREFIX}You have bought an RPGHorse from &6{PLAYER} &7for &6${PRICE}'
+  market-buy-own-horse: '{PREFIX}You may not buy your own RPGHorse'
+  cant-afford-market-horse: '{PREFIX}You can''t afford to buy that RPGHorse'
+  horse-added-to-market: '{PREFIX}RPGHorse &8(&6{HORSE-NUMBER}&8) &7added to market successfully'
+  horse-already-in-market: '{PREFIX}Your RPGHorse &8(&6{HORSE-NUMBER}&8) &7is already listed in the market'
+  horse-market-fail: '{PREFIX}Your RPGHorse &8(&6{HORSE-NUMBER}&8) &7must be alive and in your stable to be sold in the
+  market'
+  horse-is-in-market: '{PREFIX}You can''t call your horse while it''s in the market'
+  horse-is-dead: '{PREFIX}You can''t call your horse when it''s dead'
+  cant-afford-upgrade: '{PREFIX}You can''t afford to upgrade your RPGHorse &8(&6{HORSE-NUMBER}&8)'
+  upgrade-horse-success: '{PREFIX}Upgraded RPGHorse &8(&6{HORSE-NUMBER}&8) &7to tier &6{TIER} &7successfully'
+  upgrade-horse-failure: '{PREFIX}Failed to upgrade RPGHorse &8(&6{HORSE-NUMBER}&8) &7to tier &6{TIER}'
+  max-tier-horse: '{PREFIX}Your RPGHorse &8(&6{HORSE-NUMBER}&8) &7is already max tier!'
+  rename-horse: '{PREFIX}What would you like to name your RPGHORSE &8(&6{HORSE-NUMBER}&8)&7?'
+  horse-renamed: '{PREFIX}Your RPGHorse &8(&6{HORSE-NUMBER}&8) &7was renamed to {HORSE-NAME}'
+  confirm-remove-horse: '{PREFIX}Are you sure you want to remove your RPGHorse &8(&6{HORSE-NUMBER}&8)&7? Type
+  &6/confirm'
+  not-your-horse: '{PREFIX}That RPGHorse does not belong to you!'
+  horse-sent-to-stable: '{PREFIX}Your RPGHorse was sent back to the stable by &6{PLAYER}'
+  horse-removenear: '{PREFIX}&6{HORSE-COUNT} &7rpghorses were removed nearby'
+  horse-purgeall: '{PREFIX}&6{HORSE-COUNT} &7horses were removed nearby'
+  horse-upgraded: '{PREFIX}&6{PLAYER}''s &7RPGHorse &8(&6{HORSE-NUMBER}&8) &7upgraded to &6{TIER} &7successfully'
+  your-horse-was-upgraded: '{PREFIX}Your RPGHorse &8(&6{HORSE-NUMBER}&8) &7was upgraded to &6{TIER} &7by &6{PLAYER}'
+  max-horse-tier: '{PREFIX}&6{PLAYER}''s &7RPGHorse &8(&6{HORSE-NUMBER}&8) &7is already max tier'
+  horse-removed: '{PREFIX}&6{PLAYER}''s &7RPGHorse &8(&6{HORSE-NUMBER}&8) &7removed successfully'
+  your-horse-was-removed: '{PREFIX}Your RPGHorse &8(&6{HORSE-NUMBER}&8) &7has been removed by {PLAYER}'
+  horse-set: '{PREFIX}&6{PLAYER}''s &7RPGHorse &8(&6{HORSE-NUMBER}&8) &7updated successfully'
+  horse-given: '{PREFIX}RPGHorse given to &6{PLAYER} &7successfully'
+  horse-received: '{PREFIX}You have received an RPGHorse from &6{PLAYER}'
+  horse-limit: '{PREFIX}&6{PLAYER} &7tried to give you a RPGHorse but you''ve reach your limit!'
+  no-horses: '{PREFIX}You don''t have any horses in your stable'
+  config-reloaded: '{PREFIX}Configuration file reloaded'
+  no-permission: 'You don''t have permission for that'
+  help-message:
+    - '                             &6&lRPGHorses'
+    - '&6/rpghorseadmin give <health> <movement-speed> <jump-strength> <type> <color> <style> <player> &8- &7Gives a
+    player a RPGHorse'
+    - '&6/rpghorseadmin set <health> <movement-speed> <jump-height> <type> <color> <style> <horse-number> <player> &8-
+     &7Modifies an existing RPGHorse'
+    - '&6/rpghorseadmin remove <horse-number> <player> &8- &7Removes a RPGHorse from a player''s stable'
+    - '&6/rpghorseadmin upgrade <horse-number> <player> &8- &7Upgrades a player''s RPGHorse'
+    - '&6/rpghorseadmin listall &8- &7Lists all active RPGHorses'
+    - '&6/rpghorseadmin check <radius> &8- &7Lists all active RPGHorses within a certain radius'
+    - '&6/rpghourseadmin removenear <radius> &8- &7Removes all RPGHorses within a certain radius'
+    - '&6/rpghorsesadmin reload &8- &7Reloads the configuration file'
+    - '&6/rpghorsesadmin &8- &7Displays this message'
+    - '&6/rpghorses &8- &7Opens the stable gui'
\ No newline at end of file
diff --git a/resources/market.yml b/resources/market.yml
new file mode 100644
index 0000000..ea8aecc
--- /dev/null
+++ b/resources/market.yml
@@ -0,0 +1 @@
+market: {}
\ No newline at end of file
diff --git a/resources/plugin.yml b/resources/plugin.yml
new file mode 100644
index 0000000..b03eb48
--- /dev/null
+++ b/resources/plugin.yml
@@ -0,0 +1,44 @@
+main: org.plugins.rpghorses.RPGHorsesMain
+name: RPGHorses
+author: 7rory768
+version: 1.0.0
+depend: [Vault]
+load: POSTWORLD
+
+commands:
+  rpghorses:
+    aliases: [rpghorse, rpghorses, horses, horse]
+  rpghorsesadmin:
+    aliases: [rpghorseadmin, rpghorsesadmin, horseadmin, horsesadmin]
+
+permissions:
+  rpghorses.trail.*:
+    default: op
+  rpghorses.market:
+    default: true
+  rpghorses.sell:
+    default: true
+  rpghorses.buy:
+    default: true
+  rpghorses.stable:
+    default: true
+  rpghorses.upgrade:
+    default: op
+  rpghorses.check:
+    default: op
+  rpghorses.removenear:
+    default: op
+  rpghorses.listall:
+    default: op
+  rpghorses.remove:
+    default: op
+  rpghorses.set:
+    default: op
+  rpghorses.give:
+    default: op
+  rpghorses.limit.*:
+    default: op
+  rpghorses.reload:
+    default: op
+  rpghorses.help:
+    default: op
\ No newline at end of file
diff --git a/src/org/plugins/rpghorses/RPGHorsesMain.java b/src/org/plugins/rpghorses/RPGHorsesMain.java
new file mode 100644
index 0000000..98658ad
--- /dev/null
+++ b/src/org/plugins/rpghorses/RPGHorsesMain.java
@@ -0,0 +1,131 @@
+package org.plugins.rpghorses;
+
+import net.milkbowl.vault.economy.Economy;
+import net.milkbowl.vault.permission.Permission;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.plugins.rpghorses.commands.RPGHorsesAdminCommand;
+import org.plugins.rpghorses.commands.RPGHorsesCommand;
+import org.plugins.rpghorses.configs.CustomConfig;
+import org.plugins.rpghorses.configs.PlayerConfigs;
+import org.plugins.rpghorses.listeners.*;
+import org.plugins.rpghorses.managers.*;
+import org.plugins.rpghorses.players.HorseOwner;
+import org.plugins.rpghorses.utils.CustomConfigUtil;
+import org.plugins.rpghorses.utils.ItemUtil;
+import org.plugins.rpghorses.utils.MessagingUtil;
+
+import java.util.logging.Level;
+
+public class RPGHorsesMain extends JavaPlugin {
+
+    private CustomConfig marketConfig;
+    private PlayerConfigs playerConfigs;
+    private ItemUtil itemUtil;
+    private MessagingUtil messagingUtil;
+    private HorseDespawner horseDespawner;
+    private HorseOwnerManager horseOwnerManager;
+    private StableGUIManager stableGuiManager;
+    private MarketGUIManager marketGUIManager;
+    private RPGHorseManager rpgHorseManager;
+    private HorseCrateManager horseCrateManager;
+    private ParticleManager particleManager;
+    private XPManager xpManager;
+    private MessageQueuer messageQueuer;
+    private Permission permissions;
+    private Economy economy;
+
+    @Override
+    public void onEnable() {
+        this.loadConfigs();
+        if (this.loadHooks()) {
+            Bukkit.getLogger().log(Level.INFO, "[RPGHorses] Successfully hooked into Vault");
+            this.initializeVariables();
+            this.registerEvents();
+            this.loadCommands();
+        } else {
+            new PluginEnableListener(this);
+            Bukkit.getLogger().log(Level.SEVERE, "[RPGHorses] Failed to hook into Vault, plugin disabled");
+        }
+    }
+
+    @Override
+    public void onDisable() {
+        if (this.horseDespawner != null) {
+            this.horseDespawner.despawnAllRPGHorses();
+            this.horseDespawner.cancelIdleHorseTask();
+        }
+
+        if (this.stableGuiManager != null) {
+            this.stableGuiManager.cancelCooldownTask();
+        }
+
+        if (this.horseOwnerManager != null) {
+            for (HorseOwner horseOwner : this.horseOwnerManager.getHorseOwners()) {
+                if (horseOwner.isInStableInventory() || horseOwner.isInMarketInventory()) {
+                    Bukkit.getPlayer(horseOwner.getUUID()).closeInventory();
+                }
+            }
+
+            this.horseOwnerManager.saveData();
+        }
+    }
+
+    public void loadConfigs() {
+        CustomConfigUtil.loadDefaultConfig(this);
+
+        this.playerConfigs = new PlayerConfigs(this);
+
+        this.marketConfig = new CustomConfig(this, "market");
+        CustomConfigUtil.loadConfig(this.marketConfig);
+    }
+
+    public boolean loadHooks() {
+        RegisteredServiceProvider<Permission> permissionProvider = getServer().getServicesManager().getRegistration(net.milkbowl.vault.permission.Permission.class);
+        if (permissionProvider != null) {
+            this.permissions = permissionProvider.getProvider();
+        }
+
+        RegisteredServiceProvider<Economy> economyProvider = getServer().getServicesManager().getRegistration(net.milkbowl.vault.economy.Economy.class);
+        if (economyProvider != null) {
+            this.economy = economyProvider.getProvider();
+        }
+
+        return this.permissions != null && this.economy != null;
+    }
+
+    public void initializeVariables() {
+        this.messagingUtil = new MessagingUtil(this);
+        this.itemUtil = new ItemUtil(this, this.messagingUtil);
+        this.horseOwnerManager = new HorseOwnerManager(this, this.playerConfigs, this.permissions);
+        this.rpgHorseManager = new RPGHorseManager(this, this.horseOwnerManager, this.economy);
+        this.stableGuiManager = new StableGUIManager(this, this.horseOwnerManager, this.rpgHorseManager, this.itemUtil, this.messagingUtil);
+        this.marketGUIManager = new MarketGUIManager(this, this.horseOwnerManager, this.rpgHorseManager, this.marketConfig, this.itemUtil);
+        this.messageQueuer = new MessageQueuer(this.playerConfigs, this.messagingUtil);
+        this.horseDespawner = new HorseDespawner(this, this.horseOwnerManager, this.rpgHorseManager);
+        this.horseCrateManager = new HorseCrateManager(this);
+        this.particleManager = new ParticleManager(this, this.horseOwnerManager);
+        this.xpManager = new XPManager(this, rpgHorseManager, messagingUtil);
+    }
+
+    public void registerEvents() {
+        new EntityDamageByEntityListener(this, this.rpgHorseManager, this.stableGuiManager);
+        new EntityDeathListener(this, this.rpgHorseManager, this.stableGuiManager, xpManager);
+        new EntitySpawnListener(this, this.rpgHorseManager, this.horseOwnerManager);
+        new InventoryClickListener(this, this.horseOwnerManager, this.rpgHorseManager, this.stableGuiManager, this.marketGUIManager, this.economy, this.messageQueuer, this.messagingUtil);
+        new InventoryCloseListener(this, this.horseOwnerManager, this.stableGuiManager);
+        new PlayerChatListener(this, this.rpgHorseManager, this.stableGuiManager, this.messagingUtil);
+        new PlayerInteractEntityListener(this, this.rpgHorseManager, this.messagingUtil);
+        new PlayerJoinListener(this, this.horseOwnerManager, this.stableGuiManager, this.marketGUIManager, this.messageQueuer);
+        new PlayerQuitListener(this, this.horseOwnerManager, xpManager);
+        new PlayerTeleportListener(this, this.horseOwnerManager, this.messagingUtil);
+        new PreCommandListener(this, this.rpgHorseManager, this.stableGuiManager, this.marketGUIManager, this.messagingUtil);
+        new VehicleListener(this, this.rpgHorseManager, this.xpManager, this.messagingUtil);
+    }
+
+    public void loadCommands() {
+        this.getCommand("rpghorses").setExecutor(new RPGHorsesCommand(this, this.horseOwnerManager, this.stableGuiManager, this.marketGUIManager, this.horseCrateManager, this.particleManager, this.economy, this.messagingUtil));
+        this.getCommand("rpghorsesadmin").setExecutor(new RPGHorsesAdminCommand(this, this.horseOwnerManager, this.rpgHorseManager, this.stableGuiManager, this.horseDespawner, this.horseCrateManager, this.marketGUIManager, this.particleManager, this.messageQueuer, this.messagingUtil));
+    }
+}
diff --git a/src/org/plugins/rpghorses/commands/RPGHorsesAdminCommand.java b/src/org/plugins/rpghorses/commands/RPGHorsesAdminCommand.java
new file mode 100644
index 0000000..b90f296
--- /dev/null
+++ b/src/org/plugins/rpghorses/commands/RPGHorsesAdminCommand.java
@@ -0,0 +1,576 @@
+package org.plugins.rpghorses.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Horse;
+import org.bukkit.entity.Player;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.managers.*;
+import org.plugins.rpghorses.players.HorseOwner;
+import org.plugins.rpghorses.utils.*;
+
+import java.util.UUID;
+
+public class RPGHorsesAdminCommand implements CommandExecutor {
+
+    private final RPGHorsesMain plugin;
+    private final HorseOwnerManager horseOwnerManager;
+    private final RPGHorseManager rpgHorseManager;
+    private final StableGUIManager stableGuiManager;
+    private final HorseDespawner horseDespawner;
+    private final HorseCrateManager horseCrateManager;
+    private final MarketGUIManager marketGUIManager;
+    private final ParticleManager particleManager;
+    private final MessageQueuer messageQueuer;
+    private final MessagingUtil messagingUtil;
+
+    public RPGHorsesAdminCommand(RPGHorsesMain plugin, HorseOwnerManager horseOwnerManager, RPGHorseManager rpgHorseManager, StableGUIManager stableGuiManager, HorseDespawner horseDespawner, HorseCrateManager horseCrateManager, MarketGUIManager marketGUIManager, ParticleManager particleManager, MessageQueuer messageQueuer, MessagingUtil messagingUtil) {
+        this.plugin = plugin;
+        this.horseOwnerManager = horseOwnerManager;
+        this.rpgHorseManager = rpgHorseManager;
+        this.stableGuiManager = stableGuiManager;
+        this.horseDespawner = horseDespawner;
+        this.horseCrateManager = horseCrateManager;
+        this.marketGUIManager = marketGUIManager;
+        this.particleManager = particleManager;
+        this.messageQueuer = messageQueuer;
+        this.messagingUtil = messagingUtil;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+
+        if (args.length > 0) {
+            String arg1 = args[0];
+
+            if (arg1.equalsIgnoreCase("reload")) {
+                if (!sender.hasPermission("rpghorses.reload")) {
+                    this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+                    return false;
+                }
+
+                this.plugin.reloadConfig();
+                this.messagingUtil.updatePrefix();
+                this.stableGuiManager.reload();
+                this.horseDespawner.reloadIdleTime();
+                TimeUtil.refreshUnitStrings(this.plugin.getConfig(), "time-options.");
+                this.horseCrateManager.loadHorseCrates();
+                this.particleManager.reload();
+                this.messagingUtil.sendMessageAtPath(sender, "messages.config-reloaded");
+                return true;
+            }
+
+            if (arg1.equalsIgnoreCase("give")) {
+                if (!sender.hasPermission("rpghorses.give")) {
+                    this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+                    return false;
+                }
+
+                if (args.length < 8) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Not enough arguments, try &6/" + label.toLowerCase() + " give <health> <movement-speed> <jump-strength> <type> <color> <style> <player>");
+                    return false;
+                }
+
+                String playerArg = args[7];
+                OfflinePlayer p = this.runPlayerCheck(sender, playerArg);
+                if (p == null) {
+                    return false;
+                }
+
+                if (this.horseOwnerManager.getHorseCount(p) >= this.horseOwnerManager.getHorseLimit(p)) {
+                    String message = this.plugin.getConfig().getString("messages.horse-limit").replace("{PLAYER}", sender.getName());
+                    if (p.isOnline()) {
+                        this.messagingUtil.sendMessage(p.getPlayer(), message);
+                    } else {
+                        this.messageQueuer.queueMessage(p, message);
+                    }
+                    return false;
+                }
+
+                String healthArg = args[1];
+                String movementSpeedArg = args[2];
+                String jumpStrengthArg = args[3];
+
+                String typeArg = args[4];
+                String colorArg = args[5];
+                String styleArg = args[6];
+
+                if (!this.checkHorseArguments(sender, p, healthArg, movementSpeedArg, jumpStrengthArg, typeArg, colorArg, styleArg, null)) {
+                    return false;
+                }
+
+                double health = Double.valueOf(healthArg);
+                double movementSpeed = Double.valueOf(movementSpeedArg);
+                double jumpStrength = Double.valueOf(jumpStrengthArg);
+
+                EntityType type = EntityType.valueOf(typeArg.toUpperCase());
+                Horse.Color color = Horse.Color.valueOf(colorArg.toUpperCase());
+                Horse.Style style = Horse.Style.valueOf(styleArg.toUpperCase());
+
+                HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p);
+
+                RPGHorse rpgHorse = new RPGHorse(horseOwner, 1, 0, this.plugin.getConfig().getString("horse-options.default-name").replace("{PLAYER}", p.getName()), health, movementSpeed, jumpStrength, type, color, style, false, null);
+
+                horseOwner.addRPGHorse(rpgHorse);
+                this.messagingUtil.sendMessage(sender, this.plugin.getConfig().getString("messages.horse-given").replace("{PLAYER}", p.getName()), rpgHorse);
+
+                String message = this.messagingUtil.placeholders(this.plugin.getConfig().getString("messages.horse-received").replace("{PLAYER}", sender.getName()), rpgHorse);
+                if (p.isOnline()) {
+                    this.messagingUtil.sendMessage(p.getPlayer(), message);
+                    this.stableGuiManager.setupStableGUI(horseOwner);
+                } else {
+                    this.messageQueuer.queueMessage(p, message);
+                    this.horseOwnerManager.flushHorseOwner(horseOwner);
+                }
+                return true;
+
+            }
+
+            if (arg1.equalsIgnoreCase("set")) {
+                if (!sender.hasPermission("rpghorses.set")) {
+                    this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+                    return false;
+                }
+
+                if (args.length < 9) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Not enough arguments, try &6/" + label.toLowerCase() + " set <health> <movement-speed> <jump-strength> <type> <color> <style> <horse-number> <player>");
+                    return false;
+                }
+
+                String playerArg = args[8];
+                OfflinePlayer p = this.runPlayerCheck(sender, playerArg);
+                if (p == null) {
+                    return false;
+                }
+
+                String healthArg = args[1];
+                String movementSpeedArg = args[2];
+                String jumpStrengthArg = args[3];
+                String typeArg = args[4];
+                String colorArg = args[5];
+                String styleArg = args[6];
+                String horseNumberArg = args[7];
+
+                if (!this.checkHorseArguments(sender, p, healthArg, movementSpeedArg, jumpStrengthArg, typeArg, colorArg, styleArg, horseNumberArg)) {
+                    return false;
+                }
+
+                double health = Double.valueOf(healthArg);
+                double movementSpeed = Double.valueOf(movementSpeedArg);
+                double jumpStrength = Double.valueOf(jumpStrengthArg);
+                int horseNumber = Integer.valueOf(horseNumberArg);
+
+                EntityType type = EntityType.valueOf(typeArg.toUpperCase());
+                Horse.Color color = Horse.Color.valueOf(colorArg.toUpperCase());
+                Horse.Style style = Horse.Style.valueOf(styleArg.toUpperCase());
+
+                HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p);
+                RPGHorse rpgHorse = horseOwner.getRPGHorse(horseNumber - 1);
+                rpgHorse.setHealth(health);
+                rpgHorse.setMovementSpeed(movementSpeed);
+                rpgHorse.setJumpStrength(jumpStrength);
+                rpgHorse.setEntityType(type);
+                rpgHorse.setColor(color);
+                rpgHorse.setStyle(style);
+                this.rpgHorseManager.updateHorse(rpgHorse);
+                if (p.isOnline()) {
+                    this.stableGuiManager.updateRPGHorse(rpgHorse);
+                }
+                this.messagingUtil.sendMessage(sender, this.plugin.getConfig().getString("messages.horse-set").replace("{PLAYER}", p.getName()).replace("{HORSE-NUMBER}", horseNumberArg), rpgHorse);
+                return true;
+            }
+
+            if (arg1.equalsIgnoreCase("remove")) {
+                if (!sender.hasPermission("rpghorses.remove")) {
+                    this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+                    return false;
+                }
+
+                if (args.length < 3) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Not enough arguments, try &6/" + label.toLowerCase() + " remove <horse-number> <player>");
+                    return false;
+                }
+
+                String horseNumberArg = args[1];
+                String playerArg = args[2];
+                OfflinePlayer p = this.runPlayerCheck(sender, playerArg);
+                if (p == null) {
+                    return false;
+                }
+
+                if (!this.runHorseNumberCheck(sender, horseNumberArg, p)) {
+                    return false;
+                }
+
+                HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p);
+                RPGHorse rpgHorse = horseOwner.getRPGHorse(Integer.valueOf(horseNumberArg) - 1);
+                if (horseOwner.getCurrentHorse().equals(horseOwner)) {
+                    for (String cmd : this.plugin.getConfig().getStringList("command-options.on-despawn")) {
+                        Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), MessagingUtil.format(cmd.replace("{PLAYER}", p.getName())));
+                    }
+                }
+                horseOwner.removeRPGHorse(rpgHorse);
+
+                if (rpgHorse.isInMarket()) {
+                    this.marketGUIManager.removeHorse(this.marketGUIManager.getPage(rpgHorse), rpgHorse, true);
+                }
+
+                String message = this.messagingUtil.placeholders(this.plugin.getConfig().getString("messages.your-horse-was-removed").replace("{PLAYER}", sender.getName()).replace("{HORSE-NUMBER}", horseNumberArg), rpgHorse);
+                if (p.isOnline()) {
+                    this.messagingUtil.sendMessage(p.getPlayer(), message);
+                    this.stableGuiManager.setupStableGUI(horseOwner);
+                } else {
+                    this.horseOwnerManager.flushHorseOwner(horseOwner);
+                    this.messageQueuer.queueMessage(p, message);
+                }
+
+                this.messagingUtil.sendMessage(sender, this.plugin.getConfig().getString("messages.horse-removed").replace("{PLAYER}", sender.getName()).replace("{HORSE-NUMBER}", horseNumberArg), rpgHorse);
+                return true;
+            }
+
+            if (arg1.equalsIgnoreCase("upgrade")) {
+                if (!sender.hasPermission("rpghorses.upgrade")) {
+                    this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+                    return false;
+                }
+
+                if (args.length < 3) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Not enough arguments, try &6/" + label.toLowerCase() + " upgrade <horse-number> <player>");
+                    return false;
+                }
+
+                String horseNumberArg = args[1];
+                String playerArg = args[2];
+                OfflinePlayer p = this.runPlayerCheck(sender, playerArg);
+                if (p == null) {
+                    return false;
+                }
+
+                if (!this.runHorseNumberCheck(sender, horseNumberArg, p)) {
+                    return false;
+                }
+
+                HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p);
+                RPGHorse rpgHorse = horseOwner.getRPGHorse(Integer.valueOf(horseNumberArg) - 1);
+                int tier = rpgHorse.getTier();
+                if (tier >= this.rpgHorseManager.getMaxTier()) {
+                    this.messagingUtil.sendMessage(sender, this.plugin.getConfig().getString("messages.max-horse-tier").replace("{PLAYER}", p.getName()).replace("{HORSE-NUMBER}", horseNumberArg), rpgHorse);
+                    return false;
+                }
+
+                rpgHorse.setMovementSpeed(rpgHorse.getMovementSpeed() * this.plugin.getConfig().getDouble("horse-tiers." + tier + ".movement-speed-multiplier"));
+                rpgHorse.setJumpStrength(rpgHorse.getJumpStrength() * this.plugin.getConfig().getDouble("horse-tiers." + tier + ".jump-strength-multiplier"));
+                rpgHorse.setTier(++tier);
+
+                String message = this.messagingUtil.placeholders(this.plugin.getConfig().getString("messages.your-horse-was-upgraded").replace("{PLAYER}", sender.getName()).replace("{HORSE-NUMBER}", horseNumberArg).replace("{TIER}", "" + tier), rpgHorse);
+                if (p.isOnline()) {
+                    this.messagingUtil.sendMessage(p.getPlayer(), message);
+                    this.stableGuiManager.updateRPGHorse(rpgHorse);
+                } else {
+                    this.horseOwnerManager.flushHorseOwner(horseOwner);
+                    this.messageQueuer.queueMessage(p, message);
+                }
+
+                this.messagingUtil.sendMessage(sender, this.plugin.getConfig().getString("messages.horse-upgraded").replace("{PLAYER}", p.getName()).replace("{HORSE-NUMBER}", horseNumberArg).replace("{TIER}", "" + tier), rpgHorse);
+                return true;
+            }
+
+            if (arg1.equalsIgnoreCase("listall")) {
+                if (!sender.hasPermission("rpghorses.listall")) {
+                    this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+                    return false;
+                }
+
+                this.messagingUtil.sendMessageAtPath(sender, "listall-format.header");
+                String body = this.plugin.getConfig().getString("listall-format.body");
+                for (Player p : this.plugin.getServer().getOnlinePlayers()) {
+                    HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p);
+                    RPGHorse rpgHorse = horseOwner.getCurrentHorse();
+                    if (rpgHorse != null) {
+                        this.messagingUtil.sendMessage(sender, body.replace("{PLAYER}", p.getName()).replace("{HORSE-NUMBER}", "" + horseOwner.getHorseNumber(rpgHorse)).replace("{LOCATION}", LocationUtil.toBlockString(rpgHorse.getHorse().getLocation())), rpgHorse);
+                    }
+                }
+                this.messagingUtil.sendMessageAtPath(sender, "listall-format.footer");
+                return true;
+            }
+
+            if (arg1.equalsIgnoreCase("check")) {
+                if (!sender.hasPermission("rpghorses.check")) {
+                    this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+                    return false;
+                }
+
+                if (args.length < 2) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Not enough arguments, try &6/" + label.toLowerCase() + " check <radius>");
+                    return false;
+                }
+
+                Player p;
+                try {
+                    p = (Player) sender;
+                } catch (ClassCastException e) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}This command can only be used in-game");
+                    return false;
+                }
+                Location loc = p.getLocation();
+
+                String radiusArg = args[1];
+                if (!NumberUtil.isPositiveInt(radiusArg)) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Invalid radius value: &6" + radiusArg);
+                    return false;
+                }
+                int radius = Integer.valueOf(radiusArg);
+
+                this.messagingUtil.sendMessage(sender, this.plugin.getConfig().getString("check-format.header").replace("{RADIUS}", radiusArg));
+                String body = this.plugin.getConfig().getString("check-format.body");
+                for (Player loopP : this.plugin.getServer().getOnlinePlayers()) {
+                    HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(loopP);
+                    RPGHorse rpgHorse = horseOwner.getCurrentHorse();
+                    if (rpgHorse != null && rpgHorse.getHorse().getLocation().distance(loc) <= radius) {
+                        this.messagingUtil.sendMessage(sender, body.replace("{PLAYER}", loopP.getName()).replace("{HORSE-NUMBER}", "" + horseOwner.getHorseNumber(rpgHorse)).replace("{LOCATION}", LocationUtil.toBlockString(rpgHorse.getHorse().getLocation())), rpgHorse);
+                    }
+                }
+                this.messagingUtil.sendMessage(sender, this.plugin.getConfig().getString("listall-format.footer").replace("{RADIUS}", radiusArg));
+                return true;
+            }
+
+            if (arg1.equalsIgnoreCase("removenear")) {
+                if (!sender.hasPermission("rpghorses.removenear")) {
+                    this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+                    return false;
+                }
+
+                if (args.length < 2) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Not enough arguments, try &6/" + label.toLowerCase() + " removenear <radius>");
+                    return false;
+                }
+
+                Player p;
+                try {
+                    p = (Player) sender;
+                } catch (ClassCastException e) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}This command can only be used in-game");
+                    return false;
+                }
+                Location loc = p.getLocation();
+
+                String radiusArg = args[1];
+                if (!NumberUtil.isPositiveInt(radiusArg)) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Invalid radius value: &6" + radiusArg);
+                    return false;
+                }
+                int radius = Integer.valueOf(radiusArg);
+
+                int horseCount = 0;
+                for (Player loopP : this.plugin.getServer().getOnlinePlayers()) {
+                    HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(loopP);
+                    RPGHorse rpgHorse = horseOwner.getCurrentHorse();
+                    if (rpgHorse != null && rpgHorse.getHorse().getLocation().distance(loc) <= radius) {
+                        horseOwner.setCurrentHorse(null);
+                        this.messagingUtil.sendMessage(loopP, this.plugin.getConfig().getString("messages.horse-sent-to-stable").replace("{PLAYER}", p.getName()), rpgHorse);
+                        horseCount++;
+                    }
+                }
+                this.messagingUtil.sendMessage(sender, this.plugin.getConfig().getString("messages.horse-removenear").replace("{HORSE-COUNT}", "" + horseCount));
+                return true;
+            }
+
+            if (arg1.equalsIgnoreCase("purgeall")) {
+                if (!sender.hasPermission("rpghorses.purgeall")) {
+                    this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+                    return false;
+                }
+
+                if (args.length < 2) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Not enough arguments, try &6/" + label.toLowerCase() + " purgeall <radius>");
+                    return false;
+                }
+
+                Player p;
+                try {
+                    p = (Player) sender;
+                } catch (ClassCastException e) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}This command can only be used in-game");
+                    return false;
+                }
+                Location loc = p.getLocation();
+
+                String radiusArg = args[1];
+                if (!NumberUtil.isPositiveInt(radiusArg)) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Invalid radius value: &6" + radiusArg);
+                    return false;
+                }
+                int radius = Integer.valueOf(radiusArg);
+
+                int horseCount = 0;
+                for (Entity entity : p.getWorld().getNearbyEntities(p.getLocation(), radius, radius, radius)) {
+                    if (rpgHorseManager.isValidEntityType(entity.getType())) {
+                        RPGHorse rpgHorse = rpgHorseManager.getRPGHorse(entity);
+                        if (rpgHorse != null) {
+                            rpgHorse.despawnEntity();
+                        } else {
+                            horseCount++;
+                            entity.remove();
+                        }
+                    }
+                }
+                this.messagingUtil.sendMessage(sender, this.plugin.getConfig().getString("messages.horse-purgeall").replace("{HORSE-COUNT}", "" + horseCount));
+                return true;
+            }
+        }
+
+        if (!sender.hasPermission("rpghorses.help")) {
+            this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+            return false;
+        }
+
+        for (String line : this.plugin.getConfig().getStringList("messages.help-message")) {
+            this.messagingUtil.sendMessage(sender, line);
+        }
+
+        return true;
+    }
+
+    private boolean checkHorseArguments(CommandSender sender, OfflinePlayer offlinePlayer, String healthArg, String movementSpeedArg, String jumpStrengthArg, String typeArg, String colorArg, String styleArg, String horseNumberArg) {
+
+        if (!this.runHealthCheck(sender, healthArg)) {
+            return false;
+        }
+
+        if (!this.runMovementSpeedCheck(sender, movementSpeedArg)) {
+            return false;
+        }
+
+        if (!this.runJumpStrengthCheck(sender, jumpStrengthArg)) {
+            return false;
+        }
+
+        if (!this.runTypeCheck(sender, typeArg)) {
+            return false;
+        }
+
+        if (!this.runColorCheck(sender, colorArg)) {
+            return false;
+        }
+
+        if (!this.runStyleCheck(sender, styleArg)) {
+            return false;
+        }
+
+        if (!this.runHorseNumberCheck(sender, horseNumberArg, offlinePlayer)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    private boolean runHealthCheck(CommandSender sender, String healthArg) {
+        if (healthArg != null) {
+            if (!NumberUtil.isPositiveDouble(healthArg)) {
+                this.messagingUtil.sendMessage(sender, "{PREFIX}Invalid health value: &6" + healthArg);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean runMovementSpeedCheck(CommandSender sender, String movementSpeedArg) {
+        if (movementSpeedArg != null) {
+            if (!NumberUtil.isPositiveDouble(movementSpeedArg)) {
+                this.messagingUtil.sendMessage(sender, "{PREFIX}Invalid movement-speed value: &6" + movementSpeedArg);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean runJumpStrengthCheck(CommandSender sender, String jumpStrengthArg) {
+        if (jumpStrengthArg != null) {
+            if (!NumberUtil.isPositiveDouble(jumpStrengthArg)) {
+                this.messagingUtil.sendMessage(sender, "{PREFIX}Invalid jump-strength value: &6" + jumpStrengthArg);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean runTypeCheck(CommandSender sender, String typeArg) {
+        if (typeArg != null) {
+            if (!this.rpgHorseManager.isValidEntityType(typeArg)) {
+                this.messagingUtil.sendMessage(sender, "{PREFIX}Invalid type value: &6" + typeArg.toUpperCase());
+                this.messagingUtil.sendMessage(sender, "{PREFIX}Valid types: " + this.rpgHorseManager.getEntityTypesList());
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean runColorCheck(CommandSender sender, String colorArg) {
+        if (colorArg != null) {
+            if (!this.rpgHorseManager.isValidColor(colorArg)) {
+                this.messagingUtil.sendMessage(sender, "{PREFIX}Invalid color value: &6" + colorArg);
+                this.messagingUtil.sendMessage(sender, "{PREFIX}Valid colors: " + this.rpgHorseManager.getColorsList());
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean runStyleCheck(CommandSender sender, String styleArg) {
+        if (styleArg != null) {
+            if (!this.rpgHorseManager.isValidStyle(styleArg)) {
+                this.messagingUtil.sendMessage(sender, "{PREFIX}Invalid style value: &6" + styleArg);
+                this.messagingUtil.sendMessage(sender, "{PREFIX}Valid styles: " + this.rpgHorseManager.getStylesList());
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean runHorseNumberCheck(CommandSender sender, String horseNumberArg, OfflinePlayer offlinePlayer) {
+        if (horseNumberArg != null) {
+            if (!NumberUtil.isPositiveInt(horseNumberArg) || Integer.valueOf(horseNumberArg) < 1) {
+                this.messagingUtil.sendMessage(sender, "{PREFIX}Invalid horse-number value: &6" + horseNumberArg);
+                return false;
+            }
+
+            if (offlinePlayer != null) {
+                int horseCount = this.horseOwnerManager.getHorseCount(offlinePlayer);
+                if (horseCount < Integer.valueOf(horseNumberArg)) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}&6" + offlinePlayer.getName() + " &7only has &6" + horseCount + " &7RPGHorses");
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    private OfflinePlayer runPlayerCheck(CommandSender sender, String playerArg) {
+        OfflinePlayer p = Bukkit.getPlayer(playerArg);
+        UUID uuid;
+        if (p == null) {
+            uuid = SkinUtil.getUUIDFromName(playerArg);
+
+            if (uuid == null) {
+                this.messagingUtil.sendMessage(sender, "{PREFIX}&6" + playerArg + " &7has never played this server before");
+                return null;
+            }
+
+            p = Bukkit.getOfflinePlayer(uuid);
+
+            if (p == null || !p.hasPlayedBefore()) {
+                this.messagingUtil.sendMessage(sender, "{PREFIX}&6" + playerArg + " &7has never played this server before");
+                return null;
+            }
+        }
+        return p;
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/commands/RPGHorsesCommand.java b/src/org/plugins/rpghorses/commands/RPGHorsesCommand.java
new file mode 100644
index 0000000..5cf6011
--- /dev/null
+++ b/src/org/plugins/rpghorses/commands/RPGHorsesCommand.java
@@ -0,0 +1,250 @@
+package org.plugins.rpghorses.commands;
+
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.Particle;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.HorseCrate;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.managers.*;
+import org.plugins.rpghorses.players.HorseOwner;
+import org.plugins.rpghorses.utils.MessagingUtil;
+import org.plugins.rpghorses.utils.NumberUtil;
+
+public class RPGHorsesCommand implements CommandExecutor {
+
+    private final RPGHorsesMain plugin;
+    private final HorseOwnerManager horseOwnerManager;
+    private final StableGUIManager stableGUIManager;
+    private final MarketGUIManager marketGUIManager;
+    private final HorseCrateManager horseCrateManager;
+    private final ParticleManager particleManager;
+    private final Economy economy;
+    private final MessagingUtil messagingUtil;
+
+    public RPGHorsesCommand(RPGHorsesMain plugin, HorseOwnerManager horseOwnerManager, StableGUIManager stableGUIManager, MarketGUIManager marketGUIManager, HorseCrateManager horseCrateManager, ParticleManager particleManager, Economy economy, MessagingUtil messagingUtil) {
+        this.plugin = plugin;
+        this.horseOwnerManager = horseOwnerManager;
+        this.stableGUIManager = stableGUIManager;
+        this.marketGUIManager = marketGUIManager;
+        this.horseCrateManager = horseCrateManager;
+        this.particleManager = particleManager;
+        this.economy = economy;
+        this.messagingUtil = messagingUtil;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+
+        if (args.length > 0) {
+
+            String arg1 = args[0];
+
+            if (arg1.equalsIgnoreCase("sell")) {
+                if (!sender.hasPermission("rpghorses.sell")) {
+                    this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+                    return false;
+                }
+
+                if (!(sender instanceof Player)) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}This command can only be used in-game");
+                    return false;
+                }
+                Player p = (Player) sender;
+
+                if (args.length < 3) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Not enough arguments, try &6/" + label + " sell <horse-number> <price>");
+                    return false;
+                }
+
+                String horseNumberArg = args[1];
+                if (!this.runHorseNumberCheck(sender, horseNumberArg, p)) {
+                    return false;
+                }
+                int horseNumber = Integer.valueOf(horseNumberArg), index = horseNumber - 1;
+
+                String priceArg = args[2];
+                if (!NumberUtil.isPositiveDouble(priceArg)) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Invalid price argument &6" + priceArg);
+                    return false;
+                }
+                double price = Double.valueOf(priceArg);
+
+                HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p);
+                RPGHorse rpgHorse = horseOwner.getRPGHorse(index);
+                if (rpgHorse.isInMarket()) {
+                    this.messagingUtil.sendMessage(sender, this.plugin.getConfig().getString("messages.horse-already-in-market").replace("{HORSE-NUMBER}", "" + horseNumber));
+                    return false;
+                } else if (rpgHorse.isDead() || horseOwner.getCurrentHorse() == rpgHorse) {
+                    this.messagingUtil.sendMessage(sender, this.plugin.getConfig().getString("messages.horse-market-fail").replace("{HORSE-NUMBER}", "" + horseNumber));
+                    return false;
+                }
+
+                rpgHorse.setInMarket(true);
+                this.marketGUIManager.addHorse(rpgHorse, price, horseNumber - 1);
+                this.stableGUIManager.updateRPGHorse(rpgHorse);
+                this.messagingUtil.sendMessage(sender, this.plugin.getConfig().getString("messages.horse-added-to-market").replace("{HORSE-NUMBER}", "" + horseNumber));
+                return true;
+            }
+
+            if (arg1.equalsIgnoreCase("buy")) {
+                if (!sender.hasPermission("rpghorses.buy")) {
+                    this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+                    return false;
+                }
+
+                if (args.length < 2) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Not enough arguments, try &6/" + label + " buy <horse-crate>");
+                    return false;
+                }
+
+                if (!(sender instanceof Player)) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}This command can only be used in-game");
+                    return false;
+                }
+                Player p = (Player) sender;
+                HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p);
+
+                int horseCount = this.horseOwnerManager.getHorseCount(p);
+                if (horseCount >= this.horseOwnerManager.getHorseLimit(p)) {
+                    this.messagingUtil.sendMessage(sender, this.plugin.getConfig().getString("messages.horse-limit").replace("{PLAYER}", "CONSOLE"));
+                    return false;
+                }
+
+                HorseCrate horseCrate = this.horseCrateManager.getHorseCrate(args[1]);
+                if (horseCrate == null) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Invalid crate name: &6" + args[1]);
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Valid crate names: &6" + this.horseCrateManager.getHorseCrateList());
+                    return false;
+                }
+
+                if (this.economy.getBalance(p) < horseCrate.getPrice()) {
+                    this.messagingUtil.sendMessageAtPath(p, "messages.cant-afford-crate");
+                    return false;
+                }
+
+                this.economy.withdrawPlayer(p, horseCrate.getPrice());
+                RPGHorse rpgHorse = horseCrate.getRPGHorse(horseOwner);
+                horseOwner.addRPGHorse(rpgHorse);
+                this.stableGUIManager.setupStableGUI(horseOwner);
+                this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.horse-crate-bought").replace("{HORSE-CRATE}", horseCrate.getName()).replace("{PRICE}", "" + horseCrate.getPrice()));
+                return true;
+            }
+
+            if (arg1.equalsIgnoreCase("market")) {
+                if (!sender.hasPermission("rpghorses.market")) {
+                    this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+                    return false;
+                }
+
+                if (!(sender instanceof Player)) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}This command can only be used in-game");
+                    return false;
+                }
+                Player p = (Player) sender;
+
+                HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p);
+                horseOwner.openMarketGUIPage(this.marketGUIManager.getPage(1));
+                return true;
+            }
+
+            if (arg1.equalsIgnoreCase("trail")) {
+
+                if (!(sender instanceof Player)) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}This command can only be used in-game");
+                    return false;
+                }
+                Player p = (Player) sender;
+
+                if (args.length < 2) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}Not enough arguments, try &6/" + label + " trail <particle>");
+                    return false;
+                }
+
+                String particleArg = args[1];
+                Particle particle;
+                try {
+                    particle = Particle.valueOf(particleArg);
+                } catch (IllegalArgumentException e) {
+                    this.messagingUtil.sendMessage(p, "{PREFIX}Invalid particle argument: " + particleArg);
+                    this.messagingUtil.sendMessage(p, "{PREFIX}Valid particles: " + this.particleManager.getParticleList());
+                    return false;
+                }
+
+                if (!p.hasPermission("rpghorses.trail." + particle.name().toLowerCase()) && !p.hasPermission("rpghorses.trail.*")) {
+                    this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.no-permission-particles").replace("{PARTICLE}", particle.name()));
+                    return false;
+                }
+
+                HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p);
+                RPGHorse rpgHorse = horseOwner.getCurrentHorse();
+                if (rpgHorse == null) {
+                    this.messagingUtil.sendMessageAtPath(p, "messages.particle-fail");
+                    return false;
+                }
+
+                rpgHorse.setParticle(particle);
+                this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.particle-set").replace("{HORSE-NUMBER}", "" + horseOwner.getHorseNumber(rpgHorse)).replace("{PARTICLE}", particle.name()));
+                return true;
+            }
+
+        }
+
+        if (!sender.hasPermission("rpghorses.stable")) {
+            this.messagingUtil.sendMessageAtPath(sender, "messages.no-permission");
+            return false;
+        }
+
+        if (!(sender instanceof Player)) {
+            this.messagingUtil.sendMessage(sender, "{PREFIX}This command can only be used in-game");
+            return false;
+        }
+        Player p = (Player) sender;
+
+        HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p.getUniqueId());
+        if (horseOwner.getStableGUI() == null) {
+            this.stableGUIManager.setupStableGUI(horseOwner);
+        } else {
+            for (RPGHorse rpgHorse : horseOwner.getRPGHorses()) {
+                if (rpgHorse.hasGainedXP()) {
+                    stableGUIManager.updateRPGHorse(rpgHorse);
+                    rpgHorse.setGainedXP(false);
+                }
+            }
+        }
+        
+        if (horseOwner.getRPGHorses().size() == 0) {
+            this.messagingUtil.sendMessageAtPath(p, "messages.no-horses");
+            return false;
+        }
+        
+        horseOwner.openStableGUIPage(1);
+        return true;
+    }
+
+    private boolean runHorseNumberCheck
+            (CommandSender
+                     sender, String
+                     horseNumberArg, OfflinePlayer
+                     offlinePlayer) {
+        if (horseNumberArg != null) {
+            if (!NumberUtil.isPositiveInt(horseNumberArg) || Integer.valueOf(horseNumberArg) < 1) {
+                this.messagingUtil.sendMessage(sender, "{PREFIX}Invalid horse-number value: &6" + horseNumberArg);
+                return false;
+            }
+
+            if (offlinePlayer != null) {
+                int horseCount = this.horseOwnerManager.getHorseCount(offlinePlayer);
+                if (horseCount < Integer.valueOf(horseNumberArg)) {
+                    this.messagingUtil.sendMessage(sender, "{PREFIX}&6" + offlinePlayer.getName() + " &7only has &6" + horseCount + " &7RPGHorses");
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
diff --git a/src/org/plugins/rpghorses/configs/CustomConfig.java b/src/org/plugins/rpghorses/configs/CustomConfig.java
new file mode 100644
index 0000000..20cce4a
--- /dev/null
+++ b/src/org/plugins/rpghorses/configs/CustomConfig.java
@@ -0,0 +1,76 @@
+package org.plugins.rpghorses.configs;
+
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.*;
+
+/**
+ * Created by Rory on 6/18/2017.
+ */
+public class CustomConfig {
+
+    private final JavaPlugin plugin;
+    private final String fileName;
+
+    private FileConfiguration config = null;
+    private File file = null;
+
+    public CustomConfig(JavaPlugin plugin, String fileName) {
+        this.plugin = plugin;
+        this.fileName = fileName;
+    }
+
+    public void reloadConfig() {
+        if (this.file == null) {
+            this.file = new File(this.plugin.getDataFolder(), this.fileName + ".yml");
+        }
+        this.config = YamlConfiguration.loadConfiguration(this.file);
+
+        // Look for defaults in the jar
+        if (this.plugin != null) {
+            try {
+                InputStream inputStream = this.plugin.getResource(this.fileName + ".yml");
+                if (inputStream != null) {
+                    Reader defConfigStream = new InputStreamReader(inputStream, "UTF8");
+                    if (defConfigStream != null) {
+                        YamlConfiguration defConfig = YamlConfiguration.loadConfiguration(defConfigStream);
+                        this.config.setDefaults(defConfig);
+                        this.config.options().copyDefaults(true);
+                    }
+                }
+            } catch (UnsupportedEncodingException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public FileConfiguration getConfig() {
+        if (this.config == null) {
+            reloadConfig();
+        }
+        return this.config;
+    }
+
+    public void saveConfig() {
+        if (this.config == null || this.file == null) {
+            return;
+        }
+        try {
+            getConfig().save(this.file);
+        } catch (IOException ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    public void saveDefaultConfig() {
+        if (this.file == null) {
+            this.file = new File(this.plugin.getDataFolder(), this.fileName + ".yml");
+        }
+        if (!this.file.exists()) {
+            this.plugin.saveResource(this.fileName + ".yml", false);
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/org/plugins/rpghorses/configs/PlayerConfigs.java b/src/org/plugins/rpghorses/configs/PlayerConfigs.java
new file mode 100644
index 0000000..a6fccbf
--- /dev/null
+++ b/src/org/plugins/rpghorses/configs/PlayerConfigs.java
@@ -0,0 +1,92 @@
+package org.plugins.rpghorses.configs;
+
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.UUID;
+
+/**
+ * Created by Rory on 6/18/2017.
+ */
+public class PlayerConfigs {
+
+    private JavaPlugin plugin;
+
+    private HashMap<UUID, File> playerFiles = new HashMap<>();
+    private HashMap<UUID, FileConfiguration> playerConfigs = new HashMap<>();
+
+    public PlayerConfigs(JavaPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void reloadConfig(Player p) {
+        this.reloadConfig(p.getUniqueId());
+    }
+
+    public void reloadConfig(UUID uuid) {
+        if (!this.playerFiles.containsKey(uuid)) {
+            File pathFile = new File(this.plugin.getDataFolder().getPath() + File.separator + "playerdata");
+            pathFile.mkdir();
+            File file = new File(pathFile, uuid.toString() + ".yml");
+            if (!file.exists()) {
+                try {
+                    file.createNewFile();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            this.playerFiles.put(uuid, file);
+        }
+        FileConfiguration config = YamlConfiguration.loadConfiguration(this.playerFiles.get(uuid));
+        this.playerConfigs.put(uuid, config);
+    }
+
+    public FileConfiguration getConfig(Player p) {
+        return this.getConfig(p.getUniqueId());
+    }
+
+    public FileConfiguration getConfig(UUID uuid) {
+        if (!this.playerConfigs.containsKey(uuid)) {
+            reloadConfig(uuid);
+        }
+        return this.playerConfigs.get(uuid);
+    }
+
+    public HashMap<UUID, FileConfiguration> getConfigs() {
+        HashMap<UUID, FileConfiguration> configs = new HashMap<>();
+        for (File file : (new File(this.plugin.getDataFolder().getPath() + File.separator + "playerdata")).listFiles()) {
+            String fileName = file.getName();
+            UUID uuid = UUID.fromString(fileName.substring(0, fileName.length() - 4));
+            this.playerFiles.put(uuid, file);
+            configs.put(uuid, YamlConfiguration.loadConfiguration(file));
+        }
+        return configs;
+    }
+
+    public void saveConfig(Player p) {
+        this.saveConfig(p.getUniqueId());
+    }
+
+    public void saveConfig(UUID uuid) {
+        if (!this.playerConfigs.containsKey(uuid) || !this.playerFiles.containsKey(uuid)) {
+            return;
+        }
+        try {
+            getConfig(uuid).save(this.playerFiles.get(uuid));
+        } catch (IOException ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    public void deleteConfig(UUID uuid) {
+        if (this.playerFiles.containsKey(uuid)) {
+            this.playerFiles.get(uuid).delete();
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/org/plugins/rpghorses/guis/MarketGUIPage.java b/src/org/plugins/rpghorses/guis/MarketGUIPage.java
new file mode 100644
index 0000000..b40ca59
--- /dev/null
+++ b/src/org/plugins/rpghorses/guis/MarketGUIPage.java
@@ -0,0 +1,39 @@
+package org.plugins.rpghorses.guis;
+
+import org.bukkit.inventory.Inventory;
+import org.plugins.rpghorses.horses.RPGHorse;
+
+import java.util.HashMap;
+
+public class MarketGUIPage {
+
+    private int pageNum;
+    private Inventory gui;
+    HashMap<Integer, RPGHorse> horseSlots;
+
+    public MarketGUIPage(int pageNum, Inventory gui, HashMap<Integer, RPGHorse> horseSlots) {
+        this.pageNum = pageNum;
+        this.gui = gui;
+        this.horseSlots = horseSlots;
+    }
+
+    public int getPageNum() {
+        return pageNum;
+    }
+
+    public Inventory getGUI() {
+        return gui;
+    }
+
+    public void setGUI(Inventory gui) {
+        this.gui = gui;
+    }
+
+    public RPGHorse getRPGHorse(int slot) {
+        return this.horseSlots.get(slot);
+    }
+
+    public HashMap<Integer, RPGHorse> getHorseSlots() {
+        return horseSlots;
+    }
+}
diff --git a/src/org/plugins/rpghorses/guis/StableGUI.java b/src/org/plugins/rpghorses/guis/StableGUI.java
new file mode 100644
index 0000000..1dda948
--- /dev/null
+++ b/src/org/plugins/rpghorses/guis/StableGUI.java
@@ -0,0 +1,80 @@
+package org.plugins.rpghorses.guis;
+
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.players.HorseOwner;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class StableGUI {
+
+    private HorseOwner horseOwner;
+
+    private List<StableGUIPage> stableGUIPages = new ArrayList<>();
+
+    public StableGUI(HorseOwner horseOwner, List<StableGUIPage> stableGUIPages) {
+        this.horseOwner = horseOwner;
+        this.stableGUIPages = stableGUIPages;
+    }
+
+    public HorseOwner getHorseOwner() {
+        return horseOwner;
+    }
+
+    public List<StableGUIPage> getStableGUIPages() {
+        return stableGUIPages;
+    }
+
+    public void setStableGUIPages(List<StableGUIPage> stableGUIPages) {
+        this.stableGUIPages = stableGUIPages;
+    }
+
+    public StableGUIPage getPage(int page) {
+        if (page >= 1 && this.stableGUIPages.size() >= page) {
+        return this.stableGUIPages.get(page - 1);}
+        return null;
+    }
+
+    public void addGlow(RPGHorse rpgHorse) {
+        RPGHorse oldHorse = this.horseOwner.getCurrentHorse();
+        if (oldHorse != rpgHorse) {
+            boolean foundOldHorse = oldHorse == null;
+            boolean foundNewHorse = rpgHorse == null;
+            for (StableGUIPage stableGUIPage : this.stableGUIPages) {
+                HashMap<Integer, RPGHorse> rpgHorses = stableGUIPage.getHorseSlots();
+                for (Integer slot : rpgHorses.keySet()) {
+                    RPGHorse loopHorse = rpgHorses.get(slot);
+                    if (loopHorse == oldHorse) {
+                        ItemStack item = stableGUIPage.getGUI().getItem(slot);
+                        ItemMeta itemMeta = item.getItemMeta();
+                        itemMeta.removeEnchant(Enchantment.DURABILITY);
+                        itemMeta.removeItemFlags(ItemFlag.HIDE_ENCHANTS);
+                        item.setItemMeta(itemMeta);
+                        foundOldHorse = true;
+                        if (foundNewHorse) {
+                            return;
+                        }
+                    } else if (loopHorse == rpgHorse) {
+                        ItemStack item = stableGUIPage.getGUI().getItem(slot);
+                        ItemMeta itemMeta = item.getItemMeta();
+                        itemMeta.addItemFlags(ItemFlag.HIDE_ENCHANTS);
+                        itemMeta.addEnchant(Enchantment.DURABILITY, 10, true);
+                        item.setItemMeta(itemMeta);
+                        if (this.horseOwner.isInStableInventory() && this.horseOwner.getCurrentStableGUIPage() == stableGUIPage) {
+                            this.horseOwner.openStableGUIPage(stableGUIPage.getPageNum());
+                        }
+                        foundNewHorse = true;
+                        if (foundOldHorse) {
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/org/plugins/rpghorses/guis/StableGUIPage.java b/src/org/plugins/rpghorses/guis/StableGUIPage.java
new file mode 100644
index 0000000..6ae8026
--- /dev/null
+++ b/src/org/plugins/rpghorses/guis/StableGUIPage.java
@@ -0,0 +1,46 @@
+package org.plugins.rpghorses.guis;
+
+import org.bukkit.inventory.Inventory;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.players.HorseOwner;
+
+import java.util.HashMap;
+
+public class StableGUIPage {
+
+    private HorseOwner horseOwner;
+    private int pageNum;
+    private Inventory gui;
+    HashMap<Integer, RPGHorse> horseSlots;
+
+    public StableGUIPage(HorseOwner horseOwner, int pageNum, Inventory gui, HashMap<Integer, RPGHorse> horseSlots) {
+        this.horseOwner = horseOwner;
+        this.pageNum = pageNum;
+        this.gui = gui;
+        this.horseSlots = horseSlots;
+    }
+
+    public HorseOwner getHorseOwner() {
+        return horseOwner;
+    }
+
+    public int getPageNum() {
+        return pageNum;
+    }
+
+    public Inventory getGUI() {
+        return gui;
+    }
+
+    public void setGUI(Inventory gui) {
+        this.gui = gui;
+    }
+
+    public RPGHorse getRPGHorse(int slot) {
+        return this.horseSlots.get(slot);
+    }
+
+    public HashMap<Integer, RPGHorse> getHorseSlots() {
+        return horseSlots;
+    }
+}
diff --git a/src/org/plugins/rpghorses/guis/UpgradeGUI.java b/src/org/plugins/rpghorses/guis/UpgradeGUI.java
new file mode 100644
index 0000000..89f056c
--- /dev/null
+++ b/src/org/plugins/rpghorses/guis/UpgradeGUI.java
@@ -0,0 +1,24 @@
+package org.plugins.rpghorses.guis;
+
+import org.bukkit.inventory.Inventory;
+import org.plugins.rpghorses.horses.RPGHorse;
+
+public class UpgradeGUI {
+
+    private Inventory inventory;
+    private RPGHorse rpgHorse;
+
+    public UpgradeGUI(RPGHorse rpgHorse, Inventory inventory) {
+        this.rpgHorse = rpgHorse;
+        this.inventory = inventory;
+    }
+
+    public RPGHorse getRPGHorse() {
+        return rpgHorse;
+    }
+
+    public Inventory getInventory() {
+        return this.inventory;
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/guis/YourHorsesGUI.java b/src/org/plugins/rpghorses/guis/YourHorsesGUI.java
new file mode 100644
index 0000000..bc14a0f
--- /dev/null
+++ b/src/org/plugins/rpghorses/guis/YourHorsesGUI.java
@@ -0,0 +1,36 @@
+package org.plugins.rpghorses.guis;
+
+import org.plugins.rpghorses.players.HorseOwner;
+
+import java.util.List;
+
+public class YourHorsesGUI {
+
+    private HorseOwner horseOwner;
+
+    private List<YourHorsesGUIPage> yourHorsesGUIPages;
+
+    public YourHorsesGUI(HorseOwner horseOwner, List<YourHorsesGUIPage> yourHorsesGUIPages) {
+        this.horseOwner = horseOwner;
+        this.yourHorsesGUIPages = yourHorsesGUIPages;
+    }
+
+    public HorseOwner getHorseOwner() {
+        return horseOwner;
+    }
+
+    public List<YourHorsesGUIPage> getYourHorsesGUIPages() {
+        return yourHorsesGUIPages;
+    }
+
+    public void setYourHorsesGUIPages(List<YourHorsesGUIPage> yourHorsesGUIPages) {
+        this.yourHorsesGUIPages = yourHorsesGUIPages;
+    }
+
+    public YourHorsesGUIPage getPage(int page) {
+        if (page >= 1 && this.yourHorsesGUIPages.size() >= page) {
+            return this.yourHorsesGUIPages.get(page - 1);
+        }
+        return null;
+    }
+}
diff --git a/src/org/plugins/rpghorses/guis/YourHorsesGUIPage.java b/src/org/plugins/rpghorses/guis/YourHorsesGUIPage.java
new file mode 100644
index 0000000..b0f4120
--- /dev/null
+++ b/src/org/plugins/rpghorses/guis/YourHorsesGUIPage.java
@@ -0,0 +1,39 @@
+package org.plugins.rpghorses.guis;
+
+import org.bukkit.inventory.Inventory;
+import org.plugins.rpghorses.horses.MarketHorse;
+
+import java.util.HashMap;
+
+public class YourHorsesGUIPage {
+
+    private int pageNum;
+    private Inventory gui;
+    HashMap<Integer, MarketHorse> horseSlots;
+
+    public YourHorsesGUIPage(int pageNum, Inventory gui, HashMap<Integer, MarketHorse> horseSlots) {
+        this.pageNum = pageNum;
+        this.gui = gui;
+        this.horseSlots = horseSlots;
+    }
+
+    public int getPageNum() {
+        return pageNum;
+    }
+
+    public Inventory getGUI() {
+        return gui;
+    }
+
+    public void setGUI(Inventory gui) {
+        this.gui = gui;
+    }
+
+    public MarketHorse getMarketHorse(int slot) {
+        return this.horseSlots.get(slot);
+    }
+
+    public HashMap<Integer, MarketHorse> getHorseSlots() {
+        return horseSlots;
+    }
+}
diff --git a/src/org/plugins/rpghorses/horses/HorseCrate.java b/src/org/plugins/rpghorses/horses/HorseCrate.java
new file mode 100644
index 0000000..96f3d93
--- /dev/null
+++ b/src/org/plugins/rpghorses/horses/HorseCrate.java
@@ -0,0 +1,48 @@
+package org.plugins.rpghorses.horses;
+
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Horse;
+import org.plugins.rpghorses.players.HorseOwner;
+
+import java.util.Random;
+
+public class HorseCrate {
+
+    private double price;
+    private String name;
+    private double minHealth, maxHealth, minMovementSpeed, maxMovementSpeed, minJumpStrength, maxJumpStrength;
+    private EntityType entityType;
+    private Horse.Color color;
+    private Horse.Style style;
+    private int tier;
+
+    public HorseCrate(String name, double price, double minHealth, double maxHealth, double minMovementSpeed, double maxMovementSpeed, double minJumpStrength, double maxJumpStrength, EntityType entityType, Horse.Color color, Horse.Style style, int tier) {
+        this.name = name;
+        this.price = price;
+        this.minHealth = minHealth;
+        this.maxHealth = maxHealth;
+        this.minMovementSpeed = minMovementSpeed;
+        this.maxMovementSpeed = maxMovementSpeed;
+        this.minJumpStrength = minJumpStrength;
+        this.maxJumpStrength = maxJumpStrength;
+        this.entityType = entityType;
+        this.color = color;
+        this.style = style;
+        this.tier = tier;
+    }
+
+    public RPGHorse getRPGHorse(HorseOwner horseOwner) {
+        double health = new Random().nextDouble() * (this.maxHealth - this.minHealth) + this.minHealth;
+        double movementSpeed = new Random().nextDouble() * (this.maxMovementSpeed - this.minMovementSpeed) + this.minMovementSpeed;
+        double jumpStrength = new Random().nextDouble() * (this.maxJumpStrength - this.minJumpStrength) + this.minJumpStrength;
+        return new RPGHorse(horseOwner, this.tier, 0, null, health, movementSpeed, jumpStrength, this.entityType, this.color, this.style, false, null);
+    }
+
+    public double getPrice() {
+        return price;
+    }
+
+    public String getName() {
+        return name;
+    }
+}
diff --git a/src/org/plugins/rpghorses/horses/MarketHorse.java b/src/org/plugins/rpghorses/horses/MarketHorse.java
new file mode 100644
index 0000000..7190151
--- /dev/null
+++ b/src/org/plugins/rpghorses/horses/MarketHorse.java
@@ -0,0 +1,25 @@
+package org.plugins.rpghorses.horses;
+
+public class MarketHorse {
+
+    private RPGHorse rpgHorse;
+    private double price;
+    private int index;
+
+    public MarketHorse(int index, RPGHorse rpgHorse, double price) {
+        this.rpgHorse = rpgHorse;
+        this.price = price;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+
+    public RPGHorse getRPGHorse() {
+        return rpgHorse;
+    }
+
+    public double getPrice() {
+        return price;
+    }
+}
diff --git a/src/org/plugins/rpghorses/horses/RPGHorse.java b/src/org/plugins/rpghorses/horses/RPGHorse.java
new file mode 100644
index 0000000..57a3521
--- /dev/null
+++ b/src/org/plugins/rpghorses/horses/RPGHorse.java
@@ -0,0 +1,366 @@
+package org.plugins.rpghorses.horses;
+
+import com.google.common.collect.Sets;
+import net.minecraft.server.v1_12_R1.EntityCreature;
+import net.minecraft.server.v1_12_R1.PathfinderGoalSelector;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Particle;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.craftbukkit.v1_12_R1.entity.CraftEntity;
+import org.bukkit.entity.*;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.plugins.rpghorses.players.HorseOwner;
+import org.plugins.rpghorses.utils.MessagingUtil;
+
+import java.lang.reflect.Field;
+import java.util.HashMap;
+
+public class RPGHorse {
+
+    private HorseOwner horseOwner;
+    private String name;
+    private AbstractHorse horse;
+    private int tier = 1;
+    private double xp = 0, health = 0, maxHealth = 20, movementSpeed = 1.0, jumpStrength = 1.0;
+    private EntityType entityType = EntityType.HORSE;
+    private Horse.Color color = Horse.Color.BROWN;
+    private Horse.Style style = Horse.Style.NONE;
+    private HashMap<Integer, ItemStack> items = new HashMap<>();
+    private boolean dead, inMarket, gainedXP;
+    private Long deathTime;
+    private Particle particle;
+
+    public RPGHorse(HorseOwner horseOwner, int tier, double xp, String name, double health, double movementSpeed, double jumpStrength, EntityType entityType, Horse.Color color, Horse.Style style, boolean inMarket, Particle particle) {
+        this.horseOwner = horseOwner;
+        this.setName(name);
+        this.setTier(tier);
+        this.setXp(xp);
+        this.setMovementSpeed(movementSpeed);
+        this.setJumpStrength(jumpStrength);
+        this.setHealth(health);
+        this.setEntityType(entityType);
+        this.setColor(color);
+        this.setStyle(style);
+        this.setInMarket(inMarket);
+        this.setParticle(particle);
+        items.put(0, new ItemStack(Material.SADDLE));
+        setItems(items);
+    }
+
+    public RPGHorse(HorseOwner horseOwner, int tier, double xp, String name, double health, double movementSpeed, double jumpStrength, EntityType entityType, Horse.Color color, Horse.Style style, boolean inMarket, Particle particle, HashMap<Integer, ItemStack> items) {
+        this(horseOwner, tier, xp, name, health, movementSpeed, jumpStrength, entityType, color, style, inMarket, particle);
+        this.setItems(items);
+    }
+
+    public void setHorseOwner(HorseOwner horseOwner) {
+        this.horseOwner = horseOwner;
+    }
+
+    public HorseOwner getHorseOwner() {
+        return horseOwner;
+    }
+
+    public AbstractHorse getHorse() {
+        return horse;
+    }
+
+    public int getTier() {
+        return tier;
+    }
+
+    public void setTier(int tier) {
+        if (tier > 0 && this.tier != tier) {
+            this.tier = tier;
+            setXp(0);
+            gainedXP = false;
+        }
+    }
+    
+    public double getXp() {
+        return xp;
+    }
+    
+    public void increaseXp(double xp) {
+        this.xp += xp;
+        gainedXP = true;
+    }
+    
+    public void setXp(double xp) {
+        this.xp = xp;
+    }
+    
+    public String getName() {
+        if (name == null) {
+            return "";
+        }
+        return name;
+    }
+
+    public void setName(String name) {
+        if (name != null) {
+            this.name = name;
+            if (this.horse != null) {
+                this.horse.setCustomName(MessagingUtil.format("&7" + this.name));
+                this.horse.setCustomNameVisible(true);
+            }
+        }
+    }
+
+    public double getHealth() {
+        return this.health;
+    }
+
+    public void setHealth(double health) {
+        if (health > 0) {
+            this.health = health;
+
+            if (this.health != this.maxHealth) {
+                this.setMaxHealth(health);
+            }
+        } else {
+            this.setDead(true);
+            this.refreshDeathTime();
+        }
+    }
+
+    public double getMaxHealth() {
+        return maxHealth;
+    }
+
+    public void setMaxHealth(double maxHealth) {
+        if (maxHealth > 0) {
+            this.maxHealth = maxHealth;
+        }
+    }
+
+    public double getMovementSpeed() {
+        return this.movementSpeed;
+    }
+
+    public void setMovementSpeed(double newSpeed) {
+        if (newSpeed > 0) {
+            this.movementSpeed = newSpeed;
+            if (this.horse != null) {
+                this.horse.getAttribute(Attribute.GENERIC_MOVEMENT_SPEED).setBaseValue(this.movementSpeed);
+            }
+        }
+    }
+
+    public double getJumpStrength() {
+        return this.jumpStrength;
+    }
+
+    public void setJumpStrength(double jumpStrength) {
+        if (jumpStrength > 0) {
+            this.jumpStrength = jumpStrength;
+            if (this.horse != null) {
+                this.horse.setJumpStrength(jumpStrength);
+            }
+        }
+    }
+
+    public EntityType getEntityType() {
+        return this.entityType;
+    }
+
+    public void setEntityType(EntityType entityType) {
+        if (this.entityType != null) {
+            this.entityType = entityType;
+        }
+    }
+
+    public Horse.Color getColor() {
+        return this.color;
+    }
+
+    public void setColor(Horse.Color color) {
+        this.color = color;
+    }
+
+    public Horse.Style getStyle() {
+        return this.style;
+    }
+
+    public void setStyle(Horse.Style style) {
+        this.style = style;
+    }
+
+    public HashMap<Integer, ItemStack> getItems() {
+        return items;
+    }
+
+    public void setItems(HashMap<Integer, ItemStack> items) {
+        this.items = items;
+        if (this.horse != null) {
+            Inventory inventory = this.horse.getInventory();
+            for (Integer slot : items.keySet()) {
+                inventory.setItem(slot, items.get(slot));
+            }
+        }
+    }
+
+    public void loadItems() {
+        if (this.horse != null) {
+            Inventory inventory = this.horse.getInventory();
+            for (int slot = 0; slot < inventory.getSize(); slot++) {
+                this.items.put(slot, inventory.getItem(slot));
+            }
+        }
+    }
+
+    public void loadHealth() {
+        if (this.horse != null) {
+            this.health = this.horse.getHealth();
+        }
+    }
+
+    public boolean isDead() {
+        return dead;
+    }
+
+    public void setDead(boolean dead) {
+        if (this.dead == true && dead == false) {
+            this.setHealth(this.maxHealth);
+            if (this.horse != null) {
+                this.horse.setHealth(this.health);
+            }
+        }
+        this.dead = dead;
+    }
+    
+    public boolean hasGainedXP() {
+        return gainedXP;
+    }
+    
+    public void setGainedXP(boolean gainedXP) {
+        this.gainedXP = gainedXP;
+    }
+    
+    public Long getDeathTime() {
+        return deathTime;
+    }
+
+    public void refreshDeathTime() {
+        this.deathTime = System.currentTimeMillis();
+    }
+
+    public void setDeathTime(Long deathTime) {
+        this.deathTime = deathTime;
+    }
+
+    public boolean isInMarket() {
+        return inMarket;
+    }
+
+    public void setInMarket(boolean inMarket) {
+        this.inMarket = inMarket;
+    }
+
+    public void setParticle(Particle particle) {
+        this.particle = particle;
+    }
+
+    public Particle getParticle() {
+        return this.particle;
+    }
+
+    public void spawnEntity() {
+        Player p = Bukkit.getPlayer(horseOwner.getUUID());
+        if (p != null && p.isOnline()) {
+            Location horseLoc = p.getLocation();
+
+            if (this.horse != null) {
+                horseLoc = this.horse.getLocation();
+                this.despawnEntity();
+            }
+
+            this.horseOwner.setSpawningHorse(true);
+            this.horse = (AbstractHorse) horseLoc.getWorld().spawnEntity(horseLoc, entityType);
+            
+            this.horse.getAttribute(Attribute.GENERIC_MAX_HEALTH).setBaseValue(this.maxHealth);
+            this.horse.setHealth(health);
+
+            this.horse.getAttribute(Attribute.GENERIC_MOVEMENT_SPEED).setBaseValue(this.movementSpeed);
+
+            this.horse.setJumpStrength(this.jumpStrength);
+
+            if (this.name != null) {
+                this.horse.setCustomName(MessagingUtil.format("&7" + this.name));
+                this.horse.setCustomNameVisible(true);
+            }
+
+            this.horse.setAdult();
+            this.horse.setAgeLock(true);
+            this.horse.setOwner(p);
+            this.horse.setRemoveWhenFarAway(false);
+
+            this.removeWanderingBehavior(this.horse);
+
+            if (this.entityType == EntityType.HORSE) {
+                Horse horse = (Horse) this.horse;
+                horse.setColor(this.color);
+                horse.setStyle(style);
+            } else if (this.entityType == EntityType.DONKEY) {
+                ChestedHorse chestedHorse = (ChestedHorse) this.horse;
+                chestedHorse.setCarryingChest(true);
+            }
+
+            Inventory inventory = this.horse.getInventory();
+            for (Integer slot : this.items.keySet()) {
+                inventory.setItem(slot, this.items.get(slot));
+            }
+        }
+    }
+
+    public void despawnEntity() {
+        if (this.horse != null) {
+            this.loadItems();
+            this.loadHealth();
+            this.horse.remove();
+            this.horse = null;
+        }
+    }
+
+    public void removeWanderingBehavior(LivingEntity entity) {
+        EntityCreature creature = (EntityCreature) (((CraftEntity) entity).getHandle());
+
+        try {
+            Field b = PathfinderGoalSelector.class.getDeclaredField("b");
+            b.setAccessible(true);
+            b.set(creature.goalSelector, Sets.newLinkedHashSet());
+            b.set(creature.targetSelector, Sets.newLinkedHashSet());
+            
+            Field c = PathfinderGoalSelector.class.getDeclaredField("c");
+            c.setAccessible(true);
+            c.set(creature.goalSelector, Sets.newLinkedHashSet());
+            c.set(creature.targetSelector, Sets.newLinkedHashSet());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (object == null || !(object instanceof RPGHorse)) {
+            return false;
+        }
+        return this.equals((RPGHorse) object);
+    }
+
+    public boolean equals(RPGHorse rpgHorse) {
+        /*Bukkit.getLogger().info("tier equals? " + (this.tier == rpgHorse.tier));
+        Bukkit.getLogger().info("health equals? " + (this.health == rpgHorse.health));
+        Bukkit.getLogger().info("maxHealth equals? " + (this.maxHealth == rpgHorse.maxHealth));
+        Bukkit.getLogger().info("movementSpeed equals? " + (this.movementSpeed == rpgHorse.movementSpeed));
+        Bukkit.getLogger().info("jumpStrength equals? " + (this.jumpStrength == rpgHorse.jumpStrength));
+        Bukkit.getLogger().info("entityType equals? " + (this.entityType == rpgHorse.entityType));
+        Bukkit.getLogger().info("style equals? " + (this.style == rpgHorse.style));
+        Bukkit.getLogger().info("color equals? " + (this.color == rpgHorse.color));
+        Bukkit.getLogger().info("horseOwner uuid equals? " + (this.horseOwner.getUUID().equals(rpgHorse.getHorseOwner().getUUID())));*/
+        return this.tier == rpgHorse.tier && this.health == rpgHorse.health && this.maxHealth == rpgHorse.maxHealth && this.movementSpeed == rpgHorse.movementSpeed && this.jumpStrength == rpgHorse.jumpStrength && this.entityType == rpgHorse.entityType && this.style == rpgHorse.style && this.color == rpgHorse.color && this.horseOwner.getUUID().equals(rpgHorse.getHorseOwner().getUUID());
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/listeners/EntityDamageByEntityListener.java b/src/org/plugins/rpghorses/listeners/EntityDamageByEntityListener.java
new file mode 100644
index 0000000..5d15255
--- /dev/null
+++ b/src/org/plugins/rpghorses/listeners/EntityDamageByEntityListener.java
@@ -0,0 +1,65 @@
+package org.plugins.rpghorses.listeners;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.projectiles.ProjectileSource;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.managers.RPGHorseManager;
+import org.plugins.rpghorses.managers.StableGUIManager;
+
+public class EntityDamageByEntityListener implements Listener {
+
+    private final RPGHorseManager rpgHorseManager;
+    private final StableGUIManager stableGuiManager;
+
+    public EntityDamageByEntityListener(RPGHorsesMain plugin, RPGHorseManager rpgHorseManager, StableGUIManager stableGuiManager) {
+        this.rpgHorseManager = rpgHorseManager;
+        this.stableGuiManager = stableGuiManager;
+
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
+    public void onEntityDamageByEntity(EntityDamageByEntityEvent e) {
+        Entity victim = e.getEntity();
+        Entity damager = e.getDamager();
+        if (this.rpgHorseManager.isValidEntityType(victim.getType())) {
+            EntityType damagerType = damager.getType(), victimType = victim.getType();
+            Player damagerPlayer = null;
+
+            if (damager.getType() == EntityType.PLAYER) {
+                damagerPlayer = (Player) damager;
+            } else if (damagerType == EntityType.ARROW || damagerType == EntityType.EGG || damagerType == EntityType.ENDER_PEARL || damagerType == EntityType.FISHING_HOOK || damagerType == EntityType.SPLASH_POTION || damagerType == EntityType.SNOWBALL) {
+                Projectile projectile = (Projectile) e.getDamager();
+                ProjectileSource projectileSource = projectile.getShooter();
+                if (projectileSource instanceof Player) damagerPlayer = (Player) projectileSource;
+            }
+
+            if (damagerPlayer != null) {
+                e.setCancelled(true);
+            }
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
+    public void onEntityDamage(EntityDamageEvent e) {
+        Entity damaged = e.getEntity();
+        if (this.rpgHorseManager.isValidEntityType(damaged.getType())) {
+            RPGHorse rpgHorse = this.rpgHorseManager.getRPGHorse(damaged);
+            if (rpgHorse != null) {
+                rpgHorse.loadHealth();
+                this.stableGuiManager.updateRPGHorse(rpgHorse);
+
+            }
+        }
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/listeners/EntityDeathListener.java b/src/org/plugins/rpghorses/listeners/EntityDeathListener.java
new file mode 100644
index 0000000..b183778
--- /dev/null
+++ b/src/org/plugins/rpghorses/listeners/EntityDeathListener.java
@@ -0,0 +1,48 @@
+package org.plugins.rpghorses.listeners;
+
+import org.bukkit.entity.EntityType;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDeathEvent;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.managers.RPGHorseManager;
+import org.plugins.rpghorses.managers.StableGUIManager;
+import org.plugins.rpghorses.managers.XPManager;
+import org.plugins.rpghorses.players.HorseOwner;
+
+public class EntityDeathListener implements Listener {
+
+    private final RPGHorseManager rpgHorseManager;
+    private final StableGUIManager stableGuiManager;
+    private final XPManager xpManager;
+
+    public EntityDeathListener(RPGHorsesMain plugin, RPGHorseManager rpgHorseManager, StableGUIManager stableGuiManager, XPManager xpManager) {
+        this.rpgHorseManager = rpgHorseManager;
+        this.stableGuiManager = stableGuiManager;
+        this.xpManager = xpManager;
+
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
+    public void onEntityDeath(EntityDeathEvent e) {
+        EntityType entityType = e.getEntityType();
+        if (this.rpgHorseManager.isValidEntityType(entityType)) {
+            RPGHorse rpgHorse = this.rpgHorseManager.getRPGHorse(e.getEntity());
+            if (rpgHorse != null) {
+                HorseOwner horseOwner = rpgHorse.getHorseOwner();
+                rpgHorse.loadItems();
+                horseOwner.setCurrentHorse(null);
+                rpgHorse.setDead(true);
+                rpgHorse.refreshDeathTime();
+                e.getDrops().clear();
+    
+                this.stableGuiManager.updateRPGHorse(rpgHorse);
+                xpManager.removeHorseOwner(horseOwner);
+            }
+        }
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/listeners/EntitySpawnListener.java b/src/org/plugins/rpghorses/listeners/EntitySpawnListener.java
new file mode 100644
index 0000000..488f799
--- /dev/null
+++ b/src/org/plugins/rpghorses/listeners/EntitySpawnListener.java
@@ -0,0 +1,42 @@
+package org.plugins.rpghorses.listeners;
+
+import org.bukkit.entity.EntityType;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.managers.HorseOwnerManager;
+import org.plugins.rpghorses.managers.RPGHorseManager;
+import org.plugins.rpghorses.players.HorseOwner;
+
+public class EntitySpawnListener implements Listener {
+
+    private final RPGHorseManager rpgHorseManager;
+    private final HorseOwnerManager horseOwnerManager;
+
+    public EntitySpawnListener(RPGHorsesMain plugin, RPGHorseManager rpgHorseManager, HorseOwnerManager horseOwnerManager) {
+        this.rpgHorseManager = rpgHorseManager;
+        this.horseOwnerManager = horseOwnerManager;
+
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
+    public void onEntitySpawn(CreatureSpawnEvent e) {
+        EntityType entityType = e.getEntityType();
+        if (this.rpgHorseManager.isValidEntityType(entityType)) {
+            CreatureSpawnEvent.SpawnReason spawnReason = e.getSpawnReason();
+            for (HorseOwner horseOwner : this.horseOwnerManager.getHorseOwners()) {
+                if (horseOwner.isSpawningHorse() && spawnReason == CreatureSpawnEvent.SpawnReason.CUSTOM) {
+                    horseOwner.setSpawningHorse(false);
+                    return;
+                }
+            }
+            if (spawnReason != CreatureSpawnEvent.SpawnReason.SPAWNER_EGG && spawnReason != CreatureSpawnEvent.SpawnReason.CUSTOM) {
+                e.setCancelled(true);
+            }
+        }
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/listeners/InventoryClickListener.java b/src/org/plugins/rpghorses/listeners/InventoryClickListener.java
new file mode 100644
index 0000000..87fc5ab
--- /dev/null
+++ b/src/org/plugins/rpghorses/listeners/InventoryClickListener.java
@@ -0,0 +1,249 @@
+package org.plugins.rpghorses.listeners;
+
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.guis.MarketGUIPage;
+import org.plugins.rpghorses.guis.StableGUIPage;
+import org.plugins.rpghorses.guis.UpgradeGUI;
+import org.plugins.rpghorses.guis.YourHorsesGUIPage;
+import org.plugins.rpghorses.horses.MarketHorse;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.managers.*;
+import org.plugins.rpghorses.players.HorseOwner;
+import org.plugins.rpghorses.utils.MessagingUtil;
+
+public class InventoryClickListener implements Listener {
+	
+	private final RPGHorsesMain plugin;
+	private final HorseOwnerManager horseOwnerManager;
+	private final RPGHorseManager rpgHorseManager;
+	private final StableGUIManager stableGuiManager;
+	private final MarketGUIManager marketGUIManager;
+	private final Economy economy;
+	private final MessageQueuer messageQueuer;
+	private final MessagingUtil messagingUtil;
+	
+	public InventoryClickListener(RPGHorsesMain plugin, HorseOwnerManager horseOwnerManager, RPGHorseManager rpgHorseManager, StableGUIManager stableGuiManager, MarketGUIManager marketGUIManager, Economy economy, MessageQueuer messageQueuer, MessagingUtil messagingUtil) {
+		this.plugin = plugin;
+		this.horseOwnerManager = horseOwnerManager;
+		this.rpgHorseManager = rpgHorseManager;
+		this.stableGuiManager = stableGuiManager;
+		this.marketGUIManager = marketGUIManager;
+		this.economy = economy;
+		this.messageQueuer = messageQueuer;
+		this.messagingUtil = messagingUtil;
+		
+		plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+	
+	@EventHandler
+	public void onClick(InventoryClickEvent e) {
+		Player p = (Player) e.getWhoClicked();
+		HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p);
+		if (horseOwner.isInStableInventory()) {
+			
+			e.setCancelled(true);
+			if (e.getClickedInventory() == p.getOpenInventory().getTopInventory()) {
+				int slot = e.getSlot();
+				
+				UpgradeGUI upgradeGUI = this.stableGuiManager.getUpgradeGUI(p);
+				if (upgradeGUI != null) {
+					if (slot == this.stableGuiManager.getUpgradeItemSlot()) {
+						RPGHorse rpgHorse = upgradeGUI.getRPGHorse();
+						int tier = rpgHorse.getTier() + 1;
+						int horseNumber = horseOwner.getHorseNumber(rpgHorse);
+						if (this.rpgHorseManager.getUpgradeCost(rpgHorse) <= this.economy.getBalance(p)) {
+							if (rpgHorse.getXp() > rpgHorseManager.getXPNeededToUpgrade(rpgHorse)) {
+								if (this.rpgHorseManager.upgradeHorse(p, rpgHorse)) {
+									this.stableGuiManager.updateRPGHorse(rpgHorse);
+									this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.upgrade-horse-success").replace("{HORSE-NUMBER}", "" + horseNumber).replace("{TIER}", "" + tier), rpgHorse);
+									p.getLocation().getWorld().playSound(p.getLocation(), Sound.valueOf(this.plugin.getConfig().getString("upgrade-options.success-sound.sound")), Float.valueOf(this.plugin.getConfig().getString("upgrade-options.success-sound.volume")), Float.valueOf(this.plugin.getConfig().getString("upgrade-options.success-sound.pitch")));
+									for (String cmd : this.plugin.getConfig().getStringList("command-options.on-upgrade-success")) {
+										Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), MessagingUtil.format(cmd.replace("{PLAYER}", p.getName())));
+									}
+								} else {
+									this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.upgrade-horse-failure").replace("{HORSE-NUMBER}", "" + horseNumber).replace("{TIER}", "" + tier), rpgHorse);
+									p.getLocation().getWorld().playSound(p.getLocation(), Sound.valueOf(this.plugin.getConfig().getString("upgrade-options.failure-sound.sound")), Float.valueOf(this.plugin.getConfig().getString("upgrade-options.failure-sound.volume")), Float.valueOf(this.plugin.getConfig().getString("upgrade-options.failure-sound.pitch")));
+									for (String cmd : this.plugin.getConfig().getStringList("command-options.on-upgrade-fail")) {
+										Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), MessagingUtil.format(cmd.replace("{PLAYER}", p.getName())));
+									}
+								}
+							} else {
+								messagingUtil.sendMessageAtPath(p, "messages.not-enough-xp", rpgHorse);
+							}
+						} else {
+							this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.cant-afford-upgrade").replace("{HORSE-NUMBER}", "" + horseNumber), rpgHorse);
+						}
+						p.closeInventory();
+					}
+					return;
+				}
+				
+				StableGUIPage stableGUIPage = horseOwner.getCurrentStableGUIPage();
+				if (stableGUIPage == null) {
+					horseOwner.setInStableInventory(false);
+					return;
+				}
+				
+				if (slot == this.stableGuiManager.getNextPageSlot()) {
+					horseOwner.openStableGUIPage(stableGUIPage.getPageNum() + 1);
+				} else if (slot == this.stableGuiManager.getPreviousPageSlot()) {
+					horseOwner.openStableGUIPage(stableGUIPage.getPageNum() - 1);
+				} else {
+					RPGHorse rpgHorse = stableGUIPage.getRPGHorse(slot);
+					if (rpgHorse != null) {
+						int horseNumber = horseOwner.getHorseNumber(rpgHorse);
+						if (e.isShiftClick()) {
+							if (e.isLeftClick()) {
+								this.rpgHorseManager.addHorseRenamer(p, rpgHorse);
+								this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.rename-horse").replace("{HORSE-NUMBER}", "" + horseNumber));
+							} else if (e.isRightClick()) {
+								if (rpgHorse.getTier() == this.rpgHorseManager.getMaxTier()) {
+									this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.max-tier-horse").replace("{HORSE-NUMBER}", "" + horseNumber));
+								} else if (this.rpgHorseManager.getUpgradeCost(rpgHorse) <= this.economy.getBalance(p)) {
+								    if (rpgHorse.getXp() > rpgHorseManager.getXPNeededToUpgrade(rpgHorse)) {
+									this.stableGuiManager.openUpgradeGUI(p, rpgHorse);
+									return;
+									} else {
+                                        messagingUtil.sendMessageAtPath(p, "messages.not-enough-xp", rpgHorse);
+                                    }
+								} else {
+									this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.cant-afford-upgrade").replace("{HORSE-NUMBER}", "" + horseNumber));
+								}
+							}
+						} else {
+							if (e.isLeftClick()) {
+								if (horseOwner.getCurrentHorse() == rpgHorse) {
+									horseOwner.setCurrentHorse(null);
+									for (String cmd : this.plugin.getConfig().getStringList("command-options.on-despawn")) {
+										Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), MessagingUtil.format(cmd.replace("{PLAYER}", p.getName())));
+									}
+								} else if (rpgHorse.isDead()) {
+									this.messagingUtil.sendMessageAtPath(p, "messages.horse-is-dead");
+								} else if (rpgHorse.isInMarket()) {
+									this.messagingUtil.sendMessageAtPath(p, "messages.horse-is-in-market");
+								} else {
+									if (horseOwner.getCurrentHorse() != null) {
+										for (String cmd : this.plugin.getConfig().getStringList("command-options.on-despawn")) {
+											Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), MessagingUtil.format(cmd.replace("{PLAYER}", p.getName())));
+										}
+									}
+									horseOwner.setCurrentHorse(rpgHorse);
+									for (String cmd : this.plugin.getConfig().getStringList("command-options.on-spawn")) {
+										Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), MessagingUtil.format(cmd.replace("{PLAYER}", p.getName())));
+									}
+								}
+								p.closeInventory();
+							} else if (e.isRightClick()) {
+								this.rpgHorseManager.addRemoveConfirmation(p, rpgHorse);
+								this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.confirm-remove-horse").replace("{HORSE-NUMBER}", "" + horseNumber));
+							}
+						}
+						p.closeInventory();
+					}
+				}
+			}
+			
+		} else if (horseOwner.isInMarketInventory()) {
+			
+			e.setCancelled(true);
+			if (e.getClickedInventory() == p.getOpenInventory().getTopInventory()) {
+				int slot = e.getSlot();
+				
+				MarketGUIPage marketGUIPage = horseOwner.getCurrentMarketGUIPage();
+				if (marketGUIPage == null) {
+					horseOwner.setInMarketInventory(false);
+					return;
+				}
+				
+				if (slot == this.marketGUIManager.getNextPageSlot()) {
+					horseOwner.openMarketGUIPage(this.marketGUIManager.getPage(marketGUIPage.getPageNum() + 1));
+				} else if (slot == this.marketGUIManager.getPreviousPageSlot()) {
+					horseOwner.openMarketGUIPage(this.marketGUIManager.getPage(marketGUIPage.getPageNum() - 1));
+				} else if (slot == this.marketGUIManager.getYourHorsesSlot()) {
+					
+					if (horseOwner.getYourHorsesGUI() == null || horseOwner.getYourHorsesGUI().getPage(1) == null) {
+						this.marketGUIManager.setupYourHorsesGUI(horseOwner);
+					}
+					horseOwner.openYourHorsesGUIPage(1);
+				} else {
+					RPGHorse rpgHorse = marketGUIPage.getRPGHorse(slot);
+					if (rpgHorse != null) {
+						
+						if (rpgHorse.getHorseOwner().getUUID().equals(p.getUniqueId())) {
+							this.messagingUtil.sendMessageAtPath(p.getPlayer(), "messages.market-buy-own-horse", rpgHorse);
+						} else {
+							
+							if (this.horseOwnerManager.getHorseCount(p) >= this.horseOwnerManager.getHorseLimit(p)) {
+								this.messagingUtil.sendMessageAtPath(p.getPlayer(), "messages.market-horse-limit", rpgHorse);
+							} else {
+								
+								double price = this.marketGUIManager.getPrice(marketGUIPage, rpgHorse);
+								if (this.economy.getBalance(p) < price) {
+									this.messagingUtil.sendMessageAtPath(p, "messages.cant-afford-market-horse", rpgHorse);
+								} else {
+									this.economy.withdrawPlayer(p, price);
+									rpgHorse.setInMarket(false);
+									this.marketGUIManager.removeHorse(marketGUIPage, rpgHorse, true);
+									String oldPlayerName = "null";
+									if (rpgHorse.getHorseOwner() != null) {
+										HorseOwner oldHorseOwner = rpgHorse.getHorseOwner();
+										oldHorseOwner.removeRPGHorse(rpgHorse);
+										Player oldOwner = Bukkit.getPlayer(oldHorseOwner.getUUID());
+										if (oldOwner != null) {
+											oldPlayerName = oldOwner.getName();
+											this.stableGuiManager.setupStableGUI(oldHorseOwner);
+											this.messagingUtil.sendMessage(oldOwner, this.plugin.getConfig().getString("messages.market-horse-sold").replace("{PRICE}", "" + price).replace("{PLAYER}", p.getName()), rpgHorse);
+										} else {
+											OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(oldHorseOwner.getUUID());
+											oldPlayerName = offlinePlayer.getName();
+											this.messageQueuer.queueMessage(offlinePlayer, this.messagingUtil.placeholders(this.plugin.getConfig().getString("messages.market-horse-sold").replace("{PRICE}", "" + price).replace("{PLAYER}", p.getName()), rpgHorse));
+											this.horseOwnerManager.flushHorseOwner(oldHorseOwner);
+										}
+									}
+									horseOwner.addRPGHorse(rpgHorse);
+									this.stableGuiManager.setupStableGUI(horseOwner);
+									this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.market-horse-bought").replace("{PRICE}", "" + price).replace("{PLAYER}", oldPlayerName), rpgHorse);
+								}
+							}
+						}
+						p.closeInventory();
+					}
+				}
+			}
+		} else if (horseOwner.isInYourHorsesInventory()) {
+			e.setCancelled(true);
+			if (e.getClickedInventory() == p.getOpenInventory().getTopInventory()) {
+				int slot = e.getSlot();
+				
+				if (slot == this.marketGUIManager.getBackSlot()) {
+					horseOwner.openMarketGUIPage(this.marketGUIManager.getPage(1));
+					return;
+				}
+				
+				YourHorsesGUIPage yourHorsesGUIPage = horseOwner.getCurrentYourHorsesGUIPage();
+				MarketHorse marketHorse = yourHorsesGUIPage.getMarketHorse(slot);
+				if (marketHorse != null) {
+					RPGHorse rpgHorse = marketHorse.getRPGHorse();
+					this.marketGUIManager.removeHorse(this.marketGUIManager.getPage(marketHorse.getRPGHorse()), rpgHorse, false);
+					rpgHorse.setInMarket(false);
+					this.marketGUIManager.setupYourHorsesGUI(horseOwner);
+					this.stableGuiManager.updateRPGHorse(rpgHorse);
+					int horseNumber = horseOwner.getHorseNumber(rpgHorse);
+					this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.market-horse-removed").replace("{HORSE-NUMBER}", "" + horseNumber), rpgHorse);
+					p.closeInventory();
+				}
+				
+			}
+			
+		}
+	}
+	
+}
diff --git a/src/org/plugins/rpghorses/listeners/InventoryCloseListener.java b/src/org/plugins/rpghorses/listeners/InventoryCloseListener.java
new file mode 100644
index 0000000..af07813
--- /dev/null
+++ b/src/org/plugins/rpghorses/listeners/InventoryCloseListener.java
@@ -0,0 +1,41 @@
+package org.plugins.rpghorses.listeners;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.managers.StableGUIManager;
+import org.plugins.rpghorses.managers.HorseOwnerManager;
+import org.plugins.rpghorses.players.HorseOwner;
+
+public class InventoryCloseListener implements Listener {
+
+    private final HorseOwnerManager horseOwnerManager;
+    private final StableGUIManager stableGuiManager;
+
+    public InventoryCloseListener(RPGHorsesMain plugin, HorseOwnerManager horseOwnerManager, StableGUIManager stableGuiManager) {
+        this.horseOwnerManager = horseOwnerManager;
+        this.stableGuiManager = stableGuiManager;
+
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler
+    public void onInvClose(InventoryCloseEvent e) {
+        Player p = (Player) e.getPlayer();
+        HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p);
+        if (horseOwner.isInStableInventory()) {
+            horseOwner.setInStableInventory(false);
+
+            if (this.stableGuiManager.getUpgradeGUI(p) != null) {
+                this.stableGuiManager.removeUpgradeGUI(p);
+            }
+        } else if (horseOwner.isInMarketInventory()) {
+            horseOwner.setInMarketInventory(false);
+        } else if (horseOwner.isInYourHorsesInventory()) {
+            horseOwner.setInYourHorsesInventory(false);
+        }
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/listeners/PlayerChatListener.java b/src/org/plugins/rpghorses/listeners/PlayerChatListener.java
new file mode 100644
index 0000000..54ac008
--- /dev/null
+++ b/src/org/plugins/rpghorses/listeners/PlayerChatListener.java
@@ -0,0 +1,47 @@
+package org.plugins.rpghorses.listeners;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.AsyncPlayerChatEvent;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.managers.StableGUIManager;
+import org.plugins.rpghorses.managers.RPGHorseManager;
+import org.plugins.rpghorses.players.HorseOwner;
+import org.plugins.rpghorses.players.HorseRenamer;
+import org.plugins.rpghorses.utils.MessagingUtil;
+
+public class PlayerChatListener implements Listener {
+
+    private final RPGHorsesMain plugin;
+    private final RPGHorseManager rpgHorseManager;
+    private final StableGUIManager stableGuiManager;
+    private final MessagingUtil messagingUtil;
+
+    public PlayerChatListener(RPGHorsesMain plugin, RPGHorseManager rpgHorseManager, StableGUIManager stableGuiManager, MessagingUtil messagingUtil) {
+        this.plugin = plugin;
+        this.rpgHorseManager = rpgHorseManager;
+        this.stableGuiManager = stableGuiManager;
+        this.messagingUtil = messagingUtil;
+
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler
+    public void onChat(AsyncPlayerChatEvent e) {
+        Player p = e.getPlayer();
+        HorseRenamer horseRenamer = this.rpgHorseManager.getHorseRenamer(p);
+        if (horseRenamer != null) {
+            e.setCancelled(true);
+            RPGHorse rpgHorse = horseRenamer.getRPGHorse();
+            HorseOwner horseOwner = horseRenamer.getHorseOwner();
+            int horseNumber = horseOwner.getHorseNumber(rpgHorse);
+            String name = e.getMessage().split("\\s")[0];
+            rpgHorse.setName(name);
+            this.stableGuiManager.updateRPGHorse(rpgHorse);
+            this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.horse-renamed").replace("{HORSE-NUMBER}", "" + horseNumber), rpgHorse);
+            this.rpgHorseManager.removeHorseRenamer(p.getUniqueId());
+        }
+    }
+}
diff --git a/src/org/plugins/rpghorses/listeners/PlayerInteractEntityListener.java b/src/org/plugins/rpghorses/listeners/PlayerInteractEntityListener.java
new file mode 100644
index 0000000..5341c6b
--- /dev/null
+++ b/src/org/plugins/rpghorses/listeners/PlayerInteractEntityListener.java
@@ -0,0 +1,41 @@
+package org.plugins.rpghorses.listeners;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.managers.RPGHorseManager;
+import org.plugins.rpghorses.utils.MessagingUtil;
+
+public class PlayerInteractEntityListener implements Listener {
+
+    private final RPGHorseManager rpgHorseManager;
+    private final MessagingUtil messagingUtil;
+
+    public PlayerInteractEntityListener(RPGHorsesMain plugin, RPGHorseManager rpgHorseManager, MessagingUtil messagingUtil) {
+        this.rpgHorseManager = rpgHorseManager;
+        this.messagingUtil = messagingUtil;
+
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
+    public void onEntityInteract(PlayerInteractEntityEvent e) {
+        Entity entity = e.getRightClicked();
+        if (this.rpgHorseManager.isValidEntityType(entity.getType())) {
+            RPGHorse rpgHorse = this.rpgHorseManager.getRPGHorse(entity);
+            if (rpgHorse != null) {
+                Player p = e.getPlayer();
+                if (!rpgHorse.getHorseOwner().getUUID().equals(p.getUniqueId())) {
+                    e.setCancelled(true);
+                    this.messagingUtil.sendMessageAtPath(p, "messages.not-your-horse", rpgHorse);
+                }
+            }
+        }
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/listeners/PlayerJoinListener.java b/src/org/plugins/rpghorses/listeners/PlayerJoinListener.java
new file mode 100644
index 0000000..5acc452
--- /dev/null
+++ b/src/org/plugins/rpghorses/listeners/PlayerJoinListener.java
@@ -0,0 +1,48 @@
+package org.plugins.rpghorses.listeners;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.managers.MarketGUIManager;
+import org.plugins.rpghorses.managers.StableGUIManager;
+import org.plugins.rpghorses.managers.HorseOwnerManager;
+import org.plugins.rpghorses.managers.MessageQueuer;
+import org.plugins.rpghorses.players.HorseOwner;
+
+public class PlayerJoinListener implements Listener {
+
+    private final RPGHorsesMain plugin;
+    private final HorseOwnerManager horseOwnerManager;
+    private final StableGUIManager stableGuiManager;
+    private final MarketGUIManager marketGUIManager;
+    private final MessageQueuer messageQueuer;
+
+    public PlayerJoinListener(RPGHorsesMain plugin, HorseOwnerManager horseOwnerManager, StableGUIManager stableGuiManager, MarketGUIManager marketGUIManager, MessageQueuer messageQueuer) {
+        this.plugin = plugin;
+        this.horseOwnerManager = horseOwnerManager;
+        this.stableGuiManager = stableGuiManager;
+        this.marketGUIManager = marketGUIManager;
+        this.messageQueuer = messageQueuer;
+
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onJoin(PlayerJoinEvent e) {
+        Player p = e.getPlayer();
+        HorseOwner horseOwner = this.horseOwnerManager.loadData(p);
+        this.stableGuiManager.setupStableGUI(horseOwner);
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                marketGUIManager.setupYourHorsesGUI(horseOwner);
+                messageQueuer.sendQueuedMessages(p);
+            }
+        }.runTaskLaterAsynchronously(this.plugin, 5L);
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/listeners/PlayerQuitListener.java b/src/org/plugins/rpghorses/listeners/PlayerQuitListener.java
new file mode 100644
index 0000000..5eb4cc8
--- /dev/null
+++ b/src/org/plugins/rpghorses/listeners/PlayerQuitListener.java
@@ -0,0 +1,31 @@
+package org.plugins.rpghorses.listeners;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.managers.HorseOwnerManager;
+import org.plugins.rpghorses.managers.XPManager;
+import org.plugins.rpghorses.players.HorseOwner;
+
+public class PlayerQuitListener implements Listener {
+
+    private final HorseOwnerManager horseOwnerManager;
+    private final XPManager xpManager;
+
+    public PlayerQuitListener(RPGHorsesMain plugin, HorseOwnerManager horseOwnerManager, XPManager xpManager) {
+        this.horseOwnerManager = horseOwnerManager;
+        this.xpManager = xpManager;
+
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onQuit(PlayerQuitEvent e) {
+        HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(e.getPlayer());
+        this.xpManager.removeHorseOwner(horseOwner);
+        this.horseOwnerManager.flushHorseOwner(horseOwner);
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/listeners/PlayerTeleportListener.java b/src/org/plugins/rpghorses/listeners/PlayerTeleportListener.java
new file mode 100644
index 0000000..e3085f6
--- /dev/null
+++ b/src/org/plugins/rpghorses/listeners/PlayerTeleportListener.java
@@ -0,0 +1,46 @@
+package org.plugins.rpghorses.listeners;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.managers.HorseOwnerManager;
+import org.plugins.rpghorses.players.HorseOwner;
+import org.plugins.rpghorses.utils.MessagingUtil;
+
+public class PlayerTeleportListener implements Listener {
+
+    private final RPGHorsesMain plugin;
+    private final HorseOwnerManager horseOwnerManager;
+    private final MessagingUtil messagingUtil;
+
+    public PlayerTeleportListener(RPGHorsesMain plugin, HorseOwnerManager horseOwnerManager, MessagingUtil messagingUtil) {
+        this.plugin = plugin;
+        this.horseOwnerManager = horseOwnerManager;
+        this.messagingUtil = messagingUtil;
+
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+    public void onTeleport(PlayerTeleportEvent e) {
+        Player p = e.getPlayer();
+        HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p);
+        RPGHorse currentHorse = horseOwner.getCurrentHorse();
+
+        if (currentHorse != null && !horseOwner.isMountingHorse() && !horseOwner.isDeMountingHorse() && !horseOwner.isChangingHorse()) {
+            this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.horse-sent-to-stable").replace("{PLAYER}", "CONSOLE"), currentHorse);
+            horseOwner.setCurrentHorse(null);
+        } else if (horseOwner.isMountingHorse()) {
+            horseOwner.setMountingHorse(false);
+        } else if (horseOwner.isDeMountingHorse()) {
+            horseOwner.setDeMountingHorse(false);
+        } else if (horseOwner.isChangingHorse()) {
+            horseOwner.setChangingHorse(false);
+        }
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/listeners/PluginEnableListener.java b/src/org/plugins/rpghorses/listeners/PluginEnableListener.java
new file mode 100644
index 0000000..cf499b6
--- /dev/null
+++ b/src/org/plugins/rpghorses/listeners/PluginEnableListener.java
@@ -0,0 +1,28 @@
+package org.plugins.rpghorses.listeners;
+
+import org.bukkit.Bukkit;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.server.PluginEnableEvent;
+import org.plugins.rpghorses.RPGHorsesMain;
+
+public class PluginEnableListener implements Listener {
+
+    private final RPGHorsesMain plugin;
+
+    public PluginEnableListener(RPGHorsesMain plugin) {
+        this.plugin = plugin;
+
+        this.plugin.getServer().getPluginManager().registerEvents(this, this.plugin);
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onPluginEnable(PluginEnableEvent e) {
+        if (e.getPlugin().getName().equals("Vault")) {
+            Bukkit.getLogger().info("[RPGHorses] Vault loading...");
+            if (!this.plugin.getServer().getPluginManager().isPluginEnabled(this.plugin)) {
+                this.plugin.getServer().getPluginManager().enablePlugin(this.plugin);
+            }
+        }
+    }
+}
diff --git a/src/org/plugins/rpghorses/listeners/PreCommandListener.java b/src/org/plugins/rpghorses/listeners/PreCommandListener.java
new file mode 100644
index 0000000..83e1629
--- /dev/null
+++ b/src/org/plugins/rpghorses/listeners/PreCommandListener.java
@@ -0,0 +1,61 @@
+package org.plugins.rpghorses.listeners;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.managers.MarketGUIManager;
+import org.plugins.rpghorses.managers.RPGHorseManager;
+import org.plugins.rpghorses.managers.StableGUIManager;
+import org.plugins.rpghorses.players.HorseOwner;
+import org.plugins.rpghorses.players.RemoveHorseConfirmation;
+import org.plugins.rpghorses.utils.MessagingUtil;
+
+public class PreCommandListener implements Listener {
+
+    private final RPGHorsesMain plugin;
+    private final RPGHorseManager rpgHorseManager;
+    private final StableGUIManager stableGuiManager;
+    private final MarketGUIManager marketGUIManager;
+    private final MessagingUtil messagingUtil;
+
+    public PreCommandListener(RPGHorsesMain plugin, RPGHorseManager rpgHorseManager, StableGUIManager stableGuiManager, MarketGUIManager marketGUIManager, MessagingUtil messagingUtil) {
+        this.plugin = plugin;
+        this.rpgHorseManager = rpgHorseManager;
+        this.stableGuiManager = stableGuiManager;
+        this.marketGUIManager = marketGUIManager;
+        this.messagingUtil = messagingUtil;
+
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler
+    public void preCommand(PlayerCommandPreprocessEvent e) {
+        Player p = e.getPlayer();
+        if (e.getMessage().toLowerCase().startsWith("/confirm")) {
+            RemoveHorseConfirmation removeHorseConfirmation = this.rpgHorseManager.getRemovingHorseConfirmation(p);
+            if (removeHorseConfirmation != null) {
+                e.setCancelled(true);
+                RPGHorse rpgHorse = removeHorseConfirmation.getRPGHorse();
+                HorseOwner horseOwner = removeHorseConfirmation.getHorseOwner();
+                int horseNumber = horseOwner.getHorseNumber(rpgHorse);
+                RPGHorse currentHorse = horseOwner.getCurrentHorse();
+                if (currentHorse != null && currentHorse.equals(rpgHorse)) {
+                    for (String cmd : this.plugin.getConfig().getStringList("command-options.on-despawn")) {
+                        Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), MessagingUtil.format(cmd.replace("{PLAYER}", p.getName())));
+                    }
+                }
+                horseOwner.removeRPGHorse(rpgHorse);
+                this.stableGuiManager.setupStableGUI(horseOwner);
+                if (rpgHorse.isInMarket()) {
+                    this.marketGUIManager.removeHorse(this.marketGUIManager.getPage(rpgHorse), rpgHorse, true);
+                }
+                this.messagingUtil.sendMessage(p, this.plugin.getConfig().getString("messages.your-horse-was-removed").replace("{HORSE-NUMBER}", "" + horseNumber).replace("{PLAYER}", p.getName()), rpgHorse);
+            }
+        }
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/listeners/VehicleListener.java b/src/org/plugins/rpghorses/listeners/VehicleListener.java
new file mode 100644
index 0000000..7614140
--- /dev/null
+++ b/src/org/plugins/rpghorses/listeners/VehicleListener.java
@@ -0,0 +1,61 @@
+package org.plugins.rpghorses.listeners;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.vehicle.VehicleEnterEvent;
+import org.bukkit.event.vehicle.VehicleExitEvent;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.managers.RPGHorseManager;
+import org.plugins.rpghorses.managers.XPManager;
+import org.plugins.rpghorses.players.HorseOwner;
+import org.plugins.rpghorses.utils.MessagingUtil;
+
+public class VehicleListener implements Listener {
+
+    private final RPGHorseManager rpgHorseManager;
+    private final XPManager xpManager;
+    private final MessagingUtil messagingUtil;
+
+    public VehicleListener(RPGHorsesMain plugin, RPGHorseManager rpgHorseManager, XPManager xpManager, MessagingUtil messagingUtil) {
+        this.rpgHorseManager = rpgHorseManager;
+        this.xpManager = xpManager;
+        this.messagingUtil = messagingUtil;
+
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    @EventHandler
+    public void onVehicleEnter(VehicleEnterEvent e) {
+        RPGHorse rpgHorse = this.rpgHorseManager.getRPGHorse(e.getVehicle());
+        if (rpgHorse != null) {
+            HorseOwner horseOwner = rpgHorse.getHorseOwner();
+            Entity entered = e.getEntered();
+            if (entered.getType() == EntityType.PLAYER) {
+                Player p = (Player) entered;
+                if (horseOwner.getUUID().equals(p.getUniqueId())) {
+                    horseOwner.setMountingHorse(true);
+                    horseOwner.setLastHorseLocation(p.getLocation());
+                    xpManager.addHorseOwner(horseOwner);
+                } else {
+                    this.messagingUtil.sendMessageAtPath(p, "messages.not-your-horse");
+                    e.setCancelled(true);
+                }
+            }
+        }
+    }
+
+    @EventHandler
+    public void onVehicleExit(VehicleExitEvent e) {
+        RPGHorse rpgHorse = this.rpgHorseManager.getRPGHorse(e.getVehicle());
+        if (rpgHorse != null) {
+            HorseOwner horseOwner = rpgHorse.getHorseOwner();
+            horseOwner.setDeMountingHorse(true);
+            xpManager.removeHorseOwner(horseOwner);
+        }
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/managers/HorseCrateManager.java b/src/org/plugins/rpghorses/managers/HorseCrateManager.java
new file mode 100644
index 0000000..887a485
--- /dev/null
+++ b/src/org/plugins/rpghorses/managers/HorseCrateManager.java
@@ -0,0 +1,96 @@
+package org.plugins.rpghorses.managers;
+
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Horse;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.HorseCrate;
+
+import java.util.HashSet;
+import java.util.logging.Level;
+
+public class HorseCrateManager {
+
+    private final RPGHorsesMain plugin;
+
+    private HashSet<HorseCrate> horseCrates = new HashSet<>();
+
+    public HorseCrateManager(RPGHorsesMain plugin) {
+        this.plugin = plugin;
+
+        this.loadHorseCrates();
+    }
+
+    public void loadHorseCrates() {
+        this.horseCrates.clear();
+        FileConfiguration config = this.plugin.getConfig();
+        for (String crateName : config.getConfigurationSection("horse-crates").getKeys(false)) {
+            String path = "horse-crates." + crateName + ".horse-info.";
+            double[] healthValues = this.getMinAndMaxValues(config.getString(path + "health"));
+            double minHealth = healthValues[0];
+            double maxHealth = healthValues[1];
+            double[] movementSpeedValues = this.getMinAndMaxValues(config.getString(path + "movement-speed"));
+            double minMovementSpeed = movementSpeedValues[0];
+            double maxMovementSpeed = movementSpeedValues[1];
+            double[] jumpStrengthValues = this.getMinAndMaxValues(config.getString(path + "jump-strength"));
+            double minJumpStrength = jumpStrengthValues[0];
+            double maxJumpStrength = jumpStrengthValues[1];
+            double movementSpeed = config.getDouble(path + "movement-speed");
+            double jumpStrength = config.getDouble(path + "jump-strength");
+            int tier = config.getInt(path + "tier");
+            EntityType entityType = EntityType.HORSE;
+            Horse.Color color = Horse.Color.BROWN;
+            Horse.Style style = Horse.Style.NONE;
+            try {
+                entityType = EntityType.valueOf(config.getString(path + "type", "HORSE"));
+            } catch (IllegalArgumentException e) {
+                Bukkit.getLogger().log(Level.SEVERE, "[RPGHorses] Failed to load " + crateName + "( " + config.getString(path + "type") + " is not a valid entityType )");
+            }
+            try {
+                color = Horse.Color.valueOf(config.getString(path + "color", "BROWN"));
+            } catch (IllegalArgumentException e) {
+                Bukkit.getLogger().log(Level.SEVERE, "[RPGHorses] Failed to load " + crateName + " ( " + config.getString(path + "color") + " is not a valid color )");
+            }
+            try {
+                style = Horse.Style.valueOf(config.getString(path + "style", "NONE"));
+            } catch (IllegalArgumentException e) {
+                Bukkit.getLogger().log(Level.SEVERE, "[RPGHorses] Failed to load " + crateName + " ( " + config.getString(path + "style") + " is not a valid style )");
+            }
+            HorseCrate horseCrate = new HorseCrate(crateName, config.getDouble("horse-crates." + crateName + ".price"), minHealth, maxHealth, minMovementSpeed, maxMovementSpeed, minJumpStrength, maxJumpStrength, entityType, color, style, tier);
+            this.horseCrates.add(horseCrate);
+        }
+    }
+
+    public HorseCrate getHorseCrate(String name) {
+        for (HorseCrate horseCrate : this.horseCrates) {
+            if (horseCrate.getName().equalsIgnoreCase(name)) {
+                return horseCrate;
+            }
+        }
+        return null;
+    }
+
+    public String getHorseCrateList() {
+        String list = "";
+        for (HorseCrate horseCrate : this.horseCrates) {
+            list += horseCrate.getName() + ", ";
+        }
+        return list.substring(0, list.length() - 2);
+    }
+
+    public double[] getMinAndMaxValues(String info) {
+        double[] values = new double[2];
+        values[0] = 0;
+        values[1] = 0;
+        int index = info.indexOf("-");
+        if (index > -1) {
+            double min = Double.parseDouble(info.substring(0, index));
+            values[0] = min;
+            double max = Double.parseDouble(info.substring(index + 1));
+            values[1] = max;
+        }
+        return values;
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/managers/HorseDespawner.java b/src/org/plugins/rpghorses/managers/HorseDespawner.java
new file mode 100644
index 0000000..67c7764
--- /dev/null
+++ b/src/org/plugins/rpghorses/managers/HorseDespawner.java
@@ -0,0 +1,108 @@
+package org.plugins.rpghorses.managers;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.players.HorseOwner;
+
+import java.util.HashMap;
+
+public class HorseDespawner {
+
+    private final RPGHorsesMain plugin;
+    private final HorseOwnerManager horseOwnerManager;
+    private final RPGHorseManager rpgHorseManager;
+
+    private int idleTime = 5;
+    private BukkitTask idleHorseTask;
+    private HashMap<RPGHorse, Location> lastLocations = new HashMap<>();
+
+    public HorseDespawner(RPGHorsesMain plugin, HorseOwnerManager horseOwnerManager, RPGHorseManager rpgHorseManager) {
+        this.plugin = plugin;
+        this.horseOwnerManager = horseOwnerManager;
+        this.rpgHorseManager = rpgHorseManager;
+
+        this.despawnAllHorses();
+        this.reloadIdleTime();
+    }
+
+    public void reloadIdleTime() {
+        int oldIdleTime = this.idleTime;
+        this.idleTime = this.plugin.getConfig().getInt("horse-options.idle-time");
+
+        if (this.idleTime != oldIdleTime) {
+            this.startIdleHorseTask();
+        }
+    }
+
+    public void despawnAllRPGHorses() {
+        int horsesDespawned = 0;
+        for (HorseOwner horseOwner : this.horseOwnerManager.getHorseOwners()) {
+            RPGHorse oldCurrentHorse = horseOwner.getCurrentHorse();
+            horseOwner.setCurrentHorse(null);
+            if (oldCurrentHorse != null) {
+                horsesDespawned++;
+            }
+        }
+        Bukkit.getLogger().info("[RPGHorses] Despawned " + horsesDespawned + " horses");
+    }
+
+    public void despawnAllHorses() {
+        int horsesDespawned = 0;
+        for (World world : Bukkit.getWorlds()) {
+            for (Entity entity : world.getEntities()) {
+                if (this.rpgHorseManager.isValidEntityType(entity.getType())) {
+                    horsesDespawned++;
+                    entity.remove();
+                }
+            }
+        }
+        Bukkit.getLogger().info("[RPGHorses] Despawned " + horsesDespawned + " horses");
+    }
+
+    public Location getLastLocation(RPGHorse rpgHorse) {
+        return this.lastLocations.get(rpgHorse);
+    }
+
+    public void setLastLocations(HashMap<RPGHorse, Location> lastLocations) {
+        this.lastLocations = lastLocations;
+    }
+
+    public void startIdleHorseTask() {
+        this.cancelIdleHorseTask();
+
+        final HorseDespawner horseDespawner = this;
+        this.idleHorseTask = new BukkitRunnable() {
+            @Override
+            public void run() {
+                HashMap<RPGHorse, Location> lastLocations = new HashMap<>();
+                for (HorseOwner horseOwner : horseDespawner.horseOwnerManager.getHorseOwners()) {
+                    RPGHorse currentHorse = horseOwner.getCurrentHorse();
+                    if (currentHorse != null) {
+                        Location currentLocation = currentHorse.getHorse().getLocation();
+                        Location lastLocation = horseDespawner.getLastLocation(currentHorse);
+                        if (lastLocation != null && lastLocation.equals(currentLocation)) {
+                            horseOwner.setCurrentHorse(null);
+                        } else {
+                            lastLocations.put(currentHorse, currentLocation);
+                        }
+                    }
+                }
+                horseDespawner.setLastLocations(lastLocations);
+            }
+        }.runTaskTimerAsynchronously(this.plugin, 0, this.idleTime * 20L);
+    }
+
+    public void cancelIdleHorseTask() {
+        if (this.idleHorseTask != null) {
+            this.idleHorseTask.cancel();
+            this.idleHorseTask = null;
+        }
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/managers/HorseOwnerManager.java b/src/org/plugins/rpghorses/managers/HorseOwnerManager.java
new file mode 100644
index 0000000..83f7101
--- /dev/null
+++ b/src/org/plugins/rpghorses/managers/HorseOwnerManager.java
@@ -0,0 +1,224 @@
+package org.plugins.rpghorses.managers;
+
+import net.milkbowl.vault.permission.Permission;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.Particle;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Horse;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.configs.PlayerConfigs;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.players.HorseOwner;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.UUID;
+import java.util.logging.Level;
+
+public class HorseOwnerManager {
+
+    private final RPGHorsesMain plugin;
+    private final PlayerConfigs playerConfigs;
+    private final Permission permissions;
+
+    private HashSet<HorseOwner> horseOwners = new HashSet<>();
+
+    public HorseOwnerManager(RPGHorsesMain plugin, PlayerConfigs playerConfigs, Permission permissions) {
+        this.plugin = plugin;
+        this.playerConfigs = playerConfigs;
+        this.permissions = permissions;
+
+        // load owners
+        this.loadData();
+    }
+
+    public void saveData() {
+        for (HorseOwner horseOwner : this.horseOwners) {
+            this.saveData(horseOwner);
+        }
+    }
+
+    public void saveData(HorseOwner horseOwner) {
+        UUID uuid = horseOwner.getUUID();
+        FileConfiguration config = this.playerConfigs.getConfig(uuid);
+        if (config.getConfigurationSection("rpghorses") != null) {
+            config.set("rpghorses", null);
+        }
+        config.createSection("rpghorses");
+        int count = 0;
+        for (RPGHorse rpgHorse : horseOwner.getRPGHorses()) {
+            String path = "rpghorses." + ++count + ".";
+            config.set(path + "name", rpgHorse.getName());
+            config.set(path + "tier", rpgHorse.getTier());
+            config.set(path + "xp", rpgHorse.getXp());
+            config.set(path + "health", rpgHorse.getHealth());
+            config.set(path + "movement-speed", rpgHorse.getMovementSpeed());
+            config.set(path + "jump-strength", rpgHorse.getJumpStrength());
+            config.set(path + "type", rpgHorse.getEntityType().name());
+            config.set(path + "color", rpgHorse.getColor().name());
+            config.set(path + "style", rpgHorse.getStyle().name());
+            config.set(path + "death-time", rpgHorse.getDeathTime());
+            config.set(path + "in-market", rpgHorse.isInMarket());
+            if (rpgHorse.getParticle() != null) {
+                config.set(path + "particle", rpgHorse.getParticle().name());
+            }
+            config.createSection(path + "items");
+            HashMap<Integer, ItemStack> items = rpgHorse.getItems();
+            for (Integer slot : items.keySet()) {
+                config.set(path + "items." + slot, items.get(slot));
+            }
+        }
+
+        if (count == 0) {
+            this.playerConfigs.deleteConfig(uuid);
+        } else {
+            this.playerConfigs.saveConfig(uuid);
+            this.playerConfigs.reloadConfig(uuid);
+        }
+    }
+
+    public void saveData(Player p) {
+        this.saveData(this.getHorseOwner(p));
+    }
+
+    public void loadData() {
+        for (Player p : Bukkit.getServer().getOnlinePlayers()) {
+            this.loadData(p);
+        }
+    }
+
+    public HorseOwner loadData(Player p) {
+        if (p.isOnline()) {
+            return this.loadData(p.getUniqueId());
+        }
+        return null;
+    }
+
+    public HorseOwner loadData(UUID uuid) {
+        FileConfiguration config = this.playerConfigs.getConfig(uuid);
+        HorseOwner horseOwner = new HorseOwner(uuid);
+
+        if (config.getConfigurationSection("rpghorses") == null) {
+            this.playerConfigs.deleteConfig(uuid);
+            this.horseOwners.add(horseOwner);
+            return horseOwner;
+        }
+
+        for (String horseIndex : config.getConfigurationSection("rpghorses").getKeys(false)) {
+            String path = "rpghorses." + horseIndex + ".";
+            String name = config.getString(path + "name");
+            int tier = config.getInt(path + "tier");
+            double xp = config.getDouble(path + "xp");
+            double health = config.getDouble(path + "health");
+            double movementSpeed = config.getDouble(path + "movement-speed");
+            double jumpStrength = config.getDouble(path + "jump-strength");
+            EntityType entityType = EntityType.HORSE;
+            Horse.Color color = Horse.Color.BROWN;
+            Horse.Style style = Horse.Style.NONE;
+            try {
+                entityType = EntityType.valueOf(config.getString(path + "type", "HORSE"));
+            } catch (IllegalArgumentException e) {
+                Bukkit.getLogger().log(Level.SEVERE, "[RPGHorses] Failed to load " + uuid.toString() + "'s horse ( " + config.getString(path + "type") + " is not a valid entityType )");
+            }
+            try {
+                color = Horse.Color.valueOf(config.getString(path + "color", "BROWN"));
+            } catch (IllegalArgumentException e) {
+                Bukkit.getLogger().log(Level.SEVERE, "[RPGHorses] Failed to load " + uuid.toString() + "'s horse ( " + config.getString(path + "color") + " is not a valid color )");
+            }
+            try {
+                style = Horse.Style.valueOf(config.getString(path + "style", "NONE"));
+            } catch (IllegalArgumentException e) {
+                Bukkit.getLogger().log(Level.SEVERE, "[RPGHorses] Failed to load " + uuid.toString() + "'s horse ( " + config.getString(path + "style") + " is not a valid style )");
+            }
+
+            Long deathTime = Long.valueOf(config.getString(path + "death-time", "0"));
+            boolean isDead = deathTime + (this.plugin.getConfig().getInt("horse-options.death-cooldown") * 1000) - System.currentTimeMillis() > 0;
+
+            boolean inMarket = config.getBoolean(path + "in-market", false);
+            Particle particle = null;
+            if (config.isSet(path + "particle")) {
+                particle = Particle.valueOf(config.getString(path + "particle"));
+            }
+
+            HashMap<Integer, ItemStack> items = new HashMap<>();
+            for (String slotStr : config.getConfigurationSection(path + "items").getKeys(false)) {
+                items.put(Integer.valueOf(slotStr), config.getItemStack(path + "items." + slotStr));
+            }
+
+
+            RPGHorse rpgHorse = new RPGHorse(horseOwner, tier, xp, name, health, movementSpeed, jumpStrength, entityType, color, style, inMarket, particle, items);
+            if (isDead) {
+                rpgHorse.setDead(true);
+                rpgHorse.setDeathTime(deathTime);
+            }
+
+            horseOwner.addRPGHorse(rpgHorse);
+        }
+        this.horseOwners.add(horseOwner);
+        return horseOwner;
+    }
+
+    public HorseOwner getHorseOwner(OfflinePlayer p) {
+        return this.getHorseOwner(p.getUniqueId());
+    }
+
+    public HorseOwner getHorseOwner(UUID uuid) {
+        for (HorseOwner horseOwner : this.horseOwners) {
+            if (horseOwner.getUUID().equals(uuid)) {
+                return horseOwner;
+            }
+        }
+        return this.loadData(uuid);
+    }
+
+    public HashSet<HorseOwner> getHorseOwners() {
+        return horseOwners;
+    }
+
+    private HorseOwner removeHorseOwner(HorseOwner horseOwner) {
+        if (horseOwner != null) {
+            this.horseOwners.remove(horseOwner);
+            horseOwner.setCurrentHorse(null);
+        }
+        return horseOwner;
+    }
+
+    public void flushHorseOwner(HorseOwner horseOwner) {
+        this.saveData(this.removeHorseOwner(horseOwner));
+    }
+
+    public int getHorseLimit(OfflinePlayer p) {
+        if (this.permissions.playerHas(null, p, "rpghorses.limit.*")) {
+            return Integer.MAX_VALUE;
+        }
+
+        for (int i = 200; i > 0; i--) {
+            if (this.permissions.playerHas(null, p, "rpghorses.limit." + i)) {
+                return i;
+            }
+        }
+        return 0;
+    }
+
+    public int getHorseCount(Player p) {
+        return this.getHorseOwner(p).getRPGHorses().size();
+    }
+
+    public int getHorseCount(OfflinePlayer p) {
+        if (p.isOnline()) {
+            return this.getHorseCount(p.getPlayer());
+        }
+
+        FileConfiguration config = this.playerConfigs.getConfig(p.getUniqueId());
+        if (config.isConfigurationSection("rpghorses")) {
+            return config.getConfigurationSection("rpghorses").getKeys(false).size();
+        } else {
+            playerConfigs.deleteConfig(p.getUniqueId());
+        }
+        return 0;
+    }
+}
diff --git a/src/org/plugins/rpghorses/managers/MarketGUIManager.java b/src/org/plugins/rpghorses/managers/MarketGUIManager.java
new file mode 100644
index 0000000..2802453
--- /dev/null
+++ b/src/org/plugins/rpghorses/managers/MarketGUIManager.java
@@ -0,0 +1,421 @@
+package org.plugins.rpghorses.managers;
+
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.configs.CustomConfig;
+import org.plugins.rpghorses.guis.MarketGUIPage;
+import org.plugins.rpghorses.guis.YourHorsesGUI;
+import org.plugins.rpghorses.guis.YourHorsesGUIPage;
+import org.plugins.rpghorses.horses.MarketHorse;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.players.HorseOwner;
+import org.plugins.rpghorses.utils.ItemUtil;
+import org.plugins.rpghorses.utils.MessagingUtil;
+
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import java.util.*;
+
+public class MarketGUIManager {
+
+    private final RPGHorsesMain plugin;
+    private final HorseOwnerManager horseOwnerManager;
+    private final RPGHorseManager rpgHorseManager;
+    private final CustomConfig marketConfig;
+    private final ItemUtil itemUtil;
+
+    private ItemStack marketFillItem, horseItem, yourHorsesItem, backItem, previousPageItem, nextPageItem;
+    private int marketRows, yourHorsesSlot, backSlot, previousPageSlot, nextPageSlot;
+    private List<MarketGUIPage> marketGUIPages = new ArrayList<>();
+    private List<MarketHorse> marketHorses = new ArrayList<>();
+
+    public MarketGUIManager(RPGHorsesMain plugin, HorseOwnerManager horseOwnerManager, RPGHorseManager rpgHorseManager, CustomConfig marketConfig, ItemUtil itemUtil) {
+        this.plugin = plugin;
+        this.horseOwnerManager = horseOwnerManager;
+        this.rpgHorseManager = rpgHorseManager;
+        this.marketConfig = marketConfig;
+        this.itemUtil = itemUtil;
+
+        this.reload();
+    }
+
+    public int getPreviousPageSlot() {
+        return previousPageSlot;
+    }
+
+    public int getNextPageSlot() {
+        return nextPageSlot;
+    }
+
+    public int getYourHorsesSlot() {
+        return this.yourHorsesSlot;
+    }
+
+    public int getBackSlot() {
+        return this.backSlot;
+    }
+
+    public boolean reload() {
+        boolean reloadItems = false;
+        reloadItems = this.reloadPreviousPageItem() || reloadItems;
+        reloadItems = this.reloadNextPageItem() || reloadItems;
+        reloadItems = this.reloadMarketFillItem() || reloadItems;
+        reloadItems = this.reloadHorseItem() || reloadItems;
+        reloadItems = this.reloadYourHorsesItem() || reloadItems;
+        reloadItems = this.reloadBackItem() || reloadItems;
+        reloadItems = this.reloadMarketNumbers() || reloadItems;
+
+        if (reloadItems) {
+            this.setupMarketGUI();
+            this.setupYourHorsesGUIS();
+        }
+
+        return reloadItems;
+    }
+
+    public void setupMarketGUI() {
+        this.loadMarketHorses();
+
+        int rpgHorsesAdded = -1;
+        String title = MessagingUtil.format(this.plugin.getConfig().getString("market-options.title"));
+        Inventory gui = Bukkit.createInventory(null, this.marketRows * 9, title);
+        int slot = 10, pageNum = 1;
+        List<MarketGUIPage> marketGUIPages = new ArrayList<>();
+        HashMap<Integer, RPGHorse> rpgHorseSlots = new HashMap<>();
+        slot = 10;
+        rpgHorseSlots = new HashMap<>();
+
+        for (MarketHorse marketHorse : this.marketHorses) {
+            rpgHorsesAdded++;
+            RPGHorse rpgHorse = marketHorse.getRPGHorse();
+            ItemStack item = this.horseItem.clone();
+            item = fillPlaceholders(item, marketHorse);
+            gui.setItem(slot, item);
+            rpgHorseSlots.put(slot, rpgHorse);
+            if (slot++ == (this.marketRows - 1) * 9 - 2 || rpgHorsesAdded == this.marketHorses.size() - 1) {
+                for (int fillSlot = 0; fillSlot < gui.getSize(); fillSlot++) {
+                    if (fillSlot == this.nextPageSlot && rpgHorsesAdded < this.marketHorses.size() - 1) {
+                        gui.setItem(fillSlot, this.nextPageItem);
+                    } else if (fillSlot == this.previousPageSlot && pageNum > 1) {
+                        gui.setItem(fillSlot, this.previousPageItem);
+                    } else if (fillSlot == this.yourHorsesSlot) {
+                        gui.setItem(fillSlot, this.yourHorsesItem);
+                    } else if (gui.getItem(fillSlot) == null) {
+                        gui.setItem(fillSlot, this.marketFillItem);
+                    }
+                }
+                marketGUIPages.add(new MarketGUIPage(pageNum, gui, rpgHorseSlots));
+                slot = 10;
+                rpgHorseSlots = new HashMap<>();
+                gui = Bukkit.createInventory(null, this.marketRows * 9, title);
+            }
+        }
+
+        if (rpgHorsesAdded == -1) {
+            for (int fillSlot = 0; fillSlot < gui.getSize(); fillSlot++) {
+                if (fillSlot == this.nextPageSlot && rpgHorsesAdded < this.marketHorses.size() - 1) {
+                    gui.setItem(fillSlot, this.nextPageItem);
+                } else if (fillSlot == this.previousPageSlot && pageNum > 1) {
+                    gui.setItem(fillSlot, this.previousPageItem);
+                } else if (fillSlot == this.yourHorsesSlot) {
+                    gui.setItem(fillSlot, this.yourHorsesItem);
+                } else if (gui.getItem(fillSlot) == null) {
+                    gui.setItem(fillSlot, this.marketFillItem);
+                }
+            }
+            marketGUIPages.add(new MarketGUIPage(pageNum++, gui, rpgHorseSlots));
+        }
+        this.marketGUIPages = marketGUIPages;
+    }
+
+    public void reloadMarketGUI() {
+        this.setupMarketGUI();
+
+        mainloop:
+        for (HorseOwner horseOwner : this.horseOwnerManager.getHorseOwners()) {
+            if (horseOwner.isInMarketInventory()) {
+                MarketGUIPage marketGUIPage = horseOwner.getCurrentMarketGUIPage();
+                int pageNum = marketGUIPage.getPageNum();
+                while (pageNum > 0) {
+                    MarketGUIPage newMarketGUIPage = this.getPage(pageNum--);
+                    if (newMarketGUIPage != null) {
+                        horseOwner.openMarketGUIPage(newMarketGUIPage);
+                        continue mainloop;
+                    }
+                }
+                Bukkit.getPlayer(horseOwner.getUUID()).closeInventory();
+            }
+        }
+    }
+
+    public void loadMarketHorses() {
+        this.marketHorses.clear();
+
+        FileConfiguration config = this.marketConfig.getConfig();
+        Set<String> ids = config.getConfigurationSection("market").getKeys(false);
+
+        for (String id : ids) {
+            RPGHorse rpgHorse = this.getRPGHorse(id);
+            double price = config.getDouble("market." + id + ".price");
+            this.marketHorses.add(new MarketHorse(Integer.valueOf(id), rpgHorse, price));
+        }
+    }
+
+    public void addHorse(RPGHorse rpgHorse, double price, int index) {
+        String id = "" + this.marketConfig.getConfig().getConfigurationSection("market").getKeys(false).size();
+        FileConfiguration config = this.marketConfig.getConfig();
+        String path = "market." + id + ".";
+        config.set(path + "horse-owner", rpgHorse.getHorseOwner().getUUID().toString());
+        config.set(path + "price", price);
+        config.set(path + "index", index);
+        this.marketConfig.saveConfig();
+        this.marketConfig.reloadConfig();
+        this.reloadMarketGUI();
+
+        this.setupYourHorsesGUI(rpgHorse.getHorseOwner());
+    }
+
+    public void removeHorse(MarketGUIPage marketGUIPage, RPGHorse rpgHorse, boolean horseRemoved) {
+        int id = this.getID(marketGUIPage, rpgHorse);
+        HorseOwner horseOwner = rpgHorse.getHorseOwner();
+        int index = horseOwner.getHorseNumber(rpgHorse) - 1;
+        UUID uuid = horseOwner.getUUID();
+        FileConfiguration config = this.marketConfig.getConfig();
+        boolean afterID = false;
+        for (String loopID : config.getConfigurationSection("market").getKeys(false)) {
+            if (afterID) {
+                int newID = Integer.valueOf(loopID) - 1;
+                String uuidStr = config.getString("market." + loopID + ".horse-owner");
+                config.set("market." + newID + ".horse-owner", uuidStr);
+                config.set("market." + newID + ".price", config.getString("market." + loopID + ".price"));
+                int newIndex = Integer.valueOf(config.getString("market." + loopID + ".index"));
+                if (horseRemoved && uuidStr.equals(uuid.toString()) && newIndex > index) {
+                    newID -= 1;
+                }
+                config.set("market." + newID + ".index", newIndex);
+            }
+            if (loopID.equalsIgnoreCase("" + id)) {
+                afterID = true;
+            }
+        }
+        config.set("market." + (config.getConfigurationSection("market").getKeys(false).size() - 1), null);
+        this.marketConfig.saveConfig();
+        this.marketConfig.reloadConfig();
+
+        this.reloadMarketGUI();
+        this.setupYourHorsesGUI(rpgHorse.getHorseOwner());
+    }
+
+    public double getPrice(MarketGUIPage marketGUIPage, RPGHorse rpgHorse) {
+        FileConfiguration config = this.marketConfig.getConfig();
+        return config.getDouble("market." + this.getID(marketGUIPage, rpgHorse) + ".price");
+    }
+
+    public int getID(MarketGUIPage marketGUIPage, RPGHorse rpgHorse) {
+        int id = 0;
+        for (RPGHorse rpgHorse1 : marketGUIPage.getHorseSlots().values()) {
+            if (rpgHorse1.equals(rpgHorse)) {
+                break;
+            }
+            id++;
+        }
+        id += (marketGUIPage.getGUI().getSize() - (18 + (this.marketRows - 2) * 2)) * (marketGUIPage.getPageNum() - 1);
+        return id;
+    }
+
+    public MarketGUIPage getPage(int page) {
+        if (page >= 1 && this.marketGUIPages.size() >= page) {
+            return this.marketGUIPages.get(page - 1);
+        }
+        return null;
+    }
+
+    public RPGHorse getRPGHorse(String id) {
+        String path = "market." + id + ".";
+        HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(UUID.fromString(this.marketConfig.getConfig().getString(path + "horse-owner")));
+        RPGHorse rpgHorse = horseOwner.getRPGHorse(this.marketConfig.getConfig().getInt(path + ".index"));
+        if (Bukkit.getPlayer(horseOwner.getUUID()) == null) {
+            this.horseOwnerManager.flushHorseOwner(horseOwner);
+        }
+        return rpgHorse;
+    }
+
+    public MarketGUIPage getPage(RPGHorse rpgHorse) {
+        if (rpgHorse.isInMarket()) {
+            int pageNum = 1;
+            MarketGUIPage page;
+            do
+            {
+                page = this.getPage(pageNum++);
+                for (RPGHorse rpgHorse1 : page.getHorseSlots().values()) {
+                    if (rpgHorse1.equals(rpgHorse)) {
+                        return page;
+                    }
+                }
+            }
+            while (page != null);
+        }
+        return null;
+    }
+
+    public ItemStack fillPlaceholders(ItemStack item, MarketHorse marketHorse) {
+        if (item != null && marketHorse != null) {
+            ItemMeta itemMeta = item.getItemMeta();
+
+            RPGHorse rpgHorse = marketHorse.getRPGHorse();
+
+            NumberFormat formatter = new DecimalFormat("#0.0##");
+            String name = MessagingUtil.format(rpgHorse.getName()), tier = "" + rpgHorse.getTier(), movementSpeed = formatter.format(rpgHorse.getMovementSpeed()), jumpStrength = formatter.format(rpgHorse.getJumpStrength()), health = formatter.format(rpgHorse.getHealth()), maxHealth = formatter.format(rpgHorse.getMaxHealth()), price = formatter.format(marketHorse.getPrice());
+
+            String ownerName = "null";
+            UUID uuid = rpgHorse.getHorseOwner().getUUID();
+            OfflinePlayer p = Bukkit.getPlayer(uuid);
+            if (p != null && p.isOnline()) {
+                ownerName = p.getName();
+            } else {
+                p = Bukkit.getOfflinePlayer(uuid);
+                if (p != null && p.hasPlayedBefore()) {
+                    ownerName = p.getName();
+                }
+            }
+
+            if (itemMeta.hasDisplayName()) {
+                itemMeta.setDisplayName(itemMeta.getDisplayName().replace("{HEALTH}", health).replace("{MAX-HEALTH}", maxHealth).replace("{TIER}", tier).replace("{HORSE-NAME}", name).replace("{MOVEMENT-SPEED}", movementSpeed).replace("{JUMP-STRENGTH}", jumpStrength).replace("{PRICE}", "" + price).replace("{HORSE-OWNER}", ownerName));
+            }
+
+            if (itemMeta.hasLore()) {
+                List<String> newLore = new ArrayList<>();
+                for (String line : itemMeta.getLore()) {
+                    newLore.add(line.replace("{HEALTH}", health).replace("{MAX-HEALTH}", maxHealth).replace("{TIER}", tier).replace("{HORSE-NAME}", name).replace("{MOVEMENT-SPEED}", movementSpeed).replace("{JUMP-STRENGTH}", jumpStrength).replace("{PRICE}", "" + price).replace("{HORSE-OWNER}", ownerName));
+                }
+                itemMeta.setLore(newLore);
+            }
+
+            item.setItemMeta(itemMeta);
+        }
+        return item;
+    }
+
+    public void setupYourHorsesGUIS() {
+        for (HorseOwner horseOwner : this.horseOwnerManager.getHorseOwners()) {
+            this.setupYourHorsesGUI(horseOwner);
+        }
+    }
+
+    public void setupYourHorsesGUI(HorseOwner horseOwner) {
+        List<RPGHorse> rpgHorses = horseOwner.getRPGHorses();
+        int horseCount = -1, slot = 10, pageNum = 1;
+        String title = MessagingUtil.format(this.plugin.getConfig().getString("market-options.title"));
+        Inventory gui = Bukkit.createInventory(null, this.marketRows * 9, title);
+        List<YourHorsesGUIPage> yourHorsesGUIPages = new ArrayList<>();
+        HashMap<Integer, MarketHorse> horseSlots = new HashMap<>();
+
+        for (RPGHorse rpgHorse : rpgHorses) {
+            horseCount++;
+            if (rpgHorse.isInMarket()) {
+                MarketHorse marketHorse = this.getMarketHorse(rpgHorse);
+                ItemStack item = this.horseItem.clone();
+                item = fillPlaceholders(item, marketHorse);
+                gui.setItem(slot, item);
+                horseSlots.put(slot, marketHorse);
+            }
+            if (slot++ == (this.marketRows - 1) * 9 - 2 || horseCount == rpgHorses.size() - 1) {
+                for (int fillSlot = 0; fillSlot < gui.getSize(); fillSlot++) {
+                    if (fillSlot == (this.marketRows * 9) - 1 && horseCount < rpgHorses.size() - 1) {
+                        gui.setItem(fillSlot, this.nextPageItem);
+                    } else if (fillSlot == (this.marketRows * 9) - 9 && pageNum > 1) {
+                        gui.setItem(fillSlot, this.previousPageItem);
+                    } else if (fillSlot == this.getBackSlot()) {
+                        gui.setItem(fillSlot, this.backItem);
+                    } else if (gui.getItem(fillSlot) == null) {
+                        gui.setItem(fillSlot, this.marketFillItem);
+                    }
+                }
+                yourHorsesGUIPages.add(new YourHorsesGUIPage(pageNum++, gui, horseSlots));
+                slot = 10;
+                horseSlots = new HashMap<>();
+                gui = Bukkit.createInventory(null, this.marketRows * 9, title);
+            }
+        }
+
+        if (yourHorsesGUIPages.size() == 0) {
+            for (int fillSlot = 0; fillSlot < gui.getSize(); fillSlot++) {
+                if (fillSlot == this.getBackSlot()) {
+                    gui.setItem(fillSlot, this.backItem);
+                } else if (gui.getItem(fillSlot) == null) {
+                    gui.setItem(fillSlot, this.marketFillItem);
+                }
+            }
+            yourHorsesGUIPages.add(new YourHorsesGUIPage(pageNum++, gui, horseSlots));
+        }
+
+        YourHorsesGUI yourHorsesGUI = new YourHorsesGUI(horseOwner, yourHorsesGUIPages);
+        horseOwner.setYourHorsesGUI(yourHorsesGUI);
+    }
+
+    public MarketHorse getMarketHorse(RPGHorse rpgHorse) {
+        for (MarketHorse marketHorse : this.marketHorses) {
+            if (marketHorse.getRPGHorse().equals(rpgHorse)) {
+                return marketHorse;
+            }
+        }
+        return null;
+    }
+
+    private boolean reloadMarketFillItem() {
+        ItemStack oldMarketFillItem = this.marketFillItem;
+        this.marketFillItem = this.itemUtil.getItemStack("market-options.fill-item");
+        return (oldMarketFillItem != null && this.marketFillItem == null) || (oldMarketFillItem == null && this.marketFillItem != null) || !oldMarketFillItem.isSimilar(this.marketFillItem);
+    }
+
+    private boolean reloadHorseItem() {
+        ItemStack oldHorseItem = this.horseItem;
+        this.horseItem = this.itemUtil.getItemStack("market-options.horse-item");
+        return (oldHorseItem != null && this.horseItem == null) || (oldHorseItem == null && this.horseItem != null) || !oldHorseItem.isSimilar(this.horseItem);
+    }
+
+    private boolean reloadYourHorsesItem() {
+        ItemStack oldYourHorsesItem = this.yourHorsesItem;
+        this.yourHorsesItem = this.itemUtil.getItemStack("market-options.your-horses-item");
+        return (oldYourHorsesItem != null && this.yourHorsesItem == null) || (oldYourHorsesItem == null && this.yourHorsesItem != null) || !oldYourHorsesItem.isSimilar(this.yourHorsesItem);
+    }
+
+    private boolean reloadBackItem() {
+        ItemStack oldBackItem = this.backItem;
+        this.backItem = this.itemUtil.getItemStack("market-options.back-item");
+        return (oldBackItem != null && this.backItem == null) || (oldBackItem == null && this.backItem != null) || !oldBackItem.isSimilar(this.backItem);
+    }
+
+    private boolean reloadPreviousPageItem() {
+        ItemStack oldPreviousPageItem = this.previousPageItem;
+        this.previousPageItem = this.itemUtil.getItemStack("market-options.previous-page-item");
+        return (oldPreviousPageItem != null && this.previousPageItem == null) || (oldPreviousPageItem == null && this.previousPageItem != null) || !oldPreviousPageItem.isSimilar(this.previousPageItem);
+    }
+
+    private boolean reloadNextPageItem() {
+        ItemStack oldNextPageItem = this.nextPageItem;
+        this.nextPageItem = this.itemUtil.getItemStack("market-options.next-page-item");
+        return (oldNextPageItem != null && this.nextPageItem == null) || (oldNextPageItem == null && this.nextPageItem != null) || !oldNextPageItem.isSimilar(this.nextPageItem);
+    }
+
+    private boolean reloadMarketNumbers() {
+        int oldMarketRows = this.marketRows;
+        this.marketRows = this.plugin.getConfig().getInt("market-options.rows");
+
+        int oldYourHorsesSlot = this.yourHorsesSlot;
+        this.yourHorsesSlot = this.itemUtil.getSlot("market-options.your-horses-item");
+
+        int oldBackSlot = this.backSlot;
+        this.backSlot = this.itemUtil.getSlot("market-options.back-item");
+
+        this.nextPageSlot = this.marketRows * 9 - 1;
+        this.previousPageSlot = this.nextPageSlot - 8;
+
+        return this.marketRows != oldMarketRows || this.yourHorsesSlot != oldYourHorsesSlot || this.backSlot != oldBackSlot;
+    }
+}
diff --git a/src/org/plugins/rpghorses/managers/MessageQueuer.java b/src/org/plugins/rpghorses/managers/MessageQueuer.java
new file mode 100644
index 0000000..02c5167
--- /dev/null
+++ b/src/org/plugins/rpghorses/managers/MessageQueuer.java
@@ -0,0 +1,40 @@
+package org.plugins.rpghorses.managers;
+
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.plugins.rpghorses.configs.PlayerConfigs;
+import org.plugins.rpghorses.utils.MessagingUtil;
+
+import java.util.List;
+import java.util.UUID;
+
+public class MessageQueuer {
+
+    private final PlayerConfigs playerConfigs;
+    private final MessagingUtil messagingUtil;
+
+    public MessageQueuer(PlayerConfigs playerConfigs, MessagingUtil messagingUtil) {
+        this.playerConfigs = playerConfigs;
+        this.messagingUtil = messagingUtil;
+    }
+
+    public void queueMessage(OfflinePlayer offlinePlayer, String message) {
+        UUID uuid = offlinePlayer.getUniqueId();
+        List<String> queuedMessages = this.playerConfigs.getConfig(uuid).getStringList("queued-messages");
+        queuedMessages.add(message);
+        this.playerConfigs.getConfig(uuid).set("queued-messages", queuedMessages);
+        this.playerConfigs.saveConfig(uuid);
+        this.playerConfigs.reloadConfig(uuid);
+    }
+
+    public void sendQueuedMessages(Player p) {
+        List<String> queuedMessages = this.playerConfigs.getConfig(p).getStringList("queued-messages");
+        for (String message : queuedMessages) {
+            this.messagingUtil.sendMessage(p, message);
+        }
+        this.playerConfigs.getConfig(p).set("queued-messages", null);
+        this.playerConfigs.saveConfig(p);
+        this.playerConfigs.reloadConfig(p);
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/managers/ParticleManager.java b/src/org/plugins/rpghorses/managers/ParticleManager.java
new file mode 100644
index 0000000..f2dbccd
--- /dev/null
+++ b/src/org/plugins/rpghorses/managers/ParticleManager.java
@@ -0,0 +1,73 @@
+package org.plugins.rpghorses.managers;
+
+import org.bukkit.Location;
+import org.bukkit.Particle;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.players.HorseOwner;
+
+public class ParticleManager {
+
+    private final RPGHorsesMain plugin;
+    private final HorseOwnerManager horseOwnerManager;
+
+    private BukkitTask task;
+    private int interval = 1, volume = 1;
+    private double yOffset;
+
+    public ParticleManager(RPGHorsesMain plugin, HorseOwnerManager horseOwnerManager) {
+        this.plugin = plugin;
+        this.horseOwnerManager = horseOwnerManager;
+
+        this.reload();
+        this.startTask();
+    }
+
+    public void reloadInterval() {
+        this.interval = this.plugin.getConfig().getInt("horse-options.particles.interval");
+    }
+
+    public void reloadVolume() {
+        this.volume = this.plugin.getConfig().getInt("horse-options.particles.volume");
+    }
+
+    public void reloadYOffset() {
+        this.yOffset = this.plugin.getConfig().getDouble("horse-options.particles.y-offset");
+    }
+
+    public void reload() {
+        this.reloadInterval();
+        this.reloadVolume();
+        this.reloadYOffset();
+    }
+
+    public void startTask() {
+        this.task = new BukkitRunnable() {
+            @Override
+            public void run() {
+                for (HorseOwner horseOwner : horseOwnerManager.getHorseOwners()) {
+                    RPGHorse currentHorse = horseOwner.getCurrentHorse();
+                    if (currentHorse != null) {
+                        Particle particle = currentHorse.getParticle();
+                        if (particle != null) {
+                            Location loc = currentHorse.getHorse().getLocation().clone();
+                            loc.getWorld().spawnParticle(particle, loc.add(0, yOffset, 0), volume, 0.1, 0, 0.1);
+                        }
+                    }
+                }
+            }
+        }.runTaskTimerAsynchronously(this.plugin, this.interval, this.interval);
+    }
+
+    public String getParticleList() {
+        String particleList = "";
+        for (Particle particle : Particle.values()) {
+            particleList += particle.name() + ", ";
+        }
+
+        return particleList.substring(0, particleList.length() - 2);
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/managers/RPGHorseManager.java b/src/org/plugins/rpghorses/managers/RPGHorseManager.java
new file mode 100644
index 0000000..cc49f9f
--- /dev/null
+++ b/src/org/plugins/rpghorses/managers/RPGHorseManager.java
@@ -0,0 +1,203 @@
+package org.plugins.rpghorses.managers;
+
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Horse;
+import org.bukkit.entity.Player;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.players.HorseOwner;
+import org.plugins.rpghorses.players.HorseRenamer;
+import org.plugins.rpghorses.players.RemoveHorseConfirmation;
+
+import java.util.*;
+
+public class RPGHorseManager {
+
+    private final RPGHorsesMain plugin;
+    private final HorseOwnerManager horseOwnerManager;
+    private final Economy economy;
+
+    private final List<EntityType> validEntityTypes = new ArrayList<>();
+    private HashMap<UUID, RemoveHorseConfirmation> removeConfirmations = new HashMap<>();
+    private HashMap<UUID, HorseRenamer> horseRenamers = new HashMap<>();
+
+    public RPGHorseManager(RPGHorsesMain plugin, HorseOwnerManager horseOwnerManager, Economy economy) {
+        this.plugin = plugin;
+        this.horseOwnerManager = horseOwnerManager;
+        this.economy = economy;
+
+        this.setupValidEntityTypes();
+    }
+
+    public int getMaxTier() {
+        return this.plugin.getConfig().getConfigurationSection("horse-tiers").getKeys(false).size() + 1;
+    }
+
+    public RPGHorse getRPGHorse(Entity entity) {
+        if (entity != null) {
+            for (HorseOwner horseOwner : this.horseOwnerManager.getHorseOwners()) {
+                RPGHorse currentHorse = horseOwner.getCurrentHorse();
+                if (currentHorse != null && currentHorse.getHorse().getEntityId() == entity.getEntityId()) {
+                    return currentHorse;
+                }
+            }
+        }
+        return null;
+    }
+
+    public double getUpgradeCost(RPGHorse rpgHorse) {
+        return this.plugin.getConfig().getDouble("horse-tiers." + rpgHorse.getTier() + ".cost");
+    }
+
+    public double getSuccessChance(RPGHorse rpgHorse) {
+        int tier = rpgHorse.getTier();
+        if (tier < this.getMaxTier()) {
+            return this.plugin.getConfig().getDouble("horse-tiers." + tier + ".success-chance");
+        }
+        return -1;
+    }
+    
+    public double getXPNeededToUpgrade(RPGHorse rpgHorse) {
+        return plugin.getConfig().getDouble("horse-tiers." + rpgHorse.getTier() + ".exp-cost");
+    }
+
+    public boolean upgradeHorse(Player p, RPGHorse rpgHorse) {
+        int tier = rpgHorse.getTier();
+        if (tier < this.getMaxTier()) {
+
+            this.economy.withdrawPlayer(p, this.getUpgradeCost(rpgHorse));
+
+            double success = this.getSuccessChance(rpgHorse);
+            if ((new Random()).nextDouble() * 100 >= success) {
+                return false;
+            }
+
+            double movementSpeed = rpgHorse.getMovementSpeed() * this.plugin.getConfig().getDouble("horse-tiers." + tier + ".movement-speed-multiplier");
+            double jumpStrength = rpgHorse.getMovementSpeed() * this.plugin.getConfig().getDouble("horse-tiers." + tier + ".jump-strength-multiplier");
+
+            rpgHorse.setMovementSpeed(movementSpeed);
+            rpgHorse.setJumpStrength(jumpStrength);
+            rpgHorse.setTier(tier + 1);
+            return true;
+        }
+        return false;
+    }
+
+    public boolean isValidEntityType(String typeArg) {
+        try {
+            EntityType type = EntityType.valueOf(typeArg.toUpperCase());
+            return this.isValidEntityType(type);
+        } catch (IllegalArgumentException e) {
+            return false;
+        }
+    }
+
+    public boolean isValidEntityType(EntityType entityType) {
+        return this.validEntityTypes.contains(entityType);
+    }
+
+    public boolean isValidColor(String colorArg) {
+        try {
+            Horse.Color.valueOf(colorArg.toUpperCase());
+        } catch (IllegalArgumentException e) {
+            return false;
+        }
+        return true;
+    }
+
+    public boolean isValidStyle(String styleArg) {
+        try {
+            Horse.Style.valueOf(styleArg.toUpperCase());
+        } catch (IllegalArgumentException e) {
+            return false;
+        }
+        return true;
+    }
+
+    public void setupValidEntityTypes() {
+        if (!Bukkit.getVersion().contains("1.8.1")) {
+            this.validEntityTypes.add(EntityType.DONKEY);
+            this.validEntityTypes.add(EntityType.MULE);
+            this.validEntityTypes.add(EntityType.SKELETON_HORSE);
+            this.validEntityTypes.add(EntityType.ZOMBIE_HORSE);
+            this.validEntityTypes.add(EntityType.LLAMA);
+        }
+        this.validEntityTypes.add(EntityType.HORSE);
+    }
+
+    public String getEntityTypesList() {
+        String entityTypes = "";
+        for (EntityType type : this.validEntityTypes) {
+            entityTypes += type.name() + ", ";
+        }
+        return entityTypes.substring(0, entityTypes.length() - 2);
+    }
+
+    public String getColorsList() {
+        String validColors = "";
+        for (Horse.Color variant : Horse.Color.values()) {
+            validColors += variant.name() + ", ";
+        }
+        return validColors.substring(0, validColors.length() - 2);
+    }
+
+    public String getStylesList() {
+        String validStyles = "";
+        for (Horse.Style variant : Horse.Style.values()) {
+            validStyles += variant.name() + ", ";
+        }
+        return validStyles.substring(0, validStyles.length() - 2);
+    }
+
+    public void updateHorse(RPGHorse rpgHorse) {
+        HorseOwner horseOwner = rpgHorse.getHorseOwner();
+        if (horseOwner.getCurrentHorse() == rpgHorse) {
+            rpgHorse.spawnEntity();
+        }
+
+    }
+
+    public void addRemoveConfirmation(Player p, RPGHorse rpgHorse) {
+        RemoveHorseConfirmation horseConfirmation = this.getRemovingHorseConfirmation(p);
+        if (horseConfirmation != null) {
+            horseConfirmation.endTask();
+        }
+        this.removeConfirmations.put(p.getUniqueId(), new RemoveHorseConfirmation(this.plugin, this, this.horseOwnerManager.getHorseOwner(p), rpgHorse));
+    }
+
+    public void removeRemoveConfirmation(UUID uuid) {
+        this.removeConfirmations.remove(uuid);
+    }
+
+    public boolean isRemovingRPGHorse(Player p) {
+        return this.removeConfirmations.containsKey(p.getUniqueId());
+    }
+
+    public RemoveHorseConfirmation getRemovingHorseConfirmation(Player p) {
+        return this.removeConfirmations.get(p.getUniqueId());
+    }
+
+    public void addHorseRenamer(Player p, RPGHorse rpgHorse) {
+        HorseRenamer horseConfirmation = this.getHorseRenamer(p);
+        if (horseConfirmation != null) {
+            horseConfirmation.endTask();
+        }
+        this.horseRenamers.put(p.getUniqueId(), new HorseRenamer(this.plugin, this, this.horseOwnerManager.getHorseOwner(p), rpgHorse));
+    }
+
+    public void removeHorseRenamer(UUID uuid) {
+        this.horseRenamers.remove(uuid);
+    }
+
+    public boolean isRenamingHorse(Player p) {
+        return this.horseRenamers.containsKey(p.getUniqueId());
+    }
+
+    public HorseRenamer getHorseRenamer(Player p) {
+        return this.horseRenamers.get(p.getUniqueId());
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/managers/StableGUIManager.java b/src/org/plugins/rpghorses/managers/StableGUIManager.java
new file mode 100644
index 0000000..325de9a
--- /dev/null
+++ b/src/org/plugins/rpghorses/managers/StableGUIManager.java
@@ -0,0 +1,382 @@
+package org.plugins.rpghorses.managers;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.guis.StableGUI;
+import org.plugins.rpghorses.guis.StableGUIPage;
+import org.plugins.rpghorses.guis.UpgradeGUI;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.players.HorseOwner;
+import org.plugins.rpghorses.utils.ItemUtil;
+import org.plugins.rpghorses.utils.MessagingUtil;
+import org.plugins.rpghorses.utils.TimeUtil;
+
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+
+public class StableGUIManager {
+
+    private final RPGHorsesMain plugin;
+    private final HorseOwnerManager horseOwnerManager;
+    private final RPGHorseManager rpgHorseManager;
+    private final ItemUtil itemUtil;
+    private final MessagingUtil messagingUtil;
+
+    private Inventory upgradeInventory;
+    private ItemStack stableFillItem, upgradeFillItem, upgradeItem, aliveHorseItem, deadHorseItem, marketHorseItem, previousPageItem, nextPageItem;
+    private int stableRows, upgradeRows, previousPageSlot, nextPageSlot, upgradeItemSlot, deathCooldown;
+    private BukkitTask cooldownTask;
+    private String progressBarChar, completedColor, missingColor;
+    private int progressBarCount;
+
+    private HashMap<UUID, UpgradeGUI> upgradeGUIs = new HashMap<>();
+
+    public StableGUIManager(RPGHorsesMain plugin, HorseOwnerManager horseOwnerManager, RPGHorseManager rpgHorseManager, ItemUtil itemUtil, MessagingUtil messagingUtil) {
+        this.plugin = plugin;
+        this.horseOwnerManager = horseOwnerManager;
+        this.rpgHorseManager = rpgHorseManager;
+        this.itemUtil = itemUtil;
+        this.messagingUtil = messagingUtil;
+
+        this.reload();
+        this.startCooldownTask();
+    }
+
+    public int getUpgradeItemSlot() {
+        return upgradeItemSlot;
+    }
+
+    public int getPreviousPageSlot() {
+        return previousPageSlot;
+    }
+
+    public int getNextPageSlot() {
+        return nextPageSlot;
+    }
+
+    public void setupUpgradeGUI() {
+        this.upgradeInventory = Bukkit.createInventory(null, this.upgradeRows * 9, MessagingUtil.format(this.plugin.getConfig().getString("upgrade-options.title")));
+
+        for (int slot = 0; slot < this.upgradeInventory.getSize(); slot++) {
+            if (slot == this.upgradeItemSlot) {
+                this.upgradeInventory.setItem(this.upgradeItemSlot, this.upgradeItem);
+            } else {
+                this.upgradeInventory.setItem(slot, this.upgradeFillItem);
+            }
+        }
+
+        for (UUID uuid : this.upgradeGUIs.keySet()) {
+            this.openUpgradeGUI(Bukkit.getPlayer(uuid), this.upgradeGUIs.get(uuid).getRPGHorse());
+        }
+    }
+
+    public void setupStableGUI(HorseOwner horseOwner) {
+        List<RPGHorse> rpgHorses = horseOwner.getRPGHorses();
+        int rpgHorsesAdded = -1;
+        String title = MessagingUtil.format(this.plugin.getConfig().getString("stable-options.title"));
+        Inventory gui = Bukkit.createInventory(null, this.stableRows * 9, title);
+        int slot = 10, pageNum = 1;
+        List<StableGUIPage> stableGUIPages = new ArrayList<>();
+        HashMap<Integer, RPGHorse> rpgHorseSlots = new HashMap<>();
+
+        while (++rpgHorsesAdded < rpgHorses.size()) {
+            RPGHorse rpgHorse = rpgHorses.get(rpgHorsesAdded);
+            ItemStack item = rpgHorse.isDead() ? this.deadHorseItem.clone() : this.aliveHorseItem.clone();
+            item = rpgHorse.isInMarket() ? this.marketHorseItem.clone() : item;
+            item = fillPlaceholders(item, rpgHorse);
+            gui.setItem(slot, item);
+            rpgHorseSlots.put(slot, rpgHorse);
+            if (slot++ == (this.stableRows - 1) * 9 - 2 || rpgHorsesAdded == rpgHorses.size() - 1) {
+                for (int fillSlot = 0; fillSlot < gui.getSize(); fillSlot++) {
+                    if (fillSlot == (this.stableRows * 9) - 1 && rpgHorsesAdded < rpgHorses.size() - 1) {
+                        gui.setItem(fillSlot, this.nextPageItem);
+                    } else if (fillSlot == (this.stableRows * 9) - 9 && pageNum > 1) {
+                        gui.setItem(fillSlot, this.previousPageItem);
+                    } else if (gui.getItem(fillSlot) == null) {
+                        gui.setItem(fillSlot, this.stableFillItem);
+                    }
+                }
+                stableGUIPages.add(new StableGUIPage(horseOwner, pageNum++, gui, rpgHorseSlots));
+                slot = 10;
+                rpgHorseSlots = new HashMap<>();
+                gui = Bukkit.createInventory(null, this.stableRows * 9, title);
+            }
+        }
+
+        if (rpgHorsesAdded == 0) {
+            for (int fillSlot = 0; fillSlot < gui.getSize(); fillSlot++) {
+                if (fillSlot == this.nextPageSlot && rpgHorsesAdded < rpgHorses.size() - 1) {
+                    gui.setItem(fillSlot, this.nextPageItem);
+                } else if (fillSlot == this.previousPageSlot && pageNum > 1) {
+                    gui.setItem(fillSlot, this.previousPageItem);
+                } else if (gui.getItem(fillSlot) == null) {
+                    gui.setItem(fillSlot, this.stableFillItem);
+                }
+            }
+            stableGUIPages.add(new StableGUIPage(horseOwner, pageNum++, gui, rpgHorseSlots));
+        }
+
+        StableGUI stableGUI = new StableGUI(horseOwner, stableGUIPages);
+        horseOwner.setStableGUI(stableGUI);
+    }
+
+    public void updateRPGHorse(RPGHorse rpgHorse) {
+        if (rpgHorse != null) {
+            HorseOwner horseOwner = rpgHorse.getHorseOwner();
+            StableGUI stableGUI = horseOwner.getStableGUI();
+            pageLoop:
+            for (StableGUIPage stableGUIPage : stableGUI.getStableGUIPages()) {
+                HashMap<Integer, RPGHorse> rpgHorses = stableGUIPage.getHorseSlots();
+                for (Integer slot : rpgHorses.keySet()) {
+                    RPGHorse loopHorse = rpgHorses.get(slot);
+                    if (loopHorse == rpgHorse) {
+                        ItemStack item = rpgHorse.isDead() ? this.deadHorseItem.clone() : this.aliveHorseItem.clone();
+                        item = rpgHorse.isInMarket() ? this.marketHorseItem.clone() : item;
+                        item = this.fillPlaceholders(item, rpgHorse);
+                        stableGUIPage.getGUI().setItem(slot, item);
+                        break pageLoop;
+                    }
+                }
+            }
+        }
+    }
+
+    public Long getDeathDifferent(RPGHorse rpgHorse) {
+        return rpgHorse.getDeathTime() + this.deathCooldown - System.currentTimeMillis();
+    }
+
+    public ItemStack fillPlaceholders(ItemStack item, RPGHorse rpgHorse) {
+        if (item != null && rpgHorse != null) {
+            ItemMeta itemMeta = item.getItemMeta();
+
+            String cooldownTime = "";
+            if (rpgHorse.isDead()) {
+                cooldownTime = TimeUtil.formatTime(this.getDeathDifferent(rpgHorse) / 1000L);
+            }
+
+            NumberFormat formatter = new DecimalFormat("#0.0##");
+            String xpBar = messagingUtil.getProgressBar(rpgHorse.getXp(), rpgHorseManager.getXPNeededToUpgrade(rpgHorse), progressBarCount, completedColor, missingColor, progressBarChar);
+            String name = rpgHorse.getName(), tier = "" + rpgHorse.getTier(), movementSpeed = formatter.format(rpgHorse.getMovementSpeed()), jumpStrength = formatter.format(rpgHorse.getJumpStrength()), health = formatter.format(rpgHorse.getHealth()), maxHealth = formatter.format(rpgHorse.getMaxHealth());
+
+            if (name == null) {
+                name = "RPGHorse";
+            }
+            name = MessagingUtil.format(name);
+
+            if (itemMeta.hasDisplayName()) {
+                itemMeta.setDisplayName(itemMeta.getDisplayName().replace("{HEALTH}", health).replace("{MAX-HEALTH}", maxHealth).replace("{TIER}", tier).replace("{XP}", xpBar).replace("{HORSE-NAME}", name).replace("{MOVEMENT-SPEED}", movementSpeed).replace("{JUMP-STRENGTH}", jumpStrength).replace("{DEATH-COOLDOWN}", "" + cooldownTime));
+            }
+
+            if (itemMeta.hasLore()) {
+                List<String> newLore = new ArrayList<>();
+                for (String line : itemMeta.getLore()) {
+                    newLore.add(line.replace("{HEALTH}", health).replace("{MAX-HEALTH}", maxHealth).replace("{TIER}", tier).replace("{XP}", xpBar).replace("{HORSE-NAME}", name).replace("{MOVEMENT-SPEED}", movementSpeed).replace("{JUMP-STRENGTH}", jumpStrength).replace("{DEATH-COOLDOWN}", "" + cooldownTime));
+                }
+                itemMeta.setLore(newLore);
+            }
+
+            item.setItemMeta(itemMeta);
+        }
+        return item;
+    }
+
+    public void reloadAllStableGUIS() {
+        for (HorseOwner horseOwner : this.horseOwnerManager.getHorseOwners()) {
+            this.setupStableGUI(horseOwner);
+        }
+    }
+
+    public boolean reload() {
+        this.progressBarChar = this.plugin.getConfig().getString("progress-bar.character");
+        this.completedColor = this.plugin.getConfig().getString("progress-bar.completed-color");
+        this.missingColor = this.plugin.getConfig().getString("progress-bar.missing-color");
+        this.progressBarCount = this.plugin.getConfig().getInt("progress-bar.count");
+        
+        boolean reloadItems = false;
+        reloadItems = this.reloadStableFillItem() || reloadItems;
+        reloadItems = this.reloadAliveHorseItem() || reloadItems;
+        reloadItems = this.reloadDeadHorseItem() || reloadItems;
+        reloadItems = this.reloadMarketHorseItem() || reloadItems;
+        reloadItems = this.reloadPreviousPageItem() || reloadItems;
+        reloadItems = this.reloadNextPageItem() || reloadItems;
+        reloadItems = this.reloadStableNumbers() || reloadItems;
+        reloadItems = this.reloadDeathCooldown() || reloadItems;
+
+        if (reloadItems) {
+            this.reloadAllStableGUIS();
+        }
+
+        boolean reloadUpgradeGUI = false;
+        reloadUpgradeGUI = this.reloadUpgradeNumbers() || reloadUpgradeGUI;
+        reloadUpgradeGUI = this.reloadUpgradeFillItem() || reloadUpgradeGUI;
+        reloadUpgradeGUI = this.reloadUpgradeItem() || reloadUpgradeGUI;
+
+        if (reloadUpgradeGUI) {
+            this.setupUpgradeGUI();
+        }
+
+        return reloadItems;
+    }
+
+    private boolean reloadStableFillItem() {
+        ItemStack oldStableFillItem = this.stableFillItem;
+        this.stableFillItem = this.itemUtil.getItemStack("stable-options.fill-item");
+        return (oldStableFillItem != null && this.stableFillItem == null) || (oldStableFillItem == null && this.stableFillItem != null) || !oldStableFillItem.isSimilar(this.stableFillItem);
+    }
+
+    private boolean reloadUpgradeFillItem() {
+        ItemStack oldUpgradeFillItem = this.upgradeFillItem;
+        this.upgradeFillItem = this.itemUtil.getItemStack("upgrade-options.fill-item");
+        return (oldUpgradeFillItem != null && this.upgradeFillItem == null) || (oldUpgradeFillItem == null && this.upgradeFillItem != null) || !oldUpgradeFillItem.isSimilar(this.upgradeFillItem);
+    }
+
+    private boolean reloadAliveHorseItem() {
+        ItemStack oldAliveHorseItem = this.aliveHorseItem;
+        this.aliveHorseItem = this.itemUtil.getItemStack("stable-options.alive-horse-item");
+        return oldAliveHorseItem != null && this.aliveHorseItem == null || oldAliveHorseItem == null && this.aliveHorseItem != null || oldAliveHorseItem != null && !oldAliveHorseItem.isSimilar(this.aliveHorseItem);
+    }
+
+    private boolean reloadDeadHorseItem() {
+        ItemStack oldDeadHorseItem = this.deadHorseItem;
+        this.deadHorseItem = this.itemUtil.getItemStack("stable-options.dead-horse-item");
+        return (oldDeadHorseItem != null && this.deadHorseItem == null) || (oldDeadHorseItem == null && this.deadHorseItem != null) || (oldDeadHorseItem != null && !oldDeadHorseItem.isSimilar(this.deadHorseItem));
+    }
+
+    private boolean reloadMarketHorseItem() {
+        ItemStack oldMarketHorseItem = this.marketHorseItem;
+        this.marketHorseItem = this.itemUtil.getItemStack("stable-options.market-horse-item");
+        return (oldMarketHorseItem != null && this.marketHorseItem == null) || (oldMarketHorseItem == null && this.marketHorseItem != null) || (oldMarketHorseItem != null && !oldMarketHorseItem.isSimilar(this.marketHorseItem));
+    }
+
+    private boolean reloadUpgradeItem() {
+        ItemStack oldUpgradeItem = this.upgradeItem;
+        this.upgradeItem = this.itemUtil.getItemStack("upgrade-options.upgrade-item");
+        return oldUpgradeItem != null && this.upgradeItem == null || oldUpgradeItem == null && this.upgradeItem != null || oldUpgradeItem != null && !oldUpgradeItem.isSimilar(this.upgradeItem);
+    }
+
+    private boolean reloadPreviousPageItem() {
+        ItemStack oldPreviousPageItem = this.previousPageItem;
+        this.previousPageItem = this.itemUtil.getItemStack("stable-options.previous-page-item");
+        return (oldPreviousPageItem != null && this.previousPageItem == null) || (oldPreviousPageItem == null && this.previousPageItem != null) || !oldPreviousPageItem.isSimilar(this.previousPageItem);
+    }
+
+    private boolean reloadNextPageItem() {
+        ItemStack oldNextPageItem = this.nextPageItem;
+        this.nextPageItem = this.itemUtil.getItemStack("stable-options.next-page-item");
+        return (oldNextPageItem != null && this.nextPageItem == null) || (oldNextPageItem == null && this.nextPageItem != null) || !oldNextPageItem.isSimilar(this.nextPageItem);
+    }
+
+    private boolean reloadStableNumbers() {
+        int oldStableRows = this.stableRows;
+        this.stableRows = this.plugin.getConfig().getInt("stable-options.rows");
+
+        this.nextPageSlot = this.stableRows * 9 - 1;
+        this.previousPageSlot = this.nextPageSlot - 8;
+
+        return this.stableRows != oldStableRows;
+    }
+
+    private boolean reloadDeathCooldown() {
+        int oldDeathCooldown = this.deathCooldown;
+        this.deathCooldown = this.plugin.getConfig().getInt("horse-options.death-cooldown") * 1000;
+
+        return this.deathCooldown != oldDeathCooldown;
+    }
+
+    private boolean reloadUpgradeNumbers() {
+        int oldUpgradeRows = this.upgradeRows;
+        this.upgradeRows = this.plugin.getConfig().getInt("upgrade-options.rows");
+
+        int oldUpgradeItemSlot = this.upgradeItemSlot;
+        this.upgradeItemSlot = this.itemUtil.getSlot("upgrade-options.upgrade-item");
+
+        return this.upgradeRows != oldUpgradeRows || this.upgradeItemSlot != oldUpgradeItemSlot;
+    }
+
+    public void startCooldownTask() {
+        this.cancelCooldownTask();
+
+        this.cooldownTask = new BukkitRunnable() {
+            @Override
+            public void run() {
+                for (HorseOwner horseOwner : horseOwnerManager.getHorseOwners()) {
+                    if (horseOwner.isInStableInventory()) {
+                        StableGUIPage stableGUIPage = horseOwner.getCurrentStableGUIPage();
+                        if (stableGUIPage != null) {
+                            for (int slot : stableGUIPage.getHorseSlots().keySet()) {
+                                RPGHorse rpgHorse = stableGUIPage.getRPGHorse(slot);
+                                if (rpgHorse.isDead()) {
+                                    if (getDeathDifferent(rpgHorse) <= 0) {
+                                        rpgHorse.setDead(false);
+                                    }
+                                    updateRPGHorse(rpgHorse);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }.runTaskTimer(this.plugin, 0L, 10L);
+    }
+
+    public void cancelCooldownTask() {
+        if (this.cooldownTask != null) {
+            this.cooldownTask.cancel();
+            this.cooldownTask = null;
+        }
+    }
+
+    public void openUpgradeGUI(Player p, RPGHorse rpgHorse) {
+        HorseOwner horseOwner = this.horseOwnerManager.getHorseOwner(p);
+
+        Inventory cloneGUI = Bukkit.createInventory(null, this.upgradeInventory.getSize(), this.upgradeInventory.getTitle());
+
+        for (int slot = 0; slot < this.upgradeInventory.getSize(); slot++) {
+            ItemStack item = this.upgradeInventory.getItem(slot);
+            if (item != null) {
+                if (slot == this.getUpgradeItemSlot()) {
+                    item = item.clone();
+                    ItemMeta itemMeta = item.getItemMeta();
+                    int tier = rpgHorse.getTier() + 1;
+                    double cost = this.rpgHorseManager.getUpgradeCost(rpgHorse), successChance = this.rpgHorseManager.getSuccessChance(rpgHorse);
+                    String horseName = MessagingUtil.format("&7" + rpgHorse.getName());
+                    if (itemMeta.hasDisplayName()) {
+                        itemMeta.setDisplayName(itemMeta.getDisplayName().replace("{TIER}", "" + tier).replace("{COST}", "" + cost).replace("{SUCCESS-CHANCE}", "" + successChance).replace("{HORSE-NAME}", horseName));
+                    }
+                    if (itemMeta.hasLore()) {
+                        List<String> lore = new ArrayList<>();
+                        for (String line : itemMeta.getLore()) {
+                            lore.add(line.replace("{TIER}", "" + tier).replace("{COST}", "" + cost).replace("{SUCCESS-CHANCE}", "" + successChance).replace("{HORSE-NAME}", horseName));
+                        }
+                        itemMeta.setLore(lore);
+                    }
+                    item.setItemMeta(itemMeta);
+                }
+                cloneGUI.setItem(slot, item);
+            }
+        }
+
+        p.openInventory(cloneGUI);
+        this.upgradeGUIs.put(p.getUniqueId(), new UpgradeGUI(rpgHorse, cloneGUI));
+        horseOwner.setInStableInventory(true);
+    }
+
+    public UpgradeGUI getUpgradeGUI(Player p) {
+        return this.upgradeGUIs.get(p.getUniqueId());
+    }
+
+    public void removeUpgradeGUI(Player p) {
+        this.upgradeGUIs.remove(p.getUniqueId());
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/managers/XPManager.java b/src/org/plugins/rpghorses/managers/XPManager.java
new file mode 100644
index 0000000..95ae9c3
--- /dev/null
+++ b/src/org/plugins/rpghorses/managers/XPManager.java
@@ -0,0 +1,80 @@
+package org.plugins.rpghorses.managers;
+
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.players.HorseOwner;
+import org.plugins.rpghorses.utils.MessagingUtil;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
+public class XPManager {
+	
+	private final RPGHorsesMain plugin;
+	private final RPGHorseManager rpgHorseManager;
+	private final MessagingUtil messagingUtil;
+	
+	private HashSet<HorseOwner> horseOwners = new HashSet<>();
+	private BukkitTask xpTask;
+	
+	public XPManager(RPGHorsesMain plugin, RPGHorseManager rpgHorseManager, MessagingUtil messagingUtil) {
+		this.plugin = plugin;
+		this.rpgHorseManager = rpgHorseManager;
+		this.messagingUtil = messagingUtil;
+		
+		start();
+	}
+	
+	public void addHorseOwner(HorseOwner horseOwner) {
+		RPGHorse rpgHorse = horseOwner.getCurrentHorse();
+		if (rpgHorse != null && rpgHorse.getTier() < rpgHorseManager.getMaxTier() && rpgHorseManager.getXPNeededToUpgrade(rpgHorse) > rpgHorse.getXp()) {
+			this.horseOwners.add(horseOwner);
+		}
+	}
+	
+	public void removeHorseOwner(HorseOwner horseOwner) {
+		this.horseOwners.remove(horseOwner);
+	}
+	
+	public void start() {
+		cancel();
+		
+		xpTask = new BukkitRunnable() {
+			@Override
+			public void run() {
+				List<HorseOwner> toRemove = new ArrayList<>();
+				for (HorseOwner horseOwner : horseOwners) {
+					Player p = horseOwner.getPlayer();
+					Location newLoc = p.getLocation();
+					Location oldLoc = horseOwner.getLastHorseLocation();
+					RPGHorse rpgHorse = horseOwner.getCurrentHorse();
+					rpgHorse.increaseXp(newLoc.distance(oldLoc));
+					
+					if (rpgHorse.getXp() >= rpgHorseManager.getXPNeededToUpgrade(rpgHorse)) {
+						messagingUtil.sendMessageAtPath(p, "messages.max-xp", rpgHorse);
+						toRemove.add(horseOwner);
+					}
+					
+					horseOwner.setLastHorseLocation(newLoc);
+				}
+				
+				for (HorseOwner horseOwner : toRemove) {
+					removeHorseOwner(horseOwner);
+				}
+			}
+		}.runTaskTimerAsynchronously(plugin, 0L, 20L);
+	}
+	
+	
+	public void cancel() {
+		if (xpTask != null) {
+			xpTask.cancel();
+			xpTask = null;
+		}
+	}
+}
diff --git a/src/org/plugins/rpghorses/players/HorseOwner.java b/src/org/plugins/rpghorses/players/HorseOwner.java
new file mode 100644
index 0000000..2b1967d
--- /dev/null
+++ b/src/org/plugins/rpghorses/players/HorseOwner.java
@@ -0,0 +1,291 @@
+package org.plugins.rpghorses.players;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.AbstractHorse;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.plugins.rpghorses.guis.*;
+import org.plugins.rpghorses.horses.RPGHorse;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+public class HorseOwner {
+
+    private UUID uuid;
+    private List<RPGHorse> rpgHorses;
+    private RPGHorse currentHorse;
+    private boolean spawningHorse, mountingHorse, deMountingHorse, changingHorse, inStableInventory, inMarketInventory, inYourHorsesInventory;
+    private Location lastHorseLocation;
+    private StableGUI stableGUI;
+    private StableGUIPage stableGUIPage;
+    private MarketGUIPage marketGUIPage;
+    private YourHorsesGUI yourHorsesGUI;
+    private YourHorsesGUIPage yourHorsesGUIPage;
+
+    public HorseOwner(Player p) {
+        this(p.getUniqueId());
+    }
+
+    public HorseOwner(UUID uuid) {
+        this(uuid, new ArrayList<>());
+    }
+
+    public HorseOwner(UUID uuid, List<RPGHorse> rpgHorses) {
+        this.uuid = uuid;
+        this.rpgHorses = rpgHorses;
+    }
+
+    public UUID getUUID() {
+        return uuid;
+    }
+    
+    public Player getPlayer() {
+        return Bukkit.getPlayer(uuid);
+    }
+
+    public List<RPGHorse> getRPGHorses() {
+        return this.rpgHorses;
+    }
+
+    public RPGHorse getRPGHorse(int index) {
+        if (index >= 0 && index < this.rpgHorses.size()) {
+            return this.rpgHorses.get(index);
+        }
+        return null;
+    }
+
+    public void addRPGHorse(RPGHorse rpgHorse) {
+        this.rpgHorses.add(rpgHorse);
+        rpgHorse.setHorseOwner(this);
+    }
+
+    public RPGHorse removeRPGHorse(int index) {
+        if (index >= 0 && index < this.rpgHorses.size()) {
+            RPGHorse rpgHorse = this.rpgHorses.get(index);
+            this.removeRPGHorse(rpgHorse);
+            return rpgHorse;
+        }
+        return null;
+    }
+
+    public void removeRPGHorse(RPGHorse rpgHorse) {
+        if (rpgHorse == this.currentHorse) {
+            this.setCurrentHorse(null);
+        }
+        this.rpgHorses.remove(rpgHorse);
+    }
+
+    public RPGHorse getCurrentHorse() {
+        return currentHorse;
+    }
+
+    public void setCurrentHorse(RPGHorse rpgHorse) {
+        if (this.currentHorse != rpgHorse) {
+            if (this.currentHorse != null) {
+                if (rpgHorse != null) {
+                    AbstractHorse horse = this.currentHorse.getHorse();
+                    if (horse != null) {
+                        for (Entity entity : horse.getPassengers()) {
+                            if (entity.getUniqueId() == this.uuid) {
+                                this.setChangingHorse(true);
+                            }
+                        }
+                    }
+                }
+                this.currentHorse.despawnEntity();
+            }
+
+            if (rpgHorse != null) {
+                this.stableGUI.addGlow(rpgHorse);
+            }
+
+            this.currentHorse = rpgHorse;
+
+            if (rpgHorse != null) {
+                this.currentHorse.spawnEntity();
+            }
+        }
+    }
+
+    public int getHorseNumber(RPGHorse rpgHorse) {
+        for (int i = 0; i < this.rpgHorses.size(); i++) {
+            if (this.rpgHorses.get(i) == rpgHorse) {
+                return i + 1;
+            }
+        }
+        return -1;
+    }
+
+    public boolean isSpawningHorse() {
+        return this.spawningHorse;
+    }
+
+    public void setSpawningHorse(boolean spawningHorse) {
+        this.spawningHorse = spawningHorse;
+    }
+
+    public boolean isMountingHorse() {
+        return mountingHorse;
+    }
+
+    public void setMountingHorse(boolean mountingHorse) {
+        this.mountingHorse = mountingHorse;
+    }
+
+    public boolean isDeMountingHorse() {
+        return deMountingHorse;
+    }
+
+    public void setDeMountingHorse(boolean deMountingHorse) {
+        this.deMountingHorse = deMountingHorse;
+    }
+
+    public boolean isChangingHorse() {
+        return changingHorse;
+    }
+
+    public void setChangingHorse(boolean changingHorse) {
+        this.changingHorse = changingHorse;
+    }
+
+    public boolean isInStableInventory() {
+        return inStableInventory;
+    }
+
+    public void setInStableInventory(boolean inStableInventory) {
+        this.inStableInventory = inStableInventory;
+        if (inStableInventory == false) {
+            this.stableGUIPage = null;
+        } else {
+            this.inMarketInventory = false;
+            this.marketGUIPage = null;
+            this.inYourHorsesInventory = false;
+            this.yourHorsesGUIPage = null;
+        }
+    }
+    
+    public Location getLastHorseLocation() {
+        return lastHorseLocation;
+    }
+    
+    public void setLastHorseLocation(Location lastHorseLocation) {
+        this.lastHorseLocation = lastHorseLocation;
+    }
+    
+    public void setStableGUI(StableGUI stableGUI) {
+        this.stableGUI = stableGUI;
+        if (this.inStableInventory && this.stableGUIPage != null) {
+            int pageNum = this.stableGUIPage.getPageNum();
+            while (pageNum > 0) {
+                StableGUIPage stableGUIPage = stableGUI.getPage(pageNum--);
+                if (stableGUIPage != null) {
+                    this.openStableGUIPage(stableGUIPage);
+                    break;
+                }
+            }
+        }
+    }
+
+    public void openStableGUIPage(int pageNum) {
+        StableGUIPage stableGUIPage = this.stableGUI.getPage(pageNum);
+        this.openStableGUIPage(stableGUIPage);
+    }
+
+    public void openStableGUIPage(StableGUIPage stableGUIPage) {
+        if (stableGUIPage != null) {
+            Bukkit.getPlayer(this.uuid).openInventory(stableGUIPage.getGUI());
+            this.stableGUIPage = stableGUIPage;
+            this.setInStableInventory(true);
+        }
+    }
+
+    public StableGUI getStableGUI() {
+        return stableGUI;
+    }
+
+    public StableGUIPage getCurrentStableGUIPage() {
+        return this.stableGUIPage;
+    }
+
+    public boolean isInYourHorsesInventory() {
+        return inYourHorsesInventory;
+    }
+
+    public void setInYourHorsesInventory(boolean inYourHorsesInventory) {
+        this.inYourHorsesInventory = inYourHorsesInventory;
+        if (inYourHorsesInventory == false) {
+            this.yourHorsesGUIPage = null;
+        } else {
+            this.inMarketInventory = false;
+            this.marketGUIPage = null;
+            this.inStableInventory = false;
+            this.stableGUIPage = null;
+        }
+    }
+
+    public void setYourHorsesGUI(YourHorsesGUI yourHorsesGUI) {
+        this.yourHorsesGUI = yourHorsesGUI;
+        if (this.inYourHorsesInventory) {
+            int pageNum = this.yourHorsesGUIPage.getPageNum();
+            while (pageNum > 0) {
+                YourHorsesGUIPage yourHorsesGUIPage = yourHorsesGUI.getPage(pageNum--);
+                if (yourHorsesGUIPage != null) {
+                    this.openYourHorsesGUIPage(yourHorsesGUIPage);
+                    break;
+                }
+            }
+        }
+    }
+
+    public void openYourHorsesGUIPage(int pageNum) {
+        YourHorsesGUIPage yourHorsesGUIPage = this.yourHorsesGUI.getPage(pageNum);
+        this.openYourHorsesGUIPage(yourHorsesGUIPage);
+    }
+
+    public void openYourHorsesGUIPage(YourHorsesGUIPage yourHorsesGUIPage) {
+        if (yourHorsesGUIPage != null) {
+            Bukkit.getPlayer(this.uuid).openInventory(yourHorsesGUIPage.getGUI());
+            this.yourHorsesGUIPage = yourHorsesGUIPage;
+            this.setInYourHorsesInventory(true);
+        }
+    }
+
+    public YourHorsesGUI getYourHorsesGUI() {
+        return yourHorsesGUI;
+    }
+
+    public YourHorsesGUIPage getCurrentYourHorsesGUIPage() {
+        return this.yourHorsesGUIPage;
+    }
+
+    public boolean isInMarketInventory() {
+        return inMarketInventory;
+    }
+
+    public void setInMarketInventory(boolean inMarketInventory) {
+        this.inMarketInventory = inMarketInventory;
+        if (inMarketInventory == false) {
+            this.marketGUIPage = null;
+        } else {
+            this.inStableInventory = false;
+            this.stableGUIPage = null;
+            this.inYourHorsesInventory = false;
+            this.yourHorsesGUIPage = null;
+        }
+    }
+
+    public void openMarketGUIPage(MarketGUIPage marketGUIPage) {
+        if (marketGUIPage != null) {
+            Bukkit.getPlayer(this.uuid).openInventory(marketGUIPage.getGUI());
+            this.marketGUIPage = marketGUIPage;
+            this.setInMarketInventory(true);
+        }
+    }
+
+    public MarketGUIPage getCurrentMarketGUIPage() {
+        return marketGUIPage;
+    }
+}
diff --git a/src/org/plugins/rpghorses/players/HorseRenamer.java b/src/org/plugins/rpghorses/players/HorseRenamer.java
new file mode 100644
index 0000000..e108529
--- /dev/null
+++ b/src/org/plugins/rpghorses/players/HorseRenamer.java
@@ -0,0 +1,52 @@
+package org.plugins.rpghorses.players;
+
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.managers.RPGHorseManager;
+
+public class HorseRenamer {
+
+    private final RPGHorsesMain plugin;
+    private final RPGHorseManager rpgHorseManager;
+
+    private HorseOwner horseOwner;
+    private RPGHorse rpgHorse;
+    private BukkitTask timeoutTask;
+
+    public HorseRenamer(RPGHorsesMain plugin, RPGHorseManager rpgHorseManager, HorseOwner horseOwner, RPGHorse rpgHorse) {
+        this.plugin = plugin;
+        this.rpgHorseManager = rpgHorseManager;
+        this.horseOwner = horseOwner;
+        this.rpgHorse = rpgHorse;
+
+        this.startTask();
+    }
+
+    public HorseOwner getHorseOwner() {
+        return horseOwner;
+    }
+
+    public RPGHorse getRPGHorse() {
+        return this.rpgHorse;
+    }
+
+    public void startTask() {
+        this.endTask();
+
+        this.timeoutTask = new BukkitRunnable() {
+            @Override
+            public void run() {
+                rpgHorseManager.removeHorseRenamer(horseOwner.getUUID());
+            }
+        }.runTaskLaterAsynchronously(this.plugin, 20L * 20);
+    }
+
+    public void endTask() {
+        if (this.timeoutTask != null) {
+            this.timeoutTask.cancel();
+            this.timeoutTask = null;
+        }
+    }
+}
diff --git a/src/org/plugins/rpghorses/players/RemoveHorseConfirmation.java b/src/org/plugins/rpghorses/players/RemoveHorseConfirmation.java
new file mode 100644
index 0000000..d51b77e
--- /dev/null
+++ b/src/org/plugins/rpghorses/players/RemoveHorseConfirmation.java
@@ -0,0 +1,52 @@
+package org.plugins.rpghorses.players;
+
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+import org.plugins.rpghorses.RPGHorsesMain;
+import org.plugins.rpghorses.horses.RPGHorse;
+import org.plugins.rpghorses.managers.RPGHorseManager;
+
+public class RemoveHorseConfirmation {
+
+    private final RPGHorsesMain plugin;
+    private final RPGHorseManager rpgHorseManager;
+
+    private HorseOwner horseOwner;
+    private RPGHorse rpgHorse;
+    private BukkitTask timeoutTask;
+
+    public RemoveHorseConfirmation(RPGHorsesMain plugin, RPGHorseManager rpgHorseManager, HorseOwner horseOwner, RPGHorse rpgHorse) {
+        this.plugin = plugin;
+        this.rpgHorseManager = rpgHorseManager;
+        this.horseOwner = horseOwner;
+        this.rpgHorse = rpgHorse;
+
+        this.startTask();
+    }
+
+    public HorseOwner getHorseOwner() {
+        return horseOwner;
+    }
+
+    public RPGHorse getRPGHorse() {
+        return this.rpgHorse;
+    }
+
+    public void startTask() {
+        this.endTask();
+
+        this.timeoutTask = new BukkitRunnable() {
+            @Override
+            public void run() {
+                rpgHorseManager.removeRemoveConfirmation(horseOwner.getUUID());
+            }
+        }.runTaskLater(this.plugin, 20L * 20);
+    }
+
+    public void endTask() {
+        if (this.timeoutTask != null) {
+            this.timeoutTask.cancel();
+            this.timeoutTask = null;
+        }
+    }
+}
diff --git a/src/org/plugins/rpghorses/utils/CustomConfigUtil.java b/src/org/plugins/rpghorses/utils/CustomConfigUtil.java
new file mode 100644
index 0000000..e241c26
--- /dev/null
+++ b/src/org/plugins/rpghorses/utils/CustomConfigUtil.java
@@ -0,0 +1,23 @@
+package org.plugins.rpghorses.utils;
+
+import org.bukkit.plugin.java.JavaPlugin;
+import org.plugins.rpghorses.configs.CustomConfig;
+
+/**
+ * Created by Rory on 7/8/2017.
+ */
+public class CustomConfigUtil {
+
+    public static void loadConfig(CustomConfig customConfig) {
+        customConfig.getConfig().options().copyDefaults(true);
+        customConfig.saveDefaultConfig();
+        customConfig.reloadConfig();
+    }
+
+    public static void loadDefaultConfig(JavaPlugin plugin) {
+        plugin.getConfig().options().copyDefaults(true);
+        plugin.saveDefaultConfig();
+        plugin.reloadConfig();
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/utils/ItemUtil.java b/src/org/plugins/rpghorses/utils/ItemUtil.java
new file mode 100644
index 0000000..46a6fea
--- /dev/null
+++ b/src/org/plugins/rpghorses/utils/ItemUtil.java
@@ -0,0 +1,227 @@
+package org.plugins.rpghorses.utils;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import org.bukkit.Material;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.SkullMeta;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Created by Rory on 6/30/2017.
+ */
+public class ItemUtil {
+
+    private JavaPlugin plugin;
+    private MessagingUtil messagingUtil;
+
+    public ItemUtil(JavaPlugin plugin, MessagingUtil messagingUtil) {
+        this.plugin = plugin;
+        this.messagingUtil = messagingUtil;
+    }
+
+    public ItemStack getItemStack(String path) {
+        ItemStack item = null;
+        if (!path.endsWith(".")) {
+            path += ".";
+        }
+        try {
+            Material mat = Material.valueOf(this.plugin.getConfig().getString(path + "material", "NULL"));
+            int amount = this.plugin.getConfig().getInt(path + "amount", 1);
+            item = new ItemStack(mat, amount);
+            short data = (short) this.plugin.getConfig().getInt(path + "data", item.getDurability());
+            item.setDurability(data);
+            ItemMeta itemMeta = item.getItemMeta();
+            String name = this.plugin.getConfig().getString(path + "name", "");
+            if (!name.equals("")) {
+                itemMeta.setDisplayName(this.messagingUtil.placeholders(name));
+            }
+
+            List<String> loreLines = this.plugin.getConfig().getStringList(path + "lore");
+            if (!loreLines.isEmpty()) {
+                List<String> lore = new ArrayList<String>();
+                for (String loreLine : loreLines) {
+                    lore.add(this.messagingUtil.placeholders(loreLine));
+                }
+                itemMeta.setLore(lore);
+            }
+
+            List<String> enchants = this.plugin.getConfig().getStringList(path + "enchants");
+            for (String enchantInfo : enchants) {
+                int colonIndex = enchantInfo.indexOf(":");
+                Enchantment enchantment = Enchantment.getByName(enchantInfo.substring(0, colonIndex));
+                if (enchantment != null) {
+                    int level = Integer.parseInt(enchantInfo.substring(colonIndex + 1, enchantInfo.length()));
+                    itemMeta.addEnchant(enchantment, level, true);
+                }
+            }
+
+            List<String> itemFlags = this.plugin.getConfig().getStringList(path + "item-flags");
+            for (String itemFlag : itemFlags) {
+                itemMeta.addItemFlags(ItemFlag.valueOf(itemFlag));
+            }
+
+            if (mat == Material.SKULL_ITEM && this.plugin.getConfig().isSet(path + "skin-value")) {
+                item.setDurability((short) 3);
+                ItemMeta oldItemMeta = itemMeta;
+                itemMeta = this.applyCustomHead(itemMeta, this.plugin.getConfig().getString(path + "skin-value"));
+                if (itemMeta == null) {
+                    itemMeta = oldItemMeta;
+                    this.plugin.getLogger().info("[" + this.plugin.getName() + "] Failed to load skull skin-value @ " + path);
+                }
+            }
+
+            item.setItemMeta(itemMeta);
+
+            return item;
+        } catch (IllegalArgumentException e) {
+            return null;
+        }
+    }
+
+    public SkullMeta applyCustomHead(ItemMeta itemMeta, String value) {
+        GameProfile gameProfile = new GameProfile(UUID.randomUUID(), null);
+        gameProfile.getProperties().put("textures", new Property("textures", value));
+
+        SkullMeta skullMeta = (SkullMeta) itemMeta;
+        try {
+            Field profileField = skullMeta.getClass().getDeclaredField("profile");
+            profileField.setAccessible(true);
+            profileField.set(skullMeta, gameProfile);
+        } catch (NoSuchFieldException | IllegalArgumentException | IllegalAccessException exception) {
+            return null;
+        }
+
+        return skullMeta;
+    }
+
+    public int getSlot(String path) {
+        int xCord = this.plugin.getConfig().getInt(path + ".x-cord");
+        int yCord = this.plugin.getConfig().getInt(path + ".y-cord");
+        return ItemUtil.getSlot(xCord, yCord);
+    }
+
+    public static int getSlot(int xCord, int yCord) {
+        return ((yCord - 1) * 9) + xCord - 1;
+    }
+
+    public static int getX(int slot) {
+        return slot % 9 + 1;
+    }
+
+    public static int getY(int slot) {
+        return slot / 9 + 1;
+    }
+
+    public static ItemStack getItemStack(FileConfiguration config, String path) {
+        ItemStack item = null;
+        if (!path.endsWith(".")) {
+            path += ".";
+        }
+        try {
+            Material mat = Material.valueOf(config.getString(path + "material", "NULL"));
+            int amount = config.getInt(path + "amount", 1);
+            item = new ItemStack(mat, amount);
+            short data = (short) config.getInt(path + "data", item.getDurability());
+            item.setDurability(data);
+            ItemMeta itemMeta = item.getItemMeta();
+            String name = config.getString(path + "name", "");
+            if (!name.equals("")) {
+                itemMeta.setDisplayName(MessagingUtil.format(name));
+            }
+
+            List<String> loreLines = config.getStringList(path + "lore");
+            if (!loreLines.isEmpty()) {
+                List<String> lore = new ArrayList<String>();
+                for (String loreLine : loreLines) {
+                    lore.add(MessagingUtil.format(loreLine));
+                }
+                itemMeta.setLore(lore);
+            }
+
+            List<String> enchants = config.getStringList(path + "enchants");
+            for (String enchantInfo : enchants) {
+                int colonIndex = enchantInfo.indexOf(":");
+                String enchantName = enchantInfo.substring(0, colonIndex);
+                int level = Integer.parseInt(enchantInfo.substring(colonIndex + 1, enchantInfo.length()));
+                itemMeta.addEnchant(Enchantment.getByName(enchantName), level, true);
+            }
+
+            List<String> itemFlags = config.getStringList(path + "item-flags");
+            for (String itemFlag : itemFlags) {
+                itemMeta.addItemFlags(ItemFlag.valueOf(itemFlag));
+            }
+
+            String skullOwner = config.getString(path + "skull-owner", "");
+            if (mat == Material.SKULL_ITEM && data == 3 && !skullOwner.equals("")) {
+                SkullMeta skullMeta = (SkullMeta) itemMeta;
+                skullMeta.setOwner(skullOwner);
+                item.setItemMeta(skullMeta);
+            } else {
+                item.setItemMeta(itemMeta);
+            }
+            return item;
+        } catch (IllegalArgumentException e) {
+            return null;
+        }
+    }
+
+    public static void addDurabilityGlow(ItemStack item) {
+        ItemMeta itemMeta = item.getItemMeta();
+        itemMeta.addEnchant(Enchantment.DURABILITY, 3, true);
+        itemMeta.addItemFlags(ItemFlag.HIDE_ENCHANTS);
+        item.setItemMeta(itemMeta);
+    }
+
+    public static void storeItemStack(ItemStack item, FileConfiguration config, String path) {
+        if (!path.endsWith(".")) {
+            path += ".";
+        }
+        config.set(path + "material", item.getType().name());
+        config.set(path + "amount", item.getAmount());
+        config.set(path + "data", item.getDurability());
+
+        ItemMeta itemMeta = item.getItemMeta();
+
+        if (itemMeta.hasDisplayName()) {
+            config.set(path + "name", itemMeta.getDisplayName());
+        }
+
+        if (itemMeta.hasLore()) {
+            config.set(path + "lore", itemMeta.getLore());
+        }
+
+        if (itemMeta.hasEnchants()) {
+            List<String> enchants = new ArrayList<String>();
+            for (Map.Entry<Enchantment, Integer> enchant : itemMeta.getEnchants().entrySet()) {
+                enchants.add(enchant.getKey().getName() + ":" + enchant.getValue());
+                config.set(path + "enchants", enchants);
+
+            }
+        }
+
+        List<String> itemFlags = new ArrayList<>();
+        for (ItemFlag itemFlag : itemMeta.getItemFlags()) {
+            itemFlags.add(itemFlag.name());
+        }
+        if (!itemFlags.isEmpty()) {
+            config.set(path + "item-flags", itemFlags);
+        }
+
+        if (item.getType() == Material.SKULL_ITEM && item.getDurability() == 3) {
+            SkullMeta skullMeta = (SkullMeta) itemMeta;
+            config.set(path + "skull-owner", skullMeta.getOwner());
+        }
+    }
+
+}
diff --git a/src/org/plugins/rpghorses/utils/LocationUtil.java b/src/org/plugins/rpghorses/utils/LocationUtil.java
new file mode 100644
index 0000000..ca51112
--- /dev/null
+++ b/src/org/plugins/rpghorses/utils/LocationUtil.java
@@ -0,0 +1,29 @@
+package org.plugins.rpghorses.utils;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+
+/**
+ * Created by Rory on 6/25/2017.
+ */
+public class LocationUtil {
+
+    public static Location fromString(String string) {
+        string = string.replace(',', '.');
+        String[] args = string.split("\\|");
+        Location loc = new Location(Bukkit.getWorld(args[0]), Double.valueOf(args[1]), Double.valueOf(args[2]), Double.valueOf(args[3]));
+        if (args.length > 4) {
+            loc.setPitch(Float.valueOf(args[4]));
+            loc.setPitch(Float.valueOf(args[5]));
+        }
+        return loc;
+    }
+
+    public static String toBlockString(Location loc) {
+        return loc.getWorld().getName() + "|" + loc.getBlockX() + "|" + loc.getBlockY() + "|" + loc.getBlockZ();
+    }
+
+    public static String toString(Location loc) {
+        return (loc.getWorld().getName() + "|" + loc.getX() + "|" + loc.getY() + "|" + loc.getZ() + "|" + loc.getPitch() + "|" + loc.getYaw()).replace('.', ',');
+    }
+}
diff --git a/src/org/plugins/rpghorses/utils/MessagingUtil.java b/src/org/plugins/rpghorses/utils/MessagingUtil.java
new file mode 100644
index 0000000..bf0e8c5
--- /dev/null
+++ b/src/org/plugins/rpghorses/utils/MessagingUtil.java
@@ -0,0 +1,121 @@
+package org.plugins.rpghorses.utils;
+
+import org.apache.commons.lang.StringEscapeUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.plugins.rpghorses.horses.RPGHorse;
+
+/**
+ * Created by Rory on 6/22/2017.
+ */
+public class MessagingUtil {
+
+    private final JavaPlugin plugin;
+    private String prefix = "";
+    private String finalPrefixFormatting = "";
+
+    public MessagingUtil(JavaPlugin plugin) {
+        this.plugin = plugin;
+        this.updatePrefix();
+    }
+
+    public void updatePrefix() {
+        this.prefix = this.plugin.getConfig().getString("prefix");
+        this.updatePrefixFormatting();
+    }
+
+    private void updatePrefixFormatting() {
+        String color = "", format = "";
+        if (this.prefix.length() > 1) {
+            for (int index = this.prefix.length(); index > 1; index--) {
+                String bit = this.prefix.substring(index - 2, index);
+                if (bit.startsWith("§")) {
+                    int chNum = (int) bit.toLowerCase().charAt(1);
+                    if ((97 <= chNum && chNum <= 102) || (48 <= chNum && chNum <= 57) || chNum == 114) {
+                        color = bit;
+                        break;
+                    }
+                    if (107 <= chNum && chNum <= 112) {
+                        format += bit;
+                    }
+
+                }
+            }
+        }
+        this.finalPrefixFormatting = color + format;
+    }
+
+    public String getPrefix() {
+        return this.prefix;
+    }
+
+    public String getPrefixFormatting() {
+        return this.finalPrefixFormatting;
+    }
+
+    public void sendMessage(CommandSender sender, String msg) {
+        sender.sendMessage(this.placeholders(msg));
+    }
+
+    public void sendMessage(CommandSender sender, String msg, RPGHorse rpgHorse) {
+        sender.sendMessage(this.placeholders(msg, rpgHorse));
+    }
+
+    public void sendMessageAtPath(CommandSender sender, String path) {
+        sender.sendMessage(this.placeholders(this.plugin.getConfig().getString(path)));
+    }
+
+    public void sendMessageAtPath(CommandSender sender, String path, RPGHorse rpgHorse) {
+        sender.sendMessage(this.placeholders(this.plugin.getConfig().getString(path), rpgHorse));
+    }
+
+    public void broadcastMessage(String msg) {
+        Bukkit.broadcastMessage(this.placeholders(msg));
+    }
+
+    public void broadcastMessageAtPath(String path) {
+        Bukkit.broadcastMessage(this.placeholders(this.plugin.getConfig().getString(path)));
+    }
+
+    public String placeholders(String arg) {
+        return StringEscapeUtils.unescapeJava(ChatColor.translateAlternateColorCodes('&', arg.replace("{PREFIX}", this.prefix)));
+    }
+
+    public String placeholders(String arg, RPGHorse rpgHorse) {
+        return StringEscapeUtils.unescapeJava(ChatColor.translateAlternateColorCodes('&', arg.replace("{PREFIX}", this.prefix).replace("{HORSE-NAME}", rpgHorse.getName())));
+    }
+
+    public static String format(String arg) {
+        return StringEscapeUtils.unescapeJava(ChatColor.translateAlternateColorCodes('&', arg));
+    }
+
+    public static String format(String arg, RPGHorse rpgHorse) {
+        return StringEscapeUtils.unescapeJava(ChatColor.translateAlternateColorCodes('&', arg.replace("{HORSE-NAME}", rpgHorse.getName())));
+    }
+    
+    public String getProgressBar(double progress, double maxProgress, int progressBarCount, String completedColor, String missingColor, String progressBarChar) {
+        int completedProgress;
+        if (maxProgress == 0) {
+            completedProgress = progressBarCount;
+        } else {
+            completedProgress = (int) Math.floor((progress / maxProgress) * progressBarCount);
+        }
+        completedProgress = completedProgress > progressBarCount ? progressBarCount : completedProgress;
+        int uncompletedProgress = progressBarCount - completedProgress;
+        
+        String progressBar = completedColor;
+        for (int i = 0; i < completedProgress; i++) {
+            progressBar += progressBarChar;
+        }
+        
+        if (uncompletedProgress > 0) {
+            progressBar += missingColor;
+            for (int i = 0; i < uncompletedProgress; i++) {
+                progressBar += progressBarChar;
+            }
+        }
+        return MessagingUtil.format(progressBar);
+    }
+}
diff --git a/src/org/plugins/rpghorses/utils/NumberUtil.java b/src/org/plugins/rpghorses/utils/NumberUtil.java
new file mode 100644
index 0000000..8fb2bb3
--- /dev/null
+++ b/src/org/plugins/rpghorses/utils/NumberUtil.java
@@ -0,0 +1,83 @@
+package org.plugins.rpghorses.utils;
+
+public class NumberUtil {
+
+    public static boolean isInt(String arg) {
+        try {
+            Integer.parseInt(arg);
+        } catch (NumberFormatException e) {
+            return false;
+        }
+        return true;
+    }
+
+    public static boolean isPositiveInt(String arg) {
+        try {
+            int i = Integer.parseInt(arg);
+            return i >= 0;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+
+    public static boolean isNegativeInt(String arg) {
+        try {
+            int i = Integer.parseInt(arg);
+            return i < 0;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+
+    public static boolean isDouble(String arg) {
+        try {
+            Double.parseDouble(arg);
+        } catch (NumberFormatException e) {
+            return false;
+        }
+        return true;
+    }
+
+    public static boolean isPositiveDouble(String arg) {
+        try {
+            double i = Double.parseDouble(arg);
+            return i >= 0;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+
+    public static boolean isNegativeDouble(String arg) {
+        try {
+            double i = Double.parseDouble(arg);
+            return i < 0;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+
+    public static String formatMoney(String money) {
+        int eIndex = money.indexOf("E");
+        if (eIndex != -1) {
+            int eValue = Integer.valueOf(money.substring(eIndex + 1, money.length()));
+            money = money.substring(0, eIndex).replace(".", "");
+            int bound = (eValue - money.length()) + 1;
+            if (money.length() < eValue) {
+                for (int i = 0; i < bound; i++) {
+                    money += "0";
+                }
+            }
+        }
+        String beforeDot = money;
+
+        if (money.contains(".")) {
+            beforeDot = money.substring(0, money.indexOf("."));
+        }
+
+        String newBeforeDot = beforeDot;
+        for (int i = beforeDot.length() - 3; i > 0; i -= 3) {
+            newBeforeDot = beforeDot.substring(0, i) + "," + newBeforeDot.substring(i, newBeforeDot.length());
+        }
+        return newBeforeDot;
+    }
+}
diff --git a/src/org/plugins/rpghorses/utils/SkinUtil.java b/src/org/plugins/rpghorses/utils/SkinUtil.java
new file mode 100644
index 0000000..2c24446
--- /dev/null
+++ b/src/org/plugins/rpghorses/utils/SkinUtil.java
@@ -0,0 +1,43 @@
+package org.plugins.rpghorses.utils;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.util.UUID;
+
+public class SkinUtil {
+
+    private static JsonParser parser = new JsonParser();
+
+    public static UUID getUUIDFromName(String name) {
+        try {
+            URL url_0 = new URL("https://api.mojang.com/users/profiles/minecraft/" + name);
+            InputStreamReader reader_0 = new InputStreamReader(url_0.openStream());
+            String uuidString = SkinUtil.parser.parse(reader_0).getAsJsonObject().get("id").getAsString();
+            uuidString = uuidString.substring(0, 8) + "-" + uuidString.substring(8, 12) + "-" + uuidString.substring(12, 16) + "-" + uuidString.substring(16, 20) + "-" + uuidString.substring(20);
+            return UUID.fromString(uuidString);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    public static String[] getValueAndSignature(UUID uuid) {
+        try {
+            String uuidStr = uuid.toString().replace("-", "");
+            URL url_1 = new URL("https://sessionserver.mojang.com/session/minecraft/profile/" + uuidStr + "?unsigned=false");
+            InputStreamReader reader_1 = new InputStreamReader(url_1.openStream());
+            JsonObject textureProperty = new JsonParser().parse(reader_1).getAsJsonObject().get("properties").getAsJsonArray().get(0).getAsJsonObject();
+            String texture = textureProperty.get("value").getAsString();
+            String signature = textureProperty.get("signature").getAsString();
+            String[] args = new String[2];
+            args[0] = texture;
+            args[1] = signature;
+            return args;
+        } catch (Exception e) {
+            return null;
+        }
+    }
+}
diff --git a/src/org/plugins/rpghorses/utils/TimeUtil.java b/src/org/plugins/rpghorses/utils/TimeUtil.java
new file mode 100644
index 0000000..7a9c703
--- /dev/null
+++ b/src/org/plugins/rpghorses/utils/TimeUtil.java
@@ -0,0 +1,387 @@
+package org.plugins.rpghorses.utils;
+
+import org.bukkit.configuration.file.FileConfiguration;
+
+/**
+ * Created by Rory on 11/21/2016.
+ */
+public class TimeUtil {
+
+    private static String second = "second";
+    private static String seconds = "seconds";
+    private static String minute = "minute";
+    private static String minutes = "minutes";
+    private static String hour = "hour";
+    private static String hours = "hours";
+    private static String day = "day";
+    private static String days = "days";
+    private static String week = "week";
+    private static String weeks = "weeks";
+    private static String month = "month";
+    private static String months = "months";
+    private static String year = "year";
+    private static String years = "years";
+    private static String and = "and";
+
+    public static void refreshUnitStrings(FileConfiguration config, String path) {
+        TimeUtil.setSecond(config.getString(path + "second", "second"));
+        TimeUtil.setSeconds(config.getString(path + "seconds", "seconds"));
+        TimeUtil.setMinute(config.getString(path + "minute", "minute"));
+        TimeUtil.setMinutes(config.getString(path + "minutes", "minutes"));
+        TimeUtil.setHour(config.getString(path + "hour", "hour"));
+        TimeUtil.setHours(config.getString(path + "hours", "hours"));
+        TimeUtil.setDay(config.getString(path + "day", "day"));
+        TimeUtil.setDays(config.getString(path + "days", "days"));
+        TimeUtil.setWeek(config.getString(path + "week", "week"));
+        TimeUtil.setWeeks(config.getString(path + "weeks", "weeks"));
+        TimeUtil.setMonth(config.getString(path + "month", "month"));
+        TimeUtil.setMonths(config.getString(path + "months", "months"));
+        TimeUtil.setYear(config.getString(path + "year", "year"));
+        TimeUtil.setYears(config.getString(path + "years", "years"));
+        TimeUtil.setAnd(config.getString(path + "and", "and"));
+    }
+
+    public static void setSecond(String second) {
+        TimeUtil.second = second;
+    }
+
+    public static void setSeconds(String seconds) {
+        TimeUtil.seconds = seconds;
+    }
+
+    public static void setMinute(String minute) {
+        TimeUtil.minute = minute;
+    }
+
+    public static void setMinutes(String minutes) {
+        TimeUtil.minutes = minutes;
+    }
+
+    public static void setHour(String hour) {
+        TimeUtil.hour = hour;
+    }
+
+    public static void setHours(String hours) {
+        TimeUtil.hours = hours;
+    }
+
+    public static void setDay(String day) {
+        TimeUtil.day = day;
+    }
+
+    public static void setDays(String days) {
+        TimeUtil.days = days;
+    }
+
+    public static void setWeek(String week) {
+        TimeUtil.week = week;
+    }
+
+    public static void setWeeks(String weeks) {
+        TimeUtil.weeks = weeks;
+    }
+
+    public static void setMonth(String month) {
+        TimeUtil.month = month;
+    }
+
+    public static void setMonths(String months) {
+        TimeUtil.months = months;
+    }
+
+    public static void setYear(String year) {
+        TimeUtil.year = year;
+    }
+
+    public static void setYears(String years) {
+        TimeUtil.years = years;
+    }
+
+    public static void setAnd(String and) {
+        TimeUtil.and = and;
+    }
+
+    public static int getUnitCount(String arg) {
+        int count = 0;
+        if (arg.length() > 1) {
+            if (NumberUtil.isInt(arg.substring(0, arg.length() - 1))) {
+                if (arg.endsWith("s")) {
+                    count++;
+                } else if (arg.endsWith("m")) {
+                    count++;
+                } else if (arg.endsWith("h")) {
+                    count++;
+                } else if (arg.endsWith("d")) {
+                    count++;
+                } else if (arg.endsWith("w")) {
+                    count++;
+                } else if (arg.endsWith("y")) {
+                    count++;
+                }
+
+            }
+        } else if (arg.length() > 2) {
+            if (arg.endsWith("mo") && NumberUtil.isInt(arg.substring(0, arg.length() - 2))) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    public static boolean isUnitOfTime(String arg) {
+        if (arg.length() > 1) {
+            if (NumberUtil.isInt(arg.substring(0, arg.length() - 1))) {
+                if (arg.endsWith("s")) {
+                    return true;
+                } else if (arg.endsWith("m")) {
+                    return true;
+                } else if (arg.endsWith("h")) {
+                    return true;
+                } else if (arg.endsWith("d")) {
+                    return true;
+                } else if (arg.endsWith("w")) {
+                    return true;
+                } else if (arg.endsWith("y")) {
+                    return true;
+                }
+
+            }
+        } else if (arg.length() > 2) {
+            if (arg.endsWith("mo") && NumberUtil.isInt(arg.substring(0, arg.length() - 2))) {
+                return true;
+            }
+        }
+
+        int index = 0;
+        while (!arg.equals("") && index < arg.length()) {
+            char ch = arg.charAt(index);
+            switch (ch) {
+                case 's':
+                    arg = arg.substring(index + 1);
+                    break;
+                case 'm':
+                    if (arg.charAt(index + 1 >= arg.length() ? index : index + 1) == 'o') {
+                        arg = arg.substring(index + 2);
+                    } else {
+                        arg = arg.substring(index + 1);
+                    }
+                    index = 0;
+                    break;
+                case 'h':
+                    arg = arg.substring(index + 1);
+                    index = 0;
+                    break;
+                case 'd':
+                    arg = arg.substring(index + 1);
+                    index = 0;
+                    break;
+                case 'w':
+                    arg = arg.substring(index + 1);
+                    index = 0;
+                    break;
+                case 'y':
+                    arg = arg.substring(index + 1);
+                    index = 0;
+                    break;
+                default:
+                    if (!NumberUtil.isInt("" + ch)) {
+                        return false;
+                    }
+            }
+            index++;
+        }
+        return true;
+    }
+
+    public static String formatTime(long seconds) {
+        String timeText = "";
+        seconds += 1L;
+        if (seconds % (60 * 60 * 24 * 365) >= 0) {
+            int timecalc = (int) Math.floor(seconds / (60 * 60 * 24 * 365));
+            seconds = seconds % (60 * 60 * 24 * 365);
+            if (timecalc != 0) {
+                if (timecalc == 1) {
+                    timeText += timecalc + " " + TimeUtil.year + ", ";
+                } else {
+                    timeText += timecalc + " " + TimeUtil.years + ", ";
+                }
+            }
+        }
+
+        if (seconds % (30 * 24 * 60 * 60) >= 0) {
+            int timecalc = (int) Math.floor(seconds / (30 * 24 * 60 * 60));
+            seconds = seconds % (30 * 24 * 60 * 60);
+            if (timecalc != 0) {
+                if (timecalc == 1) {
+                    timeText += timecalc + " " + TimeUtil.month + ", ";
+                } else {
+                    timeText +=  timecalc + " " + TimeUtil.months + ", ";
+                }
+            }
+        }
+
+        if (seconds % (60 * 60 * 24 * 7) >= 0) {
+            int timecalc = (int) Math.floor(seconds / (60 * 60 * 24 * 7));
+            seconds = seconds % (60 * 60 * 24 * 7);
+            if (timecalc != 0) {
+                if (timecalc == 1) {
+                    timeText += timecalc + " " + TimeUtil.week + ", ";
+                } else {
+                    timeText += timecalc + " " + TimeUtil.weeks + ", ";
+                }
+            }
+        }
+
+        if (seconds % (60 * 60 * 24) >= 0) {
+            int timecalc = (int) Math.floor(seconds / (60 * 60 * 24));
+            seconds = seconds % (60 * 60 * 24);
+            if (timecalc != 0) {
+                if (timecalc == 1) {
+                    timeText += timecalc + " " + TimeUtil.day + ", ";
+                } else {
+                    timeText += timecalc + " " + TimeUtil.days + ", ";
+                }
+            }
+        }
+
+        if (seconds % (60 * 60) >= 0) {
+            int timecalc = (int) Math.floor(seconds / (60 * 60));
+            seconds = seconds % (60 * 60);
+            if (timecalc != 0) {
+                if (timecalc == 1) {
+                    timeText += timecalc + " " + TimeUtil.hour + ", ";
+                } else {
+                    timeText += timecalc + " " + TimeUtil.hours + ", ";
+                }
+            }
+        }
+
+        if (seconds % 60 >= 0) {
+            int timecalc = (int) Math.floor(seconds / (60));
+            seconds = seconds % (60);
+            if (timecalc != 0) {
+                if (timecalc == 1) {
+                    timeText += timecalc + " " + TimeUtil.minute + ", ";
+                } else {
+                    timeText += timecalc + " " + TimeUtil.minutes + ", ";
+                }
+            }
+        }
+
+        if (seconds > 0) {
+            if (seconds == 1) {
+                timeText += seconds + " " + TimeUtil.second + ", ";
+            } else {
+                timeText += seconds + " " + TimeUtil.seconds + ", ";
+            }
+        }
+        if (timeText.length() > 0) {
+            timeText = timeText.substring(0, timeText.length() - 2);
+            int lastComma = timeText.lastIndexOf(",");
+            if (lastComma != -1) {
+                timeText = timeText.substring(0, lastComma) + " " + TimeUtil.and + " " + timeText.substring(lastComma + 2, timeText.length());
+            }
+        } else {
+            timeText = "0 " + TimeUtil.seconds;
+        }
+        return timeText;
+    }
+
+    public static long convertToSeconds(String time) {
+        time = time.toLowerCase();
+        long seconds = 0;
+        int index = 0;
+        if (time.equals("") || !((time.contains("s") || time.contains("m") || time.contains("h") || time.contains("d") || time.contains("w") || time.contains("y")))) {
+            return -1;
+        }
+        while (!time.equals("")) {
+            char ch = time.charAt(index);
+            switch (ch) {
+                case 's':
+                    if (!NumberUtil.isInt(time.substring(0, index))) {
+                        return -1;
+                    }
+                    seconds += Integer.parseInt(time.substring(0, index));
+                    if (time.length() > index + 1) {
+                        time = time.substring(index + 1);
+                        index = 0;
+                    } else {
+                        return seconds;
+                    }
+                    break;
+                case 'm':
+                    if (!NumberUtil.isInt(time.substring(0, index))) {
+                        return -1;
+                    }
+                    if (time.charAt(index + 1 >= time.length() ? index : index + 1) == 'o') {
+                        seconds += Integer.parseInt(time.substring(0, index)) * 30 * 24 * 60 * 60;
+                        if (time.length() > index + 2) {
+                            time = time.substring(index + 2);
+                        } else {
+                            return seconds;
+                        }
+                    } else {
+                        seconds += Integer.parseInt(time.substring(0, index)) * 60;
+                        if (time.length() > index + 1) {
+                            time = time.substring(index + 1);
+                        } else {
+                            return seconds;
+                        }
+                    }
+                    index = 0;
+                    break;
+                case 'h':
+                    if (!NumberUtil.isInt(time.substring(0, index))) {
+                        return -1;
+                    }
+                    seconds += Integer.parseInt(time.substring(0, index)) * 60 * 60;
+                    if (time.length() > index + 1) {
+                        time = time.substring(index + 1);
+                        index = 0;
+                    } else {
+                        return seconds;
+                    }
+                    break;
+                case 'd':
+                    if (!NumberUtil.isInt(time.substring(0, index))) {
+                        return -1;
+                    }
+                    seconds += Integer.parseInt(time.substring(0, index)) * 60 * 60 * 24;
+                    if (time.length() > index + 1) {
+                        time = time.substring(index + 1);
+                        index = 0;
+                    } else {
+                        return seconds;
+                    }
+                    break;
+                case 'w':
+                    if (!NumberUtil.isInt(time.substring(0, index))) {
+                        return -1;
+                    }
+                    seconds += Integer.parseInt(time.substring(0, index)) * 60 * 60 * 24 * 7;
+                    if (time.length() > index + 1) {
+                        time = time.substring(index + 1);
+                        index = 0;
+                    } else {
+                        return seconds;
+                    }
+                    break;
+                case 'y':
+                    if (!NumberUtil.isInt(time.substring(0, index))) {
+                        return -1;
+                    }
+                    seconds += Integer.parseInt(time.substring(0, index)) * 60 * 60 * 24 * 365;
+                    if (time.length() > index + 1) {
+                        time = time.substring(index + 1);
+                        index = 0;
+                    } else {
+                        return seconds;
+                    }
+                    break;
+            }
+            index++;
+        }
+        return seconds;
+    }
+
+}