stendhal/tests/utilities/PlayerTestHelper.java

package utilities;

import games.stendhal.server.core.engine.SingletonRepository;
import games.stendhal.server.core.engine.StendhalRPZone;
import games.stendhal.server.core.engine.transformer.PlayerTransformer;
import games.stendhal.server.entity.ActiveEntity;
import games.stendhal.server.entity.Entity;
import games.stendhal.server.entity.Outfit;
import games.stendhal.server.entity.RPEntity;
import games.stendhal.server.entity.creature.Creature;
import games.stendhal.server.entity.item.Item;
import games.stendhal.server.entity.item.StackableItem;
import games.stendhal.server.entity.npc.ConversationStates;
import games.stendhal.server.entity.npc.NPC;
import games.stendhal.server.entity.npc.SpeakerNPC;
import games.stendhal.server.entity.player.Player;
import games.stendhal.server.entity.slot.PlayerSlot;
import games.stendhal.server.maps.MockStendhalRPRuleProcessor;
import games.stendhal.server.maps.MockStendlRPWorld;

import java.util.Iterator;
import java.util.List;

import marauroa.common.game.RPClass;
import marauroa.common.game.RPEvent;
import marauroa.common.game.RPObject;
import marauroa.common.game.RPSlot;

import org.apache.log4j.Logger;

import utilities.RPClass.ItemTestHelper;

public abstract class PlayerTestHelper {
	private static Logger logger = Logger.getLogger(PlayerTestHelper.class);

	/**
	 * Create a named player.
	 * 
	 * @param name
	 * @return player
	 */
	public static Player createPlayer(final String name) {
		generatePlayerRPClasses();

		RPObject object = new RPObject();
		object.put("name", name);
		final Player pl = (Player) new PlayerTransformer().transform(object);
		Iterator<RPEvent> eventsIterator = pl.eventsIterator();
		while(eventsIterator.hasNext()) {
			eventsIterator.next();
			eventsIterator.remove();
		}
		
		pl.setName(name);

		//addEmptySlots(pl);

		return pl;
	}

	/**
	 * Register a player in rule processor, world and zone.
	 * 
	 * @param player
	 * @param zoneName
	 */
	public static void registerPlayer(final Player player, final String zoneName) {
		registerPlayer(player, SingletonRepository.getRPWorld().getZone(zoneName));
	}

	/**
	 * Register a player in rule processor, world and zone.
	 * 
	 * @param player
	 * @param zone
	 */
	public static void registerPlayer(final Player player, final StendhalRPZone zone) {
		registerPlayer(player);

		zone.add(player);
	}

	/**
	 * Register a player in rule processor and world.
	 * 
	 * @param player
	 */
	public static void registerPlayer(final Player player) {
		MockStendhalRPRuleProcessor.get().addPlayer(player);

		MockStendlRPWorld.get().add(player);
	}

	public static Player createPlayerWithOutFit(final String name) {
		final Player player = createPlayer(name);

		player.setOutfit(new Outfit(1, 1, 1, 1));

		return player;
	}

	/**
	 * Remove a player from rule processor, world and zone.
	 * 
	 * @param player
	 * @param zone
	 */
	public static void unregisterPlayer(final Player player, final StendhalRPZone zone) {
		zone.remove(player);
		removePlayer(player);
	}

	/**
	 * Remove a player from rule processor, world and zone.
	 * 
	 * @param playerName
	 * @param zone
	 */
	public static void removePlayer(final String playerName, final StendhalRPZone zone) {
		final Player player = MockStendhalRPRuleProcessor.get().getPlayer(playerName);

		if (player != null) {
			unregisterPlayer(player, zone);
		}
	}

	/**
	 * Remove a player from rule processor, world and zone.
	 * 
	 * @param playerName
	 * @param zoneName
	 */
	public static void removePlayer(final String playerName, final String zoneName) {
		removePlayer(playerName, MockStendlRPWorld.get().getZone(zoneName));
	}

	/**
	 * Remove a player from world and rule processor.
	 * 
	 * @param playerName
	 */
	public static void removePlayer(final String playerName) {
		final Player player = MockStendhalRPRuleProcessor.get().getPlayer(playerName);

		if (player != null) {
			removePlayer(player);
		}
	}

