public static void mine(Terrain terrain, int x, int y, Quinoa quinoa)
{
switch(terrain.getCode())
{
case TerrainCode.ROCK:
terrain.setCode(TerrainCode.STONE_FLOOR);
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_MINERALS))
{
int mineralCode = Int32.Parse(TerrainManager.getParameter(terrain, TerrainParameter.HAS_MINERALS));
switch(mineralCode)
{
case 1:
if(RandomNumber.RandomDouble() > 0.5)
{
Item gem = new Item();
gem.itemClass = ItemClass.AMETHYST;
gem.setPosition(x, y);
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(gem);
}
else
{
//do nothing
}
break;
case 2:
if(RandomNumber.RandomDouble() > 0.5)
{
Item gem = new Item();
gem.itemClass = ItemClass.SAPPHIRE;
gem.setPosition(x, y);
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(gem);
}
else
{
Item gem = new Item();
gem.itemClass = ItemClass.EMERALD;
gem.setPosition(x, y);
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(gem);
}
break;
case 3:
if(RandomNumber.RandomDouble() > 0.33)
{
Item gem = new Item();
gem.itemClass = ItemClass.RUBY;
gem.setPosition(x, y);
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(gem);
}
else
{
Item gem = new Item();
gem.itemClass = ItemClass.DIAMOND;
gem.setPosition(x, y);
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(gem);
}
break;
}
}
break;
case TerrainCode.STONE_FLOOR:
terrain.setCode(TerrainCode.STREAM_BED);
break;
case TerrainCode.STREAM_BED:
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_DRAIN))
{
terrain.getParameters().Remove(TerrainParameter.HAS_DRAIN);
}
else
{
terrain.getParameters().Add(TerrainParameter.HAS_DRAIN, TerrainManager.DRAIN_RATE+"");
}
break;
default:
//do nothing
break;
}
}
public static void dig(Terrain terrain, int x, int y, Quinoa quinoa)
{
//check for graves
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_GRAVE))
{
GraveCode gc = (GraveCode)Enum.Parse(typeof(GraveCode), TerrainManager.getParameter(terrain, TerrainParameter.HAS_GRAVE));
if(gc == GraveCode.NORMAL && RandomNumber.RandomDouble() < TerrainManager.GRAVE_ROB_CHANCE)
{
Item reward = ItemManager.getTreasure(RandomNumber.RandomDouble());
reward.setPosition(x, y);
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(reward);
}
//open the grave
terrain.getParameters().Add(TerrainParameter.HAS_GRAVE, EnumUtil.EnumName<GraveCode>(GraveCode.BROKEN));
//drop bones
Item bones = new Item();
bones.itemClass = ItemClass.BONES;
bones.setPosition(x, y);
bones.itemState = ItemState.GROUND;
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(bones);
return;
}
switch(terrain.getCode())
{
case TerrainCode.GRASS:
terrain.setCode(TerrainCode.DIRT);
break;
case TerrainCode.DIRT:
terrain.setCode(TerrainCode.STONE_FLOOR);
break;
case TerrainCode.STREAM_BED:
if(!TerrainManager.hasParameter(terrain, TerrainParameter.HAS_DRAIN))
{
if(!TerrainManager.hasParameter(terrain, TerrainParameter.HAS_SPRING))
{
terrain.getParameters().Add(TerrainParameter.HAS_SPRING, TerrainManager.SPRING_RATE+"");
}
else
{
terrain.getParameters().Remove(TerrainParameter.HAS_SPRING);
}
}
break;
default:
//Do nothing, can not dig
break;
}
}
//Grow crops on this tile
public static void growCrops(Terrain terrain, int x, int y, Quinoa quinoa)
{
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_SEED))
{
if(quinoa.getLightMap().getCalc(x, y) >= TerrainManager.PLANT_LIGHT_LEVEL_MIN)
{
SeedType seedType = (SeedType)Enum.Parse(typeof(SeedType), TerrainManager.getParameter(terrain, TerrainParameter.HAS_SEED));
switch(seedType)
{
case SeedType.CORN:
terrain.getParameters().Remove(TerrainParameter.HAS_SEED);
terrain.getParameters().Add(TerrainParameter.GROW_COUNTER, TerrainManager.GRASS_GROW_COUNT+"");
if(quinoa.getCurrentRegionHeader().getRegion().getItem(x, y) == null)
{
if(RandomNumber.RandomDouble() < 0.50)
{
Item cornSeed = new Item();
cornSeed.itemClass = ItemClass.CORN_SEED;
cornSeed.stackSize = RandomNumber.RandomInteger(9) + 1;
cornSeed.setPosition(x, y);
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(cornSeed);
}
Item corn = new Item();
corn.itemClass = ItemClass.CORN;
corn.stackSize = RandomNumber.RandomInteger(3) + 1;
corn.setPosition(x, y);
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(corn);
}
break;
case SeedType.PUMPKIN:
//reset the counter
terrain.getParameters().Add(TerrainParameter.GROW_COUNTER, (TerrainManager.PUMPKIN_GROW_COUNT / 2)+"");
//chance to produce a pumpkin
if(quinoa.getCurrentRegionHeader().getRegion().getItem(x, y) == null)
{
if(RandomNumber.RandomDouble() < TerrainManager.PUMPKIN_PRODUCTION_RATE)
{
Item pumpkinSeed = new Item();
pumpkinSeed.itemClass = ItemClass.PUMPKIN_SEED;
pumpkinSeed.stackSize = RandomNumber.RandomInteger(3) + 1;
pumpkinSeed.setPosition(x, y);
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(pumpkinSeed);
Item pumpkin = new Item();
pumpkin.itemClass = ItemClass.PUMPKIN;
pumpkin.stackSize = 1;
pumpkin.setPosition(x, y);
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(pumpkin);
}
}
break;
}
}
}
else
{
//no seeds, just grow grass
terrain.getParameters().Remove(TerrainParameter.GROW_COUNTER);
terrain.setCode(TerrainCode.GRASS);
if (RandomNumber.RandomDouble() < TerrainManager.TREE_REGROWTH_RATE)
{
terrain.getParameters().Add(TerrainParameter.HAS_TREE, EnumUtil.EnumName<TreeCode>(TerrainManager.getRandomTree()));
}
}
}
public static void burn(Terrain terrain, int x, int y, Quinoa quinoa)
{
bool dropAsh = false;
//Look for items on this squares and remove them
foreach(Item tempItem in quinoa.getCurrentRegionHeader().getRegion().getItems())
{
if(tempItem.x == x && tempItem.y == y)
{
switch(tempItem.itemClass)
{
case ItemClass.LOG: dropAsh=true; break;
default: dropAsh= false; break;
}
tempItem.RemoveObject();
}
}
//Examine terrain features
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_TREE))
{
terrain.getParameters().Remove(TerrainParameter.HAS_TREE);
if(RandomNumber.RandomDouble() < 0.125)
{
dropAsh = true;
}
}
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_DOOR))
{
terrain.getParameters().Remove(TerrainParameter.HAS_DOOR);
}
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_SIGN))
{
terrain.getParameters().Remove(TerrainParameter.HAS_SIGN);
}
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_MUSHROOM_SPORES))
{
terrain.getParameters().Remove(TerrainParameter.HAS_MUSHROOM_SPORES);
}
if(TerrainManager.hasParameter(terrain, TerrainParameter.HAS_CLOVER))
{
terrain.getParameters().Remove(TerrainParameter.HAS_CLOVER);
}
switch(terrain.getCode())
{
case TerrainCode.GRASS:
if(RandomNumber.RandomDouble() < 0.98)
{
terrain.setCode(TerrainCode.FERTILE_LAND);
terrain.getParameters().Add(TerrainParameter.GROW_COUNTER, TerrainManager.GRASS_GROW_COUNT+"");
if(RandomNumber.RandomDouble() < 0.001)
{
int cloverCount = (int)(RandomNumber.RandomDouble() * (TerrainManager.CLOVER_GROW_COUNT / 4)) + TerrainManager.CLOVER_GROW_COUNT;
terrain.getParameters().Add(TerrainParameter.HAS_CLOVER, cloverCount+"");
}
else
{
if(RandomNumber.RandomDouble() < 0.001)
{
MushroomSporeCode msc = EnumUtil.RandomEnumValue<MushroomSporeCode>();
terrain.getParameters().Add(TerrainParameter.HAS_MUSHROOM_SPORES, EnumUtil.EnumName<MushroomSporeCode>(msc));
}
}
}
else
{
terrain.setCode(TerrainCode.DIRT);
}
break;
default:
//Do nothing, does not burn
break;
}
if(dropAsh)
{
Item ash = new Item();
ash.itemClass = ItemClass.ASH;
ash.setPosition(x, y);
quinoa.getCurrentRegionHeader().getRegion().getItems().Add(ash);
}
}
public static Item containsItem(ItemClass itemClass, int x, int y, Quinoa quinoa)
{
foreach(Item tempItem in quinoa.getCurrentRegionHeader().getRegion().getItems())
{
if(tempItem.itemClass == itemClass
&& tempItem.x == x && tempItem.y == y)
{
return tempItem;
}
}
return null;
}
public static void leaveWaterTrail(Monster monster, Quinoa quinoa, double strength)
{
Terrain terrain = quinoa.getCurrentRegionHeader().getRegion().getTerrain(monster.x, monster.y);
//leave water trails
if (RandomNumber.RandomDouble() > (1.0 - strength))
{
if(TerrainManager.wetable(terrain, monster.x, monster.y, quinoa))
{
if(terrain.getWater() < 3)
{
terrain.setWater(terrain.getWater()+1);
}
}
}
}
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 executeMoveCommand(Monster monster, MonsterCommand command, Quinoa quinoa)
{
Region region = quinoa.getCurrentRegionHeader().getRegion();
Direction direction = (Direction) Enum.Parse(typeof(Direction), command.getParameter("direction"));
monster.facing = direction;
int newX = monster.x;
int newY = monster.y;
switch(direction)
{
case Direction.N: newY--; break;
case Direction.NE: newY--; newX++; break;
case Direction.NW: newY--; newX--; break;
case Direction.S: newY++; break;
case Direction.SE: newY++; newX++; break;
case Direction.SW: newY++; newX--; break;
case Direction.E: newX++; break;
case Direction.W: newX--; break;
}
if(newX >= 0 && newX < region.getWidth()
&& newY >= 0 && newY < region.getHeight())
{
Terrain tmpTerrain = region.getTerrain(newX, newY);
if (TerrainManager.allowsMonsterToPass(tmpTerrain, monster) && quinoa.getMonster(newX, newY) == null)
{
monster.setPosition(newX, newY);
TerrainManager.step(region.getTerrain(newX, newY), newX, newY, region, quinoa);
}
else
{
//Do nothing
}
}
else
{
//out of bounds, but do not inform the player
}
}
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 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 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 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;
}
}
public static void spongeAI(Monster monster, Quinoa quinoa)
{
MonsterActionManager.leaveWaterTrail(monster, quinoa, 0.02);
//pick up any items which the sponge passes over
Item newItem = quinoa.getCurrentRegionHeader().getRegion().getItem(monster.x, monster.y);
if (newItem != null && !monster.inventory.Full && monster.readyForCommand())
{
MonsterActionManager.setPickupCommand(monster);
}
else
{
followerAI(monster, quinoa);
}
}
public static void pathingAI(Monster monster, Quinoa quinoa)
{
if (monster.readyForCommand())
{
String searchIntervalStr = monster.getAIParameter("searchInterval");
if (searchIntervalStr != null)
{
int searchInterval = Int32.Parse(searchIntervalStr);
if (searchInterval > 0)
{
searchInterval = searchInterval - 1;
monster.setAIParameter("searchInterval", searchInterval + "");
//followerAI(monster, quinoa);
return;
}
else
{
monster.setAIParameter("searchInterval", "3");
}
}
else
{
monster.setAIParameter("searchInterval", "3");
}
List<Position> path = quinoa.getPathFinder().findPath(quinoa.getCurrentRegionHeader().getRegion(), 50, monster, monster.x, monster.y, quinoa.getPlayer().x, quinoa.getPlayer().y);
if (path != null && path.Count > 1)
{
Position pos = path[1];
if (pos.y > monster.y)
{
MonsterActionManager.setMoveCommand(monster, Direction.S);
}
else if (pos.y < monster.y)
{
MonsterActionManager.setMoveCommand(monster, Direction.N);
}
else if (pos.x > monster.x)
{
MonsterActionManager.setMoveCommand(monster, Direction.E);
}
else if (pos.x < monster.x)
{
MonsterActionManager.setMoveCommand(monster, Direction.W);
}
}
}
}
