248549595, 310686993, 388358742, 485448428, 606810535, 758513168, 948141460, 1185176826, 1481471032, 1851838791}; //times 1.25
#endregion Fields
#region Methods
public static void activate(Monster monster, int x, int y, Region region, Quinoa quinoa)
{
if(TerrainManager.hasParameter(region.getTerrain(x, y), TerrainParameter.HAS_DOOR))
{
DoorCode doorCode = (DoorCode)Enum.Parse(typeof(DoorCode), (TerrainManager.getParameter(region.getTerrain(x, y), TerrainParameter.HAS_DOOR)));
if(doorCode == DoorCode.CLOSED)
{
region.getTerrain(x, y).getParameters().Add(TerrainParameter.HAS_DOOR, EnumUtil.EnumName<DoorCode>(DoorCode.OPEN));
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("The door opens.");
}
}
else if(doorCode == DoorCode.OPEN)
{
region.getTerrain(x, y).getParameters().Add(TerrainParameter.HAS_DOOR, EnumUtil.EnumName<DoorCode>(DoorCode.CLOSED));
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("The door closes.");
}
}
}
else if(TerrainManager.hasParameter(region.getTerrain(x, y), TerrainParameter.HAS_FLOODGATE))
{
DoorCode doorCode = (DoorCode)Enum.Parse(typeof(DoorCode), (TerrainManager.getParameter(region.getTerrain(x, y), TerrainParameter.HAS_FLOODGATE)));
if(doorCode == DoorCode.CLOSED)
{
region.getTerrain(x, y).getParameters().Add(TerrainParameter.HAS_FLOODGATE, EnumUtil.EnumName<DoorCode>(DoorCode.OPEN));
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("The floodgate opens.");
}
}
else if(doorCode == DoorCode.OPEN)
{
region.getTerrain(x, y).getParameters().Add(TerrainParameter.HAS_FLOODGATE, EnumUtil.EnumName<DoorCode>(DoorCode.CLOSED));
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("The floodgate closes.");
}
}
}
else
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Nothing to do there.");
}
}
}
public static void monsterKilled(Monster killer, Monster victim, Quinoa quinoa)
{
String playerFeedback="The " + EnumUtil.EnumName<MonsterCode>(victim.monsterCode) + " is gone.";
//Give experience
MonsterActionManager.giveExperience(killer, victim.stats.getExperienceGiven(), quinoa);
//Drop items
foreach(Item tempItem in victim.inventory.getItems())
{
Item newItem = (Item)tempItem.CopyObject();
newItem.setPosition(victim.x, victim.y);
newItem.itemState = ItemState.GROUND;
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(newItem);
}
//Any monster specific items
switch(victim.monsterCode)
{
case MonsterCode.HUMAN:
break;
case MonsterCode.GHOST:
playerFeedback = "The " + EnumUtil.EnumName<MonsterCode>(victim.monsterCode) + " fades away...";
break;
case MonsterCode.SPONGE:
playerFeedback = "The " + EnumUtil.EnumName<MonsterCode>(victim.monsterCode) + " crumbles.";
break;
case MonsterCode.SLIME:
for(int i=0; i < 2; i++)
{
Monster newMon = new Monster();
newMon.monsterCode = MonsterCode.SMALL_SLIME;
MonsterActionManager.initialize(newMon);
newMon.setPosition(victim.x + RandomNumber.RandomInteger(5) - 2, victim.y + RandomNumber.RandomInteger(5) - 2);
quinoa.getActions().addMonster(newMon);
}
playerFeedback = "The " + EnumUtil.EnumName<MonsterCode>(victim.monsterCode) + " splits!";
break;
case MonsterCode.SMALL_SLIME:
for(int i=0; i < 2; i++)
{
Monster newMon = new Monster();
newMon.monsterCode = MonsterCode.TINY_SLIME;
MonsterActionManager.initialize(newMon);
newMon.setPosition(victim.x + RandomNumber.RandomInteger(7) - 4, victim.y + RandomNumber.RandomInteger(7) - 4);
quinoa.getActions().addMonster(newMon);
}
playerFeedback = "The " + EnumUtil.EnumName<MonsterCode>(victim.monsterCode) + " splits!";
break;
case MonsterCode.TINY_SLIME:
playerFeedback = "The " + EnumUtil.EnumName<MonsterCode>(victim.monsterCode) + " evaporates!";
break;
case MonsterCode.DEER:
case MonsterCode.PIG:
playerFeedback = "The " + EnumUtil.EnumName<MonsterCode>(victim.monsterCode) + " collapses.";
break;
default:
break;
}
//Inform plyer
if(killer.ID.Equals(MonsterActionManager.PLAYER_ID))
{
quinoa.getMessageManager().addMessage(playerFeedback);
}
}
public static void giveExperience(Monster monster, int amount, Quinoa quinoa)
{
monster.stats.setExperience(monster.stats.getExperience() + amount);
//check for level up
int startLevel = monster.stats.getLevel();
int endLevel = monster.stats.getLevel();
for(int i=0; i < xpLevels.Length; i++)
{
if(monster.stats.getExperience() >= xpLevels[i])
{
endLevel = (i + 1);
}
}
if(endLevel > startLevel && startLevel != MonsterStats.MAX_LEVEL)
{
monster.stats.setLevel(endLevel);
monster.stats.setAvailableStatPoints(monster.stats.getAvailableStatPoints() + ((endLevel - startLevel) * MonsterStats.STAT_POINTS_PER_LEVEL ));
monster.stats.setCurrentHealth(monster.stats.getMaxHP());
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Level up!");
quinoa.getUI().getScreen().displayDialog();
}
}
}
public static void executePickupCommand(Monster monster, MonsterCommand command, Quinoa quinoa)
{
bool pickedUpAtLeastOneItem = false;
Region region = quinoa.getCurrentRegionHeader().getRegion();
foreach(Item tempItem in region.getItems())
{
if(tempItem.x == monster.x
&& tempItem.y == monster.y
&& !tempItem.ShouldBeRemoved)
{
if(monster.inventory.stackItem(tempItem))
{
//Item stacked on current item
tempItem.RemoveObject();
pickedUpAtLeastOneItem = true;
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Got " + EnumUtil.EnumName<ItemClass>(tempItem.itemClass) + ".");
}
}
else
{
if(!monster.inventory.Full)
{
monster.inventory.addItem((Item)tempItem.CopyObject());
tempItem.RemoveObject();
pickedUpAtLeastOneItem = true;
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Got " + EnumUtil.EnumName<ItemClass>(tempItem.itemClass) + ".");
}
}
else
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Can't carry any more.");
pickedUpAtLeastOneItem = true;
}
}
}
}
}
if(!pickedUpAtLeastOneItem)
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Nothing to pick up there.");
}
}
}
public static void executeUnequipCommand(Monster monster, MonsterCommand command, Quinoa quinoa)
{
String itemID = command.getParameter("itemID");
Item itemToEquip = monster.inventory.getItem(itemID);
//Find the slot that the item is equiped in
ItemSlot equipSlot = ItemSlot.NULL;
foreach (ItemSlot tempSlot in Enum.GetValues(typeof(ItemSlot)).Cast<ItemSlot>())
{
Item testItem = monster.inventory.getItem(tempSlot);
if(testItem != null && testItem.ID.Equals(itemID))
{
equipSlot = tempSlot;
}
}
if(equipSlot != ItemSlot.NULL)
{
if(!monster.inventory.Full)
{
Item newItem = (Item)itemToEquip.CopyObject();
monster.inventory.equipItem(null, equipSlot);
if(!monster.inventory.stackItem(newItem))
{
monster.inventory.addItem(newItem);
}
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Unequiped " + EnumUtil.EnumName<ItemClass>(newItem.itemClass) + ".");
}
}
else
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("No space to unequip that.");
}
}
}
}
public static void executeEquipCommand(Monster monster, MonsterCommand command, Quinoa quinoa)
{
String itemID = command.getParameter("itemID");
Item itemToEquip = monster.inventory.getItem(itemID);
if(itemToEquip != null)
{
//check for a free slot
ItemSlot freeSlot = ItemManager.getFreeItemSlot(monster, itemToEquip);
if(freeSlot != ItemSlot.NULL)
{
Item newItem = (Item)itemToEquip.CopyObject();
monster.inventory.removeItem(itemID);
monster.inventory.equipItem(newItem, freeSlot);
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Equiped " + EnumUtil.EnumName<ItemClass>(newItem.itemClass) + ".");
}
}
else
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("No space to equip that.");
}
}
}
}
public static void executeItemVerbCommand(Monster monster, MonsterCommand command, Quinoa quinoa)
{
Item item = monster.inventory.getItem(command.getParameter("itemID"));
ItemVerb verb = (ItemVerb)Enum.Parse(typeof(ItemVerb), command.getParameter("verb"));
Region region = quinoa.getCurrentRegionHeader().getRegion();
int x = Int32.Parse(command.getParameter("x"));
int y = Int32.Parse(command.getParameter("y"));
bool removeItem=false;
if(item != null)
{
switch(verb)
{
case ItemVerb.EAT:
foreach(ItemAttribute attribute in item.attributes)
{
if(attribute.type == ItemAttributeType.NUTRITION)
{
double nutrition = Double.Parse(attribute.parameter);
monster.stats.setCurrentHunger(monster.stats.getCurrentHunger() - nutrition);
if(monster.stats.getCurrentHunger() < 0)
{
monster.stats.setCurrentHunger(0.0);
}
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Ate " + EnumUtil.EnumName<ItemClass>(item.itemClass) + ".");
}
}
if(attribute.type == ItemAttributeType.HEALS)
{
double points = Double.Parse(attribute.parameter);
monster.stats.setCurrentHealth(monster.stats.getCurrentHealth() + points);
if(monster.stats.getCurrentHealth() > monster.stats.getMaxHP())
{
monster.stats.setCurrentHealth(monster.stats.getMaxHP());
}
if(isPlayer(monster))
{
if(points >= 0)
{
quinoa.getMessageManager().addMessage("You feel better.");
}
else
{
quinoa.getMessageManager().addMessage("You feel worse.");
}
}
}
}
removeItem = true;
break;
case ItemVerb.PLACE:
removeItem = MonsterActionManager.place(monster, item, x, y, region, quinoa);
break;
case ItemVerb.USE:
removeItem = use(monster, item, x, y, region, quinoa);
break;
}
if(removeItem)
{
if(item.stackSize > 1)
{
item.stackSize = item.stackSize - 1;
}
else
{
item.RemoveObject();
}
}
}
else
{
//Non-item verbs
switch(verb)
{
case ItemVerb.ACTIVATE:
MonsterActionManager.activate(monster, x, y, region, quinoa);
break;
case ItemVerb.TALK:
if(isPlayer(monster))
{
quinoa.getActions().talk(x, y);
quinoa.getActions().showDialog();
}
break;
case ItemVerb.LOOK:
if(isPlayer(monster))
{
quinoa.getActions().look(x, y);
quinoa.getActions().showDialog();
}
break;
case ItemVerb.TRADE:
if(isPlayer(monster))
{
quinoa.getActions().trade(x, y);
}
break;
case ItemVerb.SLEEP:
Item terrainItem = region.getItem(x, y);
if(terrainItem != null)
{
foreach(ItemAttribute ia in terrainItem.attributes)
{
if(ia.type == ItemAttributeType.SLEEPS_FOR)
{
int hours = Int32.Parse(ia.parameter.Split(new char[]{' '})[0]);
monster.setPosition(x, y);
monster.sleeping = Quinoa.TICKS_PER_SECOND * 60 * 60 * hours;
break;
}
}
}
if(TerrainManager.hasParameter(region.getTerrain(x, y), TerrainParameter.HAS_BED))
{
int hours = 4;
monster.setPosition(x, y);
monster.sleeping = Quinoa.TICKS_PER_SECOND * 60 * 60 * hours;
}
else
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("You can't sleep there.");
}
}
break;
}
}
}
public static void executeAttackCommand(Monster monster, MonsterCommand command, Quinoa quinoa)
{
Monster monsterToAttack = quinoa.getMonsterByID(command.getParameter("monsterID"));
if(monsterToAttack != null)
{
if(quinoa.monsterIsAdjacent(monster.x, monster.y, monsterToAttack.ID))
{
//Do a combat attack
MonsterActionManager.combat(monster, monsterToAttack, quinoa);
//Check for removal if not player
//Also check for kill
if(!monsterToAttack.ID.Equals(MonsterActionManager.PLAYER_ID) && !(monsterToAttack.stats.getCurrentHealth() > 1))
{
monsterToAttack.RemoveObject();
monsterKilled(monster, monsterToAttack, quinoa);
}
}
else
{
//Attack misses automatically
if(monster.ID.Equals(MonsterActionManager.PLAYER_ID))
{
quinoa.getMessageManager().addMessage("You miss the " + EnumUtil.EnumName<MonsterCode>(monsterToAttack.monsterCode) + ".");
}
}
}
else
{
//Monster cannot be found
if(monster.ID.Equals(MonsterActionManager.PLAYER_ID))
{
quinoa.getMessageManager().addMessage("You swing at nothing.");
}
}
}
public static void executeDropCommand(Monster monster, MonsterCommand command, Quinoa quinoa)
{
String itemID = command.getParameter("itemID");
Item itemToDrop = monster.inventory.getItem(itemID);
if(itemToDrop != null)
{
Item newItem = (Item)itemToDrop.CopyObject();
newItem.itemState = ItemState.GROUND;
newItem.setPosition(monster.x, monster.y);
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(newItem);
monster.inventory.removeItem(itemID);
monster.inventory.removedExpiredItems();
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Dropped " + itemToDrop.itemClass + ".");
}
}
}
public static void combat(Monster attacker, Monster defender, Quinoa quinoa)
{
//Wake on being hit
defender.sleeping = 0;
//Hit if rnd() < ATK / (ATK + DEF).
double atk = MonsterActionManager.getAttackRating(attacker);
double def = MonsterActionManager.getDefenseRating(defender);
if (RandomNumber.RandomDouble() < atk / (atk + def))
{
double damage = 0.0;
if(atk > def)
{
//damage = rnd() * (ATK - DEF)
damage = ((RandomNumber.RandomDouble() / 2) + 0.5) * (atk - def);
}
else
{
//damage = rnd()
damage = RandomNumber.RandomDouble();
}
defender.stats.setCurrentHealth(defender.stats.getCurrentHealth() - damage);
if(MonsterActionManager.isPlayer(attacker))
{
quinoa.getMessageManager().addMessage("You hit the " + EnumUtil.EnumName<MonsterCode>(defender.monsterCode) + " for " + damage + ".");
}
else if(MonsterActionManager.isPlayer(defender))
{
quinoa.getMessageManager().addMessage("The " + EnumUtil.EnumName<MonsterCode>(defender.monsterCode) + " hits for " + damage + ".");
}
}
else
{
if(MonsterActionManager.isPlayer(attacker))
{
quinoa.getMessageManager().addMessage("You missed the " + EnumUtil.EnumName<MonsterCode>(defender.monsterCode) + ".");
}
else if(MonsterActionManager.isPlayer(defender))
{
quinoa.getMessageManager().addMessage("The " + EnumUtil.EnumName<MonsterCode>(defender.monsterCode) + " missed you.");
}
}
}
public static bool use(Monster monster, Item item, int x, int y, Region region, Quinoa quinoa)
{
Terrain terrain = region.getTerrain(x,y);
switch(item.itemClass)
{
case ItemClass.AXE:
if(TerrainManager.hasParameter(region.getTerrain(x, y), TerrainParameter.HAS_TREE))
{
TreeCode tc = (TreeCode)Enum.Parse(typeof(TreeCode), TerrainManager.getParameter(region.getTerrain(x, y), TerrainParameter.HAS_TREE));
int damage = 0;
if(TerrainManager.hasParameter(region.getTerrain(x, y), TerrainParameter.DAMAGE))
{
damage = Int32.Parse(TerrainManager.getParameter(region.getTerrain(x,y), TerrainParameter.DAMAGE));
}
damage = damage + 1;
if(damage < TerrainManager.maxTreeDamage(tc))
{
region.getTerrain(x,y).getParameters().Add(TerrainParameter.DAMAGE, damage + "");
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("You chop the " + EnumUtil.EnumName<TreeCode>(tc) + ".");
}
}
else
{
region.getTerrain(x, y).getParameters().Remove(TerrainParameter.HAS_TREE);
region.getTerrain(x, y).getParameters().Remove(TerrainParameter.DAMAGE);
Item log = new Item();
log.itemClass = ItemClass.LOG;
log.itemState = ItemState.GROUND;
log.setPosition(x, y);
region.getItems().Add(log);
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("The tree falls.");
}
}
}
return false;
case ItemClass.LANTERN:
case ItemClass.TORCH:
return MonsterActionManager.setFire(monster, item, region, x, y, quinoa);
case ItemClass.ASH:
//check for mushrooms spores
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_MUSHROOM_SPORES))
{
MushroomSporeCode msc = (MushroomSporeCode)Enum.Parse(typeof(MushroomSporeCode), TerrainManager.getParameter(terrain, TerrainParameter.HAS_MUSHROOM_SPORES));
if(RandomNumber.RandomDouble() > 0.25)
{
//Grow a mushroom
Item newMushroom = new Item();
newMushroom.itemClass = TerrainManager.mushroomSporeToItemClass(msc);
ItemManager.initialize(newMushroom);
newMushroom.setPosition(x, y);
region.getItems().Add(newMushroom);
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("A mushroom sprouts!");
}
}
else
{
//spread the spore
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("The spores shimmer..");
}
quinoa.getActions().spreadSpore(x, y, msc);
}
//Slight chance to remove the spores
if (RandomNumber.RandomDouble() < 0.02)
{
terrain.getParameters().Remove(TerrainParameter.HAS_MUSHROOM_SPORES);
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("The spores crumble...");
}
}
return true;
}
//check for clover
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_CLOVER))
{
int cloverCount = Int32.Parse(TerrainManager.getParameter(terrain, TerrainParameter.HAS_CLOVER));
if(cloverCount > 0)
{
terrain.getParameters().Add(TerrainParameter.HAS_CLOVER, "0");
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("The clover blooms!");
}
return true;
}
}
//fertilize existing ground
switch(terrain.getCode())
{
case TerrainCode.DIRT:
terrain.setCode(TerrainCode.FERTILE_LAND);
terrain.getParameters().Add(TerrainParameter.GROW_COUNTER, TerrainManager.GRASS_GROW_COUNT+"");
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("The ground becomes fertile.");
}
return true;
case TerrainCode.FERTILE_LAND:
if(TerrainManager.hasParameter(terrain, TerrainParameter.GROW_COUNTER))
{
int growCount = Int32.Parse(TerrainManager.getParameter(terrain, TerrainParameter.GROW_COUNTER));
growCount = growCount / 2;
terrain.getParameters().Add(TerrainParameter.GROW_COUNTER, growCount+"");
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("The ground becomes more fertile.");
}
}
return true;
default:
return false;
}
case ItemClass.BUCKET:
if(terrain.getWater() > 0)
{
int waterLevel = terrain.getWater();
if(waterLevel > TerrainManager.DEEP_WATER)
{
item.itemClass = ItemClass.WATER_BUCKET;
terrain.setWater(waterLevel - TerrainManager.DEEP_WATER);
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("You fill the bucket with water.");
}
}
else
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("There's not enough water there.");
}
}
}
return false;
case ItemClass.WATER_BUCKET:
int waterValue = ItemManager.WATER_LEVEL_BUCKET_FULL;
//Turn the item back to a bucket after all uses are gone
if(ItemManager.decreaseUse(item))
{
item.itemClass = ItemClass.BUCKET;
}
//Check for fire extinguishing
if(TerrainManager.hasParameter(terrain, TerrainParameter.FIRE))
{
terrain.getParameters().Remove(TerrainParameter.FIRE);
waterValue = waterValue / 2;
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("The fire is extinguished!");
}
}
//Add water to the ground
if(TerrainManager.wetable(terrain, x, y, quinoa))
{
terrain.setWater(terrain.getWater() + waterValue);
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("You splash water around.");
}
}
return false;
case ItemClass.SHOVEL:
if(TerrainManager.diggable(terrain))
{
TerrainManager.dig(terrain, x, y, quinoa);
if(isPlayer(monster))
{
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_GRAVE))
{
quinoa.getMessageManager().addMessage("You open the grave.");
}
else
{
quinoa.getMessageManager().addMessage("You dig.");
}
}
}
else
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("You can't dig there.");
}
}
return false;
case ItemClass.PICKAXE:
if(TerrainManager.mineable(terrain))
{
TerrainManager.mine(terrain, x, y, quinoa);
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("You mine.");
}
}
else
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("You can't mine there.");
}
}
return false;
case ItemClass.CORN_SEED:
if(terrain.getCode() == TerrainCode.FERTILE_LAND)
{
if(!TerrainManager.hasParameter(terrain, TerrainParameter.HAS_SEED))
{
terrain.getParameters().Add(TerrainParameter.HAS_SEED, EnumUtil.EnumName<SeedType>(SeedType.CORN));
terrain.getParameters().Add(TerrainParameter.GROW_COUNTER,TerrainManager.CORN_GROW_COUNT+"");
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("You sow the corn seed.");
}
}
}
else
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Plant seeds in fertile ground.");
}
}
return true;
case ItemClass.PUMPKIN_SEED:
if(terrain.getCode() == TerrainCode.FERTILE_LAND)
{
if(!TerrainManager.hasParameter(terrain, TerrainParameter.HAS_SEED))
{
terrain.getParameters().Add(TerrainParameter.HAS_SEED,EnumUtil.EnumName<SeedType>(SeedType.PUMPKIN));
terrain.getParameters().Add(TerrainParameter.GROW_COUNTER,TerrainManager.PUMPKIN_GROW_COUNT+"");
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Sow the pumpkin seed.");
quinoa.getMessageManager().addMessage("A creeping vine appears.");
}
}
}
else
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Plant seeds in fertile ground.");
}
}
return true;
case ItemClass.MOP:
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_MOSS))
{
terrain.getParameters().Remove(TerrainParameter.HAS_MOSS);
}
if(terrain.getWater() > 0)
{
terrain.setWater(0);
}
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_MUSHROOM_SPORES))
{
terrain.getParameters().Remove(TerrainParameter.HAS_MUSHROOM_SPORES);
}
return false;
default:
return false;
}
}
public static bool setFire(Monster monster, Item item, Region region, int x, int y, Quinoa quinoa)
{
if(TerrainManager.flammable(region.getTerrain(x,y), x, y, quinoa))
{
region.getTerrain(x,y).getParameters().Add(TerrainParameter.FIRE, TerrainManager.BASE_FLAME_RATE+"");
if(ItemManager.decreaseUse(item))
{
item.RemoveObject();
}
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("Flames burst forth!");
}
}
else
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("That won't catch on fire.");
}
}
return false;
}
public static void sellItemToMonster(Monster seller, Monster buyer, Item item, Quinoa quinoa)
{
//Check if the buyer has enough money
if(buyer.inventory.wealth >= item.worth)
{
//Do the sale
Item newItem = (Item)item.CopyObject();
newItem.stackSize = 1;
if(!buyer.inventory.stackItem(newItem))
{
if(!buyer.inventory.Full)
{
//Successfully sold as new item
buyer.inventory.addItem(newItem);
item.stackSize = item.stackSize-1;
if(item.stackSize == 0)
{
item.RemoveObject();
seller.inventory.removedExpiredItems();
}
seller.inventory.wealth = (seller.inventory.wealth + newItem.worth);
buyer.inventory.wealth = (buyer.inventory.wealth - newItem.worth);
}
else
{
//No room in buyer inventory
//Buyer can not afford
if(isPlayer(buyer))
{
quinoa.getMessageManager().addMessage("You don't have enough room for that.");
}
else if(isPlayer(seller))
{
quinoa.getMessageManager().addMessage("They don't have enough room.");
}
}
}
else
{
//Successfully sold as stacked
item.stackSize = item.stackSize-1;
if(item.stackSize == 0)
{
item.RemoveObject();
seller.inventory.removedExpiredItems();
}
seller.inventory.wealth = (seller.inventory.wealth + newItem.worth);
buyer.inventory.wealth = (buyer.inventory.wealth - newItem.worth);
}
}
else
{
//Buyer can not afford
if(isPlayer(buyer))
{
quinoa.getMessageManager().addMessage("You don't have enough money for that.");
}
else if(isPlayer(seller))
{
quinoa.getMessageManager().addMessage("They don't have enough money.");
}
}
}
public static bool place(Monster monster, Item item, int x, int y, Region region, Quinoa quinoa)
{
Terrain terrain = region.getTerrain(x,y);
switch(item.itemClass)
{
case ItemClass.FLOODGATE:
if(terrain.getCode() == TerrainCode.STREAM_BED)
{
terrain.getParameters().Add(TerrainParameter.HAS_FLOODGATE, EnumUtil.EnumName<DoorCode>(DoorCode.CLOSED));
return true;
}
else
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("That must be placed in a stream bed.");
}
return false;
}
case ItemClass.BONES:
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_GRAVE))
{
GraveCode gc = (GraveCode)Enum.Parse(typeof(GraveCode), TerrainManager.getParameter(terrain, TerrainParameter.HAS_GRAVE));
if(gc == GraveCode.BROKEN)
{
terrain.getParameters().Add(TerrainParameter.HAS_GRAVE, EnumUtil.EnumName<GraveCode>(GraveCode.SPECIAL));
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("You restore the bones to the grave.");
}
return true;
}
else
{
return false;
}
}
return false;
case ItemClass.APPLE:
if(RandomNumber.RandomDouble() < TerrainManager.APPLE_TREE_FROM_APPLE_CHANCE
&& !TerrainManager.hasParameter(terrain, TerrainParameter.HAS_TREE)
&& !TerrainManager.hasParameter(terrain, TerrainParameter.HAS_SIGN)
&& !TerrainManager.hasParameter(terrain, TerrainParameter.HAS_DOOR)
&& terrain.getCode() == TerrainCode.GRASS)
{
terrain.getParameters().Add(TerrainParameter.HAS_TREE, EnumUtil.EnumName<TreeCode>(TreeCode.APPLE_TREE));
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("An apple tree sprouts!");
}
}
else
{
if(isPlayer(monster))
{
quinoa.getMessageManager().addMessage("The apple rots...");
}
}
return true;
default:
Item newItem = (Item)item.CopyObject();
newItem.itemState = ItemState.GROUND;
newItem.stackSize = 1;
newItem.refreshID();
newItem.setPosition(x, y);
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(newItem);
return true;
}
}