	/**
	 * Remove a player from world and rule processor.
	 * 
	 * @param player
	 */
	public static void removePlayer(final Player player) {
		if (player != null) {
			MockStendlRPWorld.get().remove(player.getID());
			MockStendhalRPRuleProcessor.get().getOnlinePlayers().remove(player);
		}
	}

	/**
	 * Remove all players from world and rule processor.
	 */
	public static void removeAllPlayers() {
		
		MockStendhalRPRuleProcessor.get().clearPlayers();
	}

	/**
	 * Equip the player with the given amount of money.
	 * 
	 * @param player
	 * @param amount
	 * @return success flag
	 */
	public static boolean equipWithMoney(final Player player, final int amount) {
		return equipWithStackableItem(player, "money", amount);
	}

	/**
	 * Equip the player with the given items.
	 * 
	 * @param player
	 * @param clazz
	 * @return success flag
	 */
	public static boolean equipWithItem(final Player player, final String clazz) {
		ItemTestHelper.generateRPClasses();
		final Item item = SingletonRepository.getEntityManager().getItem(clazz);

		return player.equipToInventoryOnly(item);
	}

	/**
	 * Equip the player with the given amount of items.
	 * 
	 * @param player
	 * @param clazz
	 * @param amount
	 * @return success flag
	 */
	public static boolean equipWithStackableItem(final Player player, final String clazz, final int amount) {
		final StackableItem item = (StackableItem) SingletonRepository.getEntityManager().getItem(clazz);
		item.setQuantity(amount);

		return player.equipToInventoryOnly(item);
	}

	/**
	 * Reset the conversation state of the named NPC.
	 * 
	 * @param npcName
	 */
	public static void resetNPC(final String npcName) {
		final SpeakerNPC npc = SingletonRepository.getNPCList().get(npcName);

		if (npc != null) {
			npc.setCurrentState(ConversationStates.IDLE);
		}
	}

	/**
	 * Remove the named NPC.
	 * 
	 * @param npcName
	 */
	public static void removeNPC(final String npcName) {
		SingletonRepository.getNPCList().remove(npcName);
	}



	public static void addEmptySlots(final Player player) {
//		"bag", "rhand", "lhand", "head", "armor",
//		"legs", "feet", "finger", "cloak", "keyring"
		player.addSlot(new PlayerSlot("bag"));
		player.addSlot(new PlayerSlot("lhand"));
		player.addSlot(new PlayerSlot("rhand"));
		player.addSlot(new PlayerSlot("armor"));
		player.addSlot(new PlayerSlot("head"));
		player.addSlot(new PlayerSlot("legs"));
		player.addSlot(new PlayerSlot("feet"));
		player.addSlot(new PlayerSlot("finger"));
		player.addSlot(new PlayerSlot("cloak"));
		player.addSlot(new PlayerSlot("keyring"));
		player.addSlot(new RPSlot("!buddy"));
		player.getSlot("!buddy").add(new RPObject());
		player.addSlot(new RPSlot("!quests"));
		player.getSlot("!quests").add(new RPObject());
		player.addSlot(new RPSlot("!kills"));
		player.getSlot("!kills").add(new RPObject());
		player.addSlot(new RPSlot("!tutorial"));
		player.getSlot("!tutorial").add(new RPObject());
		player.addSlot(new RPSlot("!visited"));
		player.getSlot("!visited").add(new RPObject());
	}

	public static void generateEntityRPClasses() {
		if (!RPClass.hasRPClass("entity")) {
			Entity.generateRPClass();
		}

		if (!RPClass.hasRPClass("active_entity")) {
			ActiveEntity.generateRPClass();
		}

		if (!RPClass.hasRPClass("rpentity")) {
			RPEntity.generateRPClass();
		}
	}

	public static void generateNPCRPClasses() {
		generateEntityRPClasses();

		if (!RPClass.hasRPClass("npc")) {
			NPC.generateRPClass();
		}
	}

	public static void generatePlayerRPClasses() {
		generateEntityRPClasses();

		if (!RPClass.hasRPClass("player")) {
			Player.generateRPClass();
		}
	}

	public static void generateCreatureRPClasses() {
		generateNPCRPClasses();

		if (!RPClass.hasRPClass("creature")) {
			Creature.generateRPClass();
		}
	}

	public static void dumpQuests(final Player player) {
		List<String> quests = player.getQuests();
		for (String quest : quests) {
			logger.info(quest + "=" + player.getQuest(quest));
		}
	}
}