/// <summary>
/// Add a block to a global map
/// </summary>
/// <param name="block"></param>
public void AddToGlobalMap(MapBlock block)
{
//Does it belong on the global map?
MapCoordinate coord = block.Tile.Coordinate;
if (coord.MapType != DRObjects.Enums.MapType.GLOBAL)
{
//Error
throw new Exception("The map block is not for a global map");
}
else
if (coord.X >= worldSize || coord.Y >= worldSize)
{
//error
throw new Exception("The map block is outside the bounds of the world");
}
else
{
try
{
globalGameMap[coord.X,coord.Y] = block ;
}
catch
{
//Error
throw new Exception("The map already has data at the coordinate " + block.Tile.Coordinate);
}
}
}
/// <summary>
/// Creates and puts a particular room in a particular rectangle
/// </summary>
/// <param name="roomType"></param>
/// <param name="rect"></param>
/// <param name="circle">When the room is a Summoning Room, there's the circle</param>
private static void PutRoom(MapBlock[,] map, int tileID, int level, DungeonRoomType roomType, Rectangle rect, out SummoningCircle circle)
{
circle = null;
string tagName = roomType.ToString().ToLower().Replace("_", " ") + " room";
LocalMapXMLParser parser = new LocalMapXMLParser();
var maplet = parser.ParseMapletFromTag(tagName);
//Change the width and height to match the rectangle we're fitting it in
//Leave a rim of 1
maplet.SizeX = rect.Width - 2;
maplet.SizeY = rect.Height - 2;
LocalMapGenerator lmg = new LocalMapGenerator();
Actor[] actors = null;
MapletActorWanderArea[] areas = null;
MapletPatrolPoint[] patrolRoutes = null;
MapletFootpathNode[] footpathNodes = null;
var gennedMap = lmg.GenerateMap(tileID, null, maplet, false, "", OwningFactions.UNDEAD, out actors, out areas, out patrolRoutes, out footpathNodes);
//Is this a summoning room?
if (roomType == DungeonRoomType.SUMMONING)
{
//Go through each map block and see if we find a summoning circle
for (int x = 0; x < gennedMap.GetLength(0); x++)
{
for (int y = 0; y < gennedMap.GetLength(1); y++)
{
var block = gennedMap[x, y];
if (block.GetTopMapItem() != null && block.GetTopMapItem().GetType().Equals(typeof(SummoningCircle)))
{
circle = block.GetTopMapItem() as SummoningCircle;
}
}
}
}
if (roomType == DungeonRoomType.COMBAT_PIT)
{
int docLevel = (int) level/4;
docLevel = docLevel < 1 ? 1 : docLevel;
docLevel = docLevel > 5 ? 5 : docLevel;
//Generate a combat manual - Level [1..5] will be determined by floor of Dungeon Level /4
CombatManual cm = new CombatManual(SpecialAttacksGenerator.GenerateSpecialAttack(docLevel));
//Now place it, somewhere (or at least try 50 times)
for(int i=0; i < 50; i++)
{
MapBlock randomBlock = gennedMap[GameState.Random.Next(gennedMap.GetLength(0)), GameState.Random.Next(gennedMap.GetLength(1))];
if (randomBlock.MayContainItems)
{
randomBlock.ForcePutItemOnBlock(cm);
break;
}
}
}
//Do we have any treasure chests?
for (int x = 0; x < gennedMap.GetLength(0); x++)
{
for (int y = 0; y < gennedMap.GetLength(1); y++)
{
var block = gennedMap[x, y];
if (block.GetTopMapItem() != null && block.GetTopMapItem().GetType().Equals(typeof(TreasureChest)))
{
TreasureChest chest = block.GetTopMapItem() as TreasureChest;
InventoryItemManager iim = new InventoryItemManager();
//Fill em up
chest.Contents = iim.FillTreasureChest((InventoryCategory[])Enum.GetValues(typeof(InventoryCategory)), 300 + (50 * level));
}
}
}
//Now fit one into the other
lmg.JoinMaps(map, gennedMap, rect.X + 1, rect.Y + 1);
}
/// <summary>
/// Gets a block which is at a particular coordinate. If there is no block marked on the map, it will return an Air block.
/// </summary>
/// <param name="coordinate"></param>
/// <returns></returns>
public MapBlock GetBlockAtCoordinate(MapCoordinate coordinate)
{
if (coordinate.X < this.localGameMap.GetLength(0) && coordinate.X >= 0)
{
if (coordinate.Y < this.localGameMap.GetLength(1) && coordinate.Y >= 0)
{
if (coordinate.Z < this.localGameMap.GetLength(2) && coordinate.Z >= 0)
{
if (this.localGameMap[coordinate.X, coordinate.Y, coordinate.Z] != null)
{
return this.localGameMap[coordinate.X, coordinate.Y, coordinate.Z];
}
}
}
}
//doesn't exist, send a blank one
MapBlock airBlock = new MapBlock();
airBlock.Tile = new DRObjects.Items.Tiles.Air(coordinate);
return airBlock;
}
/// <summary>
/// Regenerates a site's actors based on the sitedata. If it is not marked as needing regeneration , will do nothing
/// </summary>
/// <param name="sitedata"></param>
/// <param name="currentMap"></param>
/// <param name="actors"></param>
/// <returns></returns>
public static MapBlock[,] RegenerateSite(SiteData sitedata, MapBlock[,] currentMap, Actor[] currentActors, out Actor[] newActors)
{
if (!sitedata.MapRegenerationRequired)
{
//Do nothing
newActors = currentActors;
return currentMap;
}
//So, first go through the actors and remove any of them which shouldn't be there. That is to say all of them which are site members (I realise it's a big ugly but it's a clean check)
List<Actor> actors = currentActors.ToList();
var actorsToRemove = currentActors.Where(ca => ca.SiteMember);
//Remove the map items for these actors
foreach(var a in actorsToRemove)
{
a.IsAlive = false;
}
//We'll handle actors soon, first we need to go through all the items and set the ones with the wrong owner to inactive
foreach (var mapBlock in currentMap)
{
foreach (var item in mapBlock.GetItems())
{
if (!item.OwnedBy.HasFlag(sitedata.Owners))
{
item.IsActive = false;
}
else
{
item.IsActive = true;
}
}
}
//Now go through the site's actors and create the new ones as required
foreach (ActorProfession profession in Enum.GetValues(typeof(ActorProfession)))
{
//So do we have any wander areas for them ?
var possibleAreas = sitedata.WanderAreas.Where(wa => wa.Factions.HasFlag(sitedata.Owners) && wa.Profession.Equals(profession));
var possibleRoutes = sitedata.PatrolRoutes.Where(pr => pr.Owners.HasFlag(sitedata.Owners) && pr.Profession.Equals(profession));
//Any actors?
if (sitedata.ActorCounts.ContainsKey(profession))
{
//Yes, how many
int total = sitedata.ActorCounts[profession];
var a = ActorGeneration.CreateActors(sitedata.Owners, profession, total);
foreach (var ac in a)
{
ac.SiteMember = true;
}
actors.AddRange(a);
foreach (var actor in a)
{
//So, where we going to drop them off ? Randomly
int tries = 0;
for (; ; )
{
int randomX = GameState.Random.Next(currentMap.GetLength(0));
int randomY = GameState.Random.Next(currentMap.GetLength(1));
if (currentMap[randomX, randomY].MayContainItems)
{
//Plop it on there
actor.MapCharacter.Coordinate = new MapCoordinate(randomX, randomY, 0, MapType.LOCAL);
currentMap[randomX, randomY].ForcePutItemOnBlock(actor.MapCharacter);
tries = 0;
break;
}
else
{
tries++;
}
if (tries >= 150)
{
//give up
break;
}
}
//Go through each actor, and either tell them to wander in the whole map, or within any possible area which matches
//Any possible area avaialble?
List<object> possibleMissions = new List<object>(); //I know :( But Using an interface or trying to mangle together an inheritance was worse
possibleMissions.AddRange(possibleAreas.Where(pa => pa.MaxAmount > pa.CurrentAmount));
possibleMissions.AddRange(possibleRoutes);
var chosenArea = possibleMissions.OrderBy(pa => GameState.Random.Next(100)).FirstOrDefault();
if (chosenArea == null)
{
//Wander around the whole map
actor.CurrentMission = new WanderMission() { LoiterPercentage = 25, WanderPoint = new MapCoordinate(currentMap.GetLength(0) / 2, currentMap.GetLength(1) / 2, 0, MapType.LOCAL), WanderRectangle = new Rectangle(0, 0, currentMap.GetLength(0), currentMap.GetLength(1)) };
}
else
{
//Is this a patrol or a wander ?
if (chosenArea.GetType().Equals(typeof(PatrolRoute)))
{
var patrolDetails = chosenArea as PatrolRoute;
PatrolRouteMission pm = new PatrolRouteMission();
pm.PatrolRoute.AddRange(patrolDetails.Route);
actor.CurrentMission = pm;
}
else if (chosenArea.GetType().Equals(typeof(MapletActorWanderArea)))
{
var wanderDetails = chosenArea as MapletActorWanderArea;
//Wander around in that area
actor.CurrentMission = new WanderMission() { LoiterPercentage = 25, WanderPoint = new MapCoordinate(wanderDetails.WanderPoint), WanderRectangle = wanderDetails.WanderRect };
wanderDetails.CurrentAmount++;
}
}
}
}
}
newActors = actors.ToArray();
sitedata.MapRegenerationRequired = false; //We're done
return currentMap;
}
/// <summary>
/// Returns true if the current block is in the region
/// </summary>
/// <param name="block"></param>
/// <returns></returns>
public bool IsInRegion(MapBlock block)
{
return Blocks.Any(b => b.Tile.Coordinate.Equals(block.Tile.Coordinate));
}
/// <summary>
/// Generates enemies on the map.
/// </summary>
/// <param name="enemyCount"></param>
/// <param name="enemyType"></param>
/// <returns></returns>
public MapBlock[,] GenerateEnemies(MapBlock[,] blocks, int enemyCount, string enemyType, out DRObjects.Actor[] actors, int level, int equipmentCost = 0)
{
ItemFactory.ItemFactory fact = new ItemFactory.ItemFactory();
List<Actor> actorList = new List<Actor>();
//We'll just pick blocks at random until we fail 50 times in a row or run out of enemies to place
int failureCount = 0;
for (int i = 0; i < enemyCount; i++)
{
if (failureCount == 50)
{
break;
}
int x = random.Next(blocks.GetLength(0));
int y = random.Next(blocks.GetLength(1));
//Is the block free
if (blocks[x, y].MayContainItems)
{
int returnedID = -1;
//Put the enemy in there
//Get the basic Actor object
double multiplier = GameState.Random.Next(75, 125);
multiplier /= 100; //So we get a number between 0.75 and 1.25
Actor actor = ActorGeneration.CreateActor(enemyType, null, null, (int)(level * multiplier), (int)(equipmentCost * multiplier), null, out returnedID);
var mapObject = fact.CreateItem("enemies", returnedID);
(mapObject as LocalCharacter).Actor = actor;
//Create the Actor
actor.GlobalCoordinates = null; //useless for now
actor.IsPlayerCharacter = false;
actor.MapCharacter = mapObject;
actorList.Add(actor);
blocks[x, y].ForcePutItemOnBlock(mapObject);
int missionType = random.Next(3);
if (missionType == 0)
{
//33% of them will Wander -
WanderMission mission = new WanderMission();
mission.WanderPoint = new MapCoordinate(x, y, 0, MapType.LOCAL);
mission.WanderRectangle = new Rectangle(0, 0, blocks.GetLength(0), blocks.GetLength(1));
actor.MissionStack.Push(mission);
}
else if (missionType == 1)
{
//33% will idle
IdleMission mission = new IdleMission();
actor.MissionStack.Push(mission);
}
else
{
//The rest will patrol
PatrolMission mission = new PatrolMission();
//Don't give them the point. We;ll choose it later
actor.MissionStack.Push(mission);
}
failureCount = 0;//reset
}
else
{
failureCount++;
i--; //And again
}
}
//return the map
actors = actorList.ToArray();
return blocks;
}
/// <summary>
/// Determines the Desirability of a particular global tile
/// </summary>
/// <param name="tile"></param>
/// <returns></returns>
public static int DetermineDesirability(MapBlock block)
{
GlobalTile tile = block.Tile as GlobalTile; //Get the tile
int desirability = 0;
#region Temperature
//check the temperature
if (tile.ClimateTemperature > 30)
{
//very hot
desirability -= 2;
}
if (tile.ClimateTemperature < 30 && tile.ClimateTemperature > 15)
{
//nice temperature
desirability += 2;
}
if (tile.ClimateTemperature > 5)
{
//ok temperature
}
if (tile.ClimateTemperature < 5)
{
//too cold
desirability -= 3;
}
#endregion
#region Rainfall
if (tile.Rainfall > 8)
{
//too rainy
desirability -= 2;
}
if (tile.Rainfall < 3)
{
//too dry
desirability -= 5;
}
#endregion
#region River?
if (tile.HasRiver) //rivers are very popular
{
desirability += 4;
}
#endregion
#region Elevation
if (tile.Elevation < 0)
{
desirability += 3; //while we can't build on the sea, having the sea next to you is desirable
}
if (tile.Elevation > 200)
{
desirability += 4; //Having a mountain next to you is useful too
}
else if (tile.Elevation > 80)
{
desirability += 3; //High land is preferred
}
#endregion
#region Got wood?
if (tile.Biome.HasValue)
{
switch (tile.Biome.Value)
{
case GlobalBiome.DENSE_FOREST:
desirability += 5; //Lots of wood
break;
case GlobalBiome.POLAR_FOREST:
desirability += 2; //some wood
break;
case GlobalBiome.WOODLAND:
desirability += 3; //wood
break;
}
}
#endregion
//Any resources?
if (tile.HasResource)
{
//Find it
MapResource resource = block.GetItems().Where(gi => gi.GetType().Equals(typeof(MapResource))).FirstOrDefault() as MapResource;
desirability += resource.Desirability;
}
return desirability;
}
private static byte[,] GeneratePathfindingMap(MapBlock[,] map)
{
//Generate a byte map of x and y
int squareSize = PathfinderInterface.CeilToPower2(Math.Max(map.GetLength(0), map.GetLength(1)));
byte[,] pf = new byte[squareSize, squareSize];
for (int i = 0; i < map.GetLength(0); i++)
{
for (int j = 0; j < map.GetLength(1); j++)
{
if (i < map.GetLength(0) - 1 && j < map.GetLength(1) - 1)
{
//Copyable - If it may contain items, put a weight of 5, otherwise a weight of MaxValue. If there's already a road there, put a weight of 1. This'll encourage road reuse.
pf[i, j] = map[i, j] != null ? map[i, j].MayContainItems ? (map[i,j].Tile as GlobalTile).HasRoad ? (byte)1 : (byte)5 : Byte.MaxValue : Byte.MaxValue;
}
else
{
//Put in the largest possible weight
pf[i, j] = Byte.MaxValue;
}
}
}
return pf;
}
/// <summary>
/// Load the location
/// </summary>
/// <param name="location"></param>
/// <param name="forceRegenerate">If set to true, will regenerate the item anyway</param>
private void LoadLocation(Location location, bool forceRegenerate = false)
{
if (LocalMap.MapGenerated(location.UniqueGUID) && !forceRegenerate)
{
//Reload the map
var savedMap = LocalMap.DeserialiseLocalMap(location.UniqueGUID);
GameState.LocalMap = new LocalMap(savedMap.localGameMap.GetLength(0), savedMap.localGameMap.GetLength(1), 1, 0);
GameState.LocalMap.Location = savedMap.Location;
//GameState.LocalMap.Location = location;
if (GameState.LocalMap.Location is MapSite && (GameState.LocalMap.Location as MapSite).SiteData.MapRegenerationRequired)
{
Actor[] newActors = null;
//Before we do anything, check that we don't need to regenerate it
MapBlock[,] savedMap2D = new MapBlock[savedMap.localGameMap.GetLength(0), savedMap.localGameMap.GetLength(1)];
for (int x = 0; x < savedMap.localGameMap.GetLength(0); x++)
{
for (int y = 0; y < savedMap.localGameMap.GetLength(1); y++)
{
savedMap2D[x, y] = savedMap.localGameMap[x, y, 0]; //NB: CHANGE IF WE GO 3D
}
}
var blocks = SiteGenerator.RegenerateSite((GameState.LocalMap.Location as MapSite).SiteData, savedMap2D, savedMap.Actors.ToArray(), out newActors);
List<MapBlock> cM = new List<MapBlock>();
foreach (MapBlock block in blocks)
{
cM.Add(block);
}
GameState.LocalMap.AddToLocalMap(cM.ToArray());
GameState.LocalMap.Actors = newActors.ToList();
GameState.LocalMap.Tick(); //Tick to remove the dead actors
}
GameState.LocalMap.Actors = new List<Actor>();
List<MapBlock> collapsedMap = new List<MapBlock>();
foreach (MapBlock block in savedMap.localGameMap)
{
collapsedMap.Add(block);
}
GameState.LocalMap.AddToLocalMap(collapsedMap.ToArray());
GameState.LocalMap.PathfindingMap = savedMap.PathfindingMap;
GameState.LocalMap.PointsOfInterest = savedMap.PointsOfInterest;
GameState.LocalMap.IsUnderground = savedMap.IsUnderground;
GameState.LocalMap.Actors = savedMap.Actors;
LocalMapGenerator lmg = new LocalMapGenerator();
//Go through the actors
foreach (var actor in GameState.LocalMap.Actors)
{
//Do we have any vendors ?
if (actor.VendorDetails != null)
{
if (Math.Abs((actor.VendorDetails.GenerationTime - GameState.UniverseTime).GetTimeComponent(DRTimeComponent.MONTH)) > 1)
{
//More than a month old
//Regenerate it
lmg.UpdateVendorStock(actor);
}
}
}
//Find the player character item
var playerActor = GameState.LocalMap.Actors.Where(a => a.IsPlayerCharacter).FirstOrDefault();
GameState.PlayerCharacter.MapCharacter.Coordinate = playerActor.MapCharacter.Coordinate;
GameState.PlayerCharacter.MapCharacter = playerActor.MapCharacter;
//GameState.LocalMap.Location = location;
}
else
{
Actor[] actors = null;
MapCoordinate startPoint = null;
List<PointOfInterest> pointsOfInterest = null;
MapBlock[,] gennedMap = null;
if (location is BanditCamp)
{
gennedMap = CampGenerator.GenerateCamp((location as BanditCamp).BanditTotal, out startPoint, out actors);
}
else if (location is Citadel)
{
var citadel = location as Citadel;
CitadelGenerator gen = new CitadelGenerator();
gennedMap = gen.GenerateDungeon(citadel.TierCount, citadel.TrapRooms, citadel.GuardRooms, citadel.TreasureRoom, citadel.OwnerCreatureType, (decimal)citadel.PercentageOwned, citadel.MaxWildPopulation, citadel.MaxOwnedPopulation, out startPoint, out actors, out pointsOfInterest);
}
else if (location is MapSite)
{
var mapSite = location as MapSite;
gennedMap = SiteGenerator.GenerateSite(mapSite.SiteData, out actors);
startPoint = new MapCoordinate(gennedMap.GetLength(0) / 2, 0, 0, MapType.LOCAL);
}
else if (location is Settlement)
{
List<Actor> settlementActors = null;
PointOfInterest sp = null;
gennedMap = SettlementGenerator.GenerateMap((location as Settlement), out settlementActors, out sp);
actors = settlementActors.ToArray();
startPoint = sp.Coordinate;
}
else if (location is Dungeon)
{
Dungeon dungeon = null;
gennedMap = DungeonGenerator.GenerateDungeonLevel((location as Dungeon).DifficultyLevel, 80, out startPoint, out actors, out dungeon);
//Copy the changes, that way we retain the object reference and the guid for serialization
(location as Dungeon).Rooms = dungeon.Rooms;
(location as Dungeon).SummoningCircles = dungeon.SummoningCircles;
}
GameState.LocalMap = new LocalMap(gennedMap.GetLength(0), gennedMap.GetLength(1), 1, 0);
GameState.LocalMap.Actors = new List<Actor>();
List<MapBlock> collapsedMap = new List<MapBlock>();
foreach (MapBlock block in gennedMap)
{
collapsedMap.Add(block);
}
GameState.LocalMap.AddToLocalMap(collapsedMap.ToArray());
GameState.PlayerCharacter.MapCharacter.Coordinate = startPoint;
MapBlock playerBlock = GameState.LocalMap.GetBlockAtCoordinate(startPoint);
playerBlock.PutItemOnBlock(GameState.PlayerCharacter.MapCharacter);
GameState.LocalMap.Actors.AddRange(actors);
GameState.LocalMap.Actors.Add(GameState.PlayerCharacter);
GameState.LocalMap.PointsOfInterest = pointsOfInterest;
GameState.LocalMap.Location = location;
GameState.LocalMap.IsUnderground = (location is Dungeon);
if (location is Dungeon) //Spawn at least 10 enemies
{
for (int i = 0; i < 10; i++)
{
GameState.LocalMap.MinuteChanged(null, null); //Summon!
}
}
}
}
public static int NearestNeighbour(int worldSize, MapBlock block)
{
List<MapBlock> neighbourhood = new List<MapBlock>();
int x = block.Tile.Coordinate.X;
int y = block.Tile.Coordinate.Y;
//Populate the neighbourhood
if (x - 1 >= 0)
{
neighbourhood.Add(GameState.GlobalMap.GetBlockAtCoordinate(new MapCoordinate(x - 1, y, 0, MapType.GLOBAL)));
if (y - 1 >= 0)
{
neighbourhood.Add(GameState.GlobalMap.GetBlockAtCoordinate(new MapCoordinate(x - 1, y-1, 0, MapType.GLOBAL)));
}
if (y + 1 > worldSize)
{
neighbourhood.Add(GameState.GlobalMap.GetBlockAtCoordinate(new MapCoordinate(x - 1, y + 1, 0, MapType.GLOBAL)));
}
}
if (x + 1 < worldSize)
{
neighbourhood.Add(GameState.GlobalMap.GetBlockAtCoordinate(new MapCoordinate(x + 1, y, 0, MapType.GLOBAL)));
if (y - 1 >= 0)
{
neighbourhood.Add(GameState.GlobalMap.GetBlockAtCoordinate(new MapCoordinate(x + 1, y - 1, 0, MapType.GLOBAL)));
}
if (y + 1 > worldSize)
{
neighbourhood.Add(GameState.GlobalMap.GetBlockAtCoordinate(new MapCoordinate(x + 1, y + 1, 0, MapType.GLOBAL)));
}
}
if (y - 1 >= 0)
{
neighbourhood.Add(GameState.GlobalMap.GetBlockAtCoordinate(new MapCoordinate(x, y-1, 0, MapType.GLOBAL)));
}
if (y + 1 < worldSize)
{
neighbourhood.Add(GameState.GlobalMap.GetBlockAtCoordinate(new MapCoordinate(x, y+1, 0, MapType.GLOBAL)));
}
//now sum their elevations
foreach (MapBlock nBlock in neighbourhood)
{
if ((nBlock.Tile as GlobalTile).Elevation <= -300)
{
//weird error
(nBlock.Tile as GlobalTile).Elevation = -300;
}
}
int sum = neighbourhood.Sum(mb => (mb.Tile as GlobalTile).Elevation);
//work out their average
sum /= neighbourhood.Count;
return sum;
}
public static int InverseDistanceWeighting(MapBlock block, double p, int worldSize)
{
Random random = new Random();
int sample = 100;
int radius = 2;
int x = 0;
int y = 0;
MapCoordinate[] coorddata = new MapCoordinate[sample];
Double[] resultdata = new Double[sample];
for (int i = 0; i < sample; i++)
{
x = block.Tile.Coordinate.X + random.Next(radius * 2) - radius;
y = block.Tile.Coordinate.Y + random.Next(radius * 2) - radius;
if (x < 0)
{
x = 2;
}
if (x >= worldSize)
{
x = worldSize - 2;
}
if (y < 0)
{
y = 2;
}
if (y >= worldSize)
{
y = worldSize - 2;
}
coorddata[i] = new MapCoordinate(x, y, 0, MapType.GLOBAL);
resultdata[i] = (double)(GameState.GlobalMap.GetBlockAtCoordinate(new MapCoordinate(x, y, 0, MapType.GLOBAL)).Tile as GlobalTile).Elevation;
}
double sum1 = 0;
double sum2 = 0;
for (int j = 0; j < coorddata.Length; j++)
{
if (coorddata[j] - (block.Tile.Coordinate) != 0)
{
sum2 = sum2 + Math.Pow(1 / (coorddata[j] - (block.Tile.Coordinate)), p);
}
}
for (int i = 0; i < coorddata.Length; i++)
{
if (coorddata[i] - (block.Tile.Coordinate) != 0)
{
sum1 += Math.Pow(1 / (coorddata[i] - block.Tile.Coordinate), p) * resultdata[i] / sum2;
}
else
{
sum1 = resultdata[i];
}
}
return (int)sum1;
}
/// <summary>
/// Gets a block which is at a particular coordinate. If there is no block marked on the map, it will return an Air block.
/// </summary>
/// <param name="coordinate"></param>
/// <returns></returns>
public MapBlock GetBlockAtCoordinate(MapCoordinate coordinate)
{
if (coordinate.X < 0 || coordinate.Y < 0)
{
//out of range, send an airtile
MapBlock airBlock = new MapBlock();
airBlock.Tile = new MapItem();
airBlock.Tile.Coordinate = coordinate;
return airBlock;
}
if (this.globalGameMap == null || coordinate.X >= worldSize || coordinate.Y >= worldSize)
{
//out of range, send an airtile
//doesn't exist, send an air block.
MapBlock airBlock = new MapBlock();
airBlock.Tile = new MapItem();
airBlock.Tile.Coordinate = coordinate;
return airBlock;
}
if (this.globalGameMap[coordinate.X, coordinate.Y] != null)
{
return this.globalGameMap[coordinate.X, coordinate.Y];
}
else
{
//doesn't exist, send an air block.
MapBlock airBlock = new MapBlock();
airBlock.Tile = new DRObjects.Items.Tiles.Air(coordinate);
airBlock.Tile.Coordinate = coordinate;
return airBlock;
}
}
/// <summary>
/// Adds a number of blocks to the local map
/// </summary>
/// <param name="block"></param>
public void AddToGlobalMap(MapBlock[] blocks)
{
foreach (MapBlock block in blocks)
{
AddToGlobalMap(block);
}
}
/// <summary>
/// Generates a map with a particular biome
/// </summary>
/// <param name="herdAmount">The total amount of herds to generate</param>
/// <param name="BanditAmount">The total amount of bandits to generate.</param>
/// <param name="actors"></param>
/// <returns></returns>
public static MapBlock[,] GenerateMap(GlobalBiome biome, int herdAmount, int banditAmount, out Actor[] actors, out MapCoordinate startPoint)
{
MapBlock[,] map = new MapBlock[MAP_EDGE, MAP_EDGE];
Random random = new Random();
ItemFactory.ItemFactory factory = new ItemFactory.ItemFactory();
int tileID = 0;
factory.CreateItem(Archetype.TILES, details[biome].BaseTileTag, out tileID);
//Create a new map which is edge X edge in dimensions and made of the base tile
for (int x = 0; x < MAP_EDGE; x++)
{
for (int y = 0; y < MAP_EDGE; y++)
{
MapBlock block = new MapBlock();
map[x, y] = block;
block.Tile = factory.CreateItem("tile", tileID);
block.Tile.Coordinate = new MapCoordinate(x, y, 0, MapType.LOCAL);
}
}
#region Leave Town Item
//Now select all the border tiles and put in a "Exit here" border
for (int x = 0; x < map.GetLength(0); x++)
{
MapCoordinate coo = new MapCoordinate(x, 0, 0, MapType.LOCAL);
LeaveTownItem lti = new LeaveTownItem();
lti.Coordinate = coo;
lti.Description = "continue on your journey";
lti.Name = "Leave Area";
lti.Coordinate = coo;
map[x, 0].ForcePutItemOnBlock(lti);
coo = new MapCoordinate(x, map.GetLength(1) - 1, 0, MapType.LOCAL);
lti = new LeaveTownItem();
lti.Coordinate = coo;
lti.Description = "continue on your journey";
lti.Name = "Leave Area";
lti.Coordinate = coo;
map[x, map.GetLength(1) - 1].ForcePutItemOnBlock(lti);
}
for (int y = 0; y < map.GetLength(1); y++)
{
MapCoordinate coo = new MapCoordinate(0, y, 0, MapType.LOCAL);
LeaveTownItem lti = new LeaveTownItem();
lti.Coordinate = coo;
lti.Description = "continue on your journey";
lti.Name = "Leave Area";
lti.Coordinate = coo;
map[0, y].ForcePutItemOnBlock(lti);
coo = new MapCoordinate(map.GetLength(0) - 1, y, 0, MapType.LOCAL);
lti = new LeaveTownItem();
lti.Coordinate = coo;
lti.Description = "continue on your journey";
lti.Name = "Leave Area";
lti.Coordinate = coo;
map[map.GetLength(0) - 1, y].ForcePutItemOnBlock(lti);
}
#endregion
#region Desert Oasis
if (biome == GlobalBiome.ARID_DESERT)
{
//Let's create a pool of water towards one of the corners.
int randomNumber = random.Next(2);
int rXCoord = 0;
if (randomNumber == 1)
{
//Lower
rXCoord = random.Next(0, MAP_EDGE / 3);
}
else
{
rXCoord = random.Next(2 * MAP_EDGE / 3, MAP_EDGE);
}
randomNumber = random.Next(2);
int rYCoord = 0;
if (randomNumber == 1)
{
//Lower
rYCoord = random.Next(0, MAP_EDGE / 3);
}
else
{
rYCoord = random.Next(2 * MAP_EDGE / 3, MAP_EDGE);
}
//The pool will have a radius of 3
MapCoordinate coo = new MapCoordinate(rXCoord, rYCoord, 0, MapType.LOCAL);
//Go through the blocks with a radius of 3
var oasisBlocks = map.Cast<MapBlock>().ToArray().Where(b => Math.Abs(b.Tile.Coordinate - coo) <= 3).ToArray();
int waterTile = -1;
factory.CreateItem(Archetype.TILES, "water", out waterTile);
foreach (var block in oasisBlocks)
{
var coord = block.Tile.Coordinate;
block.Tile = factory.CreateItem("tile", waterTile);
block.Tile.Coordinate = coord;
}
var aroundOasis = map.Cast<MapBlock>().ToArray().Where(b => Math.Abs(b.Tile.Coordinate - coo) <= 4 && Math.Abs(b.Tile.Coordinate - coo) > 3).ToArray();
int dummy;
int grassTile = 0;
factory.CreateItem(Archetype.TILES, "grass", out grassTile);
foreach (var block in aroundOasis)
{
var coord = block.Tile.Coordinate;
block.Tile = factory.CreateItem("tile", grassTile);
block.Tile.Coordinate = coord;
}
//Put in some trees around the pool
for (int i = 0; i < 3; i++)
{
MapItem tree = factory.CreateItem(Archetype.MUNDANEITEMS, "jungle tree", out dummy);
var block = aroundOasis[random.Next(aroundOasis.Length)];
if (block.MayContainItems)
{
//Drop it
block.ForcePutItemOnBlock(tree);
}
}
}
#endregion
#region Wetland Splotches
if (biome == GlobalBiome.WETLAND)
{
int waterTile = -1;
factory.CreateItem(Archetype.TILES, "water", out waterTile);
for (int i=0; i < 7; i++)
{
MapBlock rBlock = map[random.Next(map.GetLength(0)), random.Next(map.GetLength(1))];
Rectangle safeRect = new Rectangle( MAP_EDGE/2 - 5,MAP_EDGE/2 -5,10,10);
if (safeRect.Contains(rBlock.Tile.Coordinate.X,rBlock.Tile.Coordinate.Y))
{
continue; //Not here!
}
int size = random.Next(1, 3);
//Get all the tiles around the block for a particular size
var pool = map.Cast<MapBlock>().ToArray().Where(b => Math.Abs(b.Tile.Coordinate - rBlock.Tile.Coordinate) <= size).ToArray();
foreach(var block in pool)
{
MapCoordinate coo = block.Tile.Coordinate;
block.Tile = factory.CreateItem("tiles", waterTile);
block.Tile.Coordinate = coo;
}
}
}
#endregion
for (int i = 0; i < details[biome].TreeCount; i++)
{
int treeID = 0;
MapItem item = null;
item = factory.CreateItem(Archetype.MUNDANEITEMS, details[biome].TreeTag, out treeID);
//try 50 times to put it somewhere
int tries = 0;
while (tries < 50)
{
MapBlock randomBlock = map[random.Next(map.GetLength(0)), random.Next(map.GetLength(1))];
if (randomBlock.MayContainItems)
{
randomBlock.ForcePutItemOnBlock(item);
break;
}
tries++;
}
}
List<Actor> actorList = new List<Actor>();
//There, now that's done, lets generate some animals
if (herdAmount + banditAmount > 0)
{
var herds = ActorGeneration.CreateAnimalHerds(biome, false, null, herdAmount);
var bandits = CampGenerator.CreateBandits(banditAmount);
var actorGroups = herds.Union(bandits);
//Each actor group will be placed in a random 3 radius circle
foreach (var actorGroup in actorGroups)
{
MapBlock randomBlock = map[random.Next(map.GetLength(0)), random.Next(map.GetLength(1))];
Rectangle wanderRect = new Rectangle(randomBlock.Tile.Coordinate.X - 2, randomBlock.Tile.Coordinate.Y - 2, 4, 4);
//Put the actor groups somewhere around that block
var blocks = map.Cast<MapBlock>().ToArray().Where(b => Math.Abs(b.Tile.Coordinate - randomBlock.Tile.Coordinate) < 4).ToArray();
//Pick a number of random blocks
foreach (var newActor in actorGroup)
{
int tries = 0;
while (tries < 50)
{
var actorBlock = blocks[random.Next(blocks.Length)];
if (actorBlock.MayContainItems)
{
//Put it there
newActor.MapCharacter.Coordinate = actorBlock.Tile.Coordinate;
actorBlock.ForcePutItemOnBlock(newActor.MapCharacter);
//Make them wander
newActor.MissionStack.Push(new WanderMission() { LoiterPercentage = 50, WanderPoint = actorBlock.Tile.Coordinate, WanderRectangle = wanderRect });
actorList.Add(newActor);
break;
}
tries++;
}
}
}
}
//Drop the player in the thick of it
MapBlock center = map[map.GetLength(0) / 2, map.GetLength(1) / 2];
center.RemoveTopItem(); //Remove it if someone else wanted it
startPoint = center.Tile.Coordinate;
actors = actorList.ToArray();
return map;
}
/// <summary>
/// Generates a dungeon having a particular amount of tiers, trap rooms, guard rooms and treasure rooms
/// </summary>
/// <param name="tiers">How many 'layers' the dungeon contains</param>
/// <param name="enemyArray">A list of enemy actors</param>
/// <param name="guardRooms">The maximum amount of guardrooms contained in the dungeon</param>
/// <param name="maxOwnedPopulation">For each owned room which generates enemies, the maximum amount GENERATED in each room (does not preclude patrols from entering the same room)</param>
/// <param name="maxWildPopulation">For each wild room which generates enemies, the maximum amount GENERATED in each room.</param>
/// <param name="ownerType">For each owned room, the type of the enemies to create</param>
/// <param name="percentageOwned">The percentage of the rooms which are owned as opposed to being wild. Bear in mind that wild rooms can spawn quite a bit of enemies</param>
/// <param name="pointsOfInterest">The points of interest (ie guard and treasure rooms for instance) which have been generated. Used for patrols</param>
/// <param name="startPoint">The entrance start point</param>
/// <param name="utilityRooms">The maximum amount of Utility rooms to generate - these might contain civilian orcs which ignore the maxOwnedPopulation value</param>
/// <param name="treasureRooms">The maximum amount of teasure rooms to generate</param>
/// <returns></returns>
public MapBlock[,] GenerateDungeon(int tiers, int utilityRooms, int guardRooms, int treasureRooms, string ownerType,
decimal percentageOwned, int maxWildPopulation, int maxOwnedPopulation,
out MapCoordinate startPoint, out DRObjects.Actor[] enemyArray, out List<PointOfInterest> pointsOfInterest)
{
startPoint = new MapCoordinate(0, 0, 0, MapType.LOCAL);
pointsOfInterest = new List<PointOfInterest>();
List<DRObjects.Actor> enemies = new List<DRObjects.Actor>();
List<CitadelRoom> rooms = new List<CitadelRoom>();
int uniqueID = 0;
//Start with the root node
CitadelRoom root = new CitadelRoom();
root.SquareNumber = (int)Math.Ceiling((double)WIDTH / 2);
root.TierNumber = 0;
root.UniqueID = uniqueID++;
root.Connections.Add(-1); //this is a special id. We'll use it to create a start point
rooms.Add(root);
int currentTier = 1;
int square = (int)Math.Ceiling((double)WIDTH / 2);
CitadelRoom focusNode = root;
Random random = new Random(DateTime.UtcNow.Millisecond);
while (currentTier < tiers)
{
//Create a new node
CitadelRoom newNode = new CitadelRoom();
newNode.SquareNumber = square;
newNode.TierNumber = currentTier;
newNode.UniqueID = uniqueID++;
newNode.CitadelRoomType = CitadelRoomType.EMPTY_ROOM;
//connect the focus node to this node
focusNode.Connections.Add(newNode.UniqueID);
newNode.Connections.Add(focusNode.UniqueID);
//change the focus node
focusNode = newNode;
//aaaand add it to the list
rooms.Add(newNode);
//Now we decide whether to stay in the same tier - or increase the tier
int randomNumber = random.Next(100);
int siblings = rooms.Where(r => r.TierNumber.Equals(currentTier)).Count();
int treshold = 0;
switch (siblings)
{
case 1: treshold = PROB_2; break;
case 2: treshold = PROB_3; break;
case 3: treshold = PROB_4; break;
case 4: treshold = PROB_5; break;
default: treshold = 0; break; //NEVER
}
if (randomNumber < treshold)
{
//then stay in the same place - go either left or right. Can we go in that direction?
bool canGoRight = !rooms.Any(r => (r.SquareNumber.Equals(square + 1) && r.TierNumber.Equals(currentTier)) || square + 1 > WIDTH);
bool canGoLeft = !rooms.Any(r => (r.SquareNumber.Equals(square - 1) && r.TierNumber.Equals(currentTier)) || square - 1 < 0);
if (canGoLeft && canGoRight)
{
//pick one at random
square += random.Next(2) == 1 ? 1 : -1;
}
else if (canGoLeft)
{
square -= 1;
}
else if (canGoRight)
{
square += 1;
}
else
{
//We've done it all
currentTier++;
}
}
else
{
currentTier++;
}
}
//Now that that part is done, lets add some more paths so we turn this into a graph
foreach (CitadelRoom room in rooms)
{
//For each room, check who is a sibling or immediatly under him. There is a 50% chance of forming a link
CitadelRoom[] potentialRooms = GetPathableRooms(rooms, room.TierNumber, room.SquareNumber);
foreach (CitadelRoom potentialRoom in potentialRooms)
{
//Is there a connection already?
if (!potentialRoom.Connections.Contains(room.UniqueID))
{
if (random.Next(2) == 1)
{
//add a connection
room.Connections.Add(potentialRoom.UniqueID);
potentialRoom.Connections.Add(room.UniqueID);
}
}
}
}
//go through the rooms and set some as wild rooms already
foreach (var room in rooms)
{
if (random.Next(100) > percentageOwned)
{
//Wild room
room.CitadelRoomType = CitadelRoomType.WILD_ROOM;
}
}
//Lets assign the rooms based on the maximum amount.
//Some rooms have more probability in certain regions.
//So lets divide the rooms in 3
//Favoured - x3
//Other - x2
//Unfavoured - x1
int lowerBoundary = rooms.Count / 3;
int upperBoundary = 2 * rooms.Count / 3;
var orderedUtilities = rooms.Where
(o => o.CitadelRoomType == CitadelRoomType.EMPTY_ROOM).OrderByDescending(o => random.Next(100) *
(o.UniqueID > upperBoundary ? 1 : o.UniqueID > lowerBoundary ? 2 : 3)).Where(r => r.CitadelRoomType == CitadelRoomType.EMPTY_ROOM
).ToArray().Take(utilityRooms);
foreach (var room in orderedUtilities)
{
room.CitadelRoomType = CitadelRoomType.UTILITY_ROOM;
}
//Same thing for treasure rooms
var orderedTreasure = rooms.Where
(o => o.CitadelRoomType == CitadelRoomType.EMPTY_ROOM).OrderByDescending(o => random.Next(100) *
(o.UniqueID > upperBoundary ? 3 : o.UniqueID > lowerBoundary ? 2 : 1)).Where(r => r.CitadelRoomType == CitadelRoomType.EMPTY_ROOM
).Take(treasureRooms);
foreach (var room in orderedTreasure)
{
room.CitadelRoomType = CitadelRoomType.TREASURE_ROOM;
}
//And guard rooms
var orderedGuard = rooms.Where
(o => o.CitadelRoomType == CitadelRoomType.EMPTY_ROOM).OrderByDescending(o => random.Next(100) *
(o.UniqueID > upperBoundary ? 1 : o.UniqueID > lowerBoundary ? 3 : 2)).Where(r => r.CitadelRoomType == CitadelRoomType.EMPTY_ROOM
).Take(guardRooms);
foreach (var room in orderedGuard)
{
room.CitadelRoomType = CitadelRoomType.GUARD_ROOM;
}
//Now that that part is done, we put them on the actual grid.
//We go for a 15x15 room and connect the items in it.
//15x15 - with a gap of 7 between them for tunnels
int mapWidth = ((WIDTH + 7) * 20);
int mapHeight = ((tiers + 7) * 20);
//Create new blocks
MapBlock[,] map = new MapBlock[mapWidth, mapHeight];
for (int x = 0; x < map.GetLength(0); x++)
{
for (int y = 0; y < map.GetLength(1); y++)
{
map[x, y] = new MapBlock()
{
Tile = new MapItem()
{
Coordinate = new MapCoordinate(x, y, 0, DRObjects.Enums.MapType.LOCAL),
MayContainItems = false
}
};
}
}
LocalMapGenerator gen = new LocalMapGenerator();
LocalMapXMLParser xmlGen = new LocalMapXMLParser();
//Start generating the maps and then stitch them upon the main map
foreach (CitadelRoom room in rooms)
{
MapBlock[,] gennedMap = null;
string tag = String.Empty;
switch (room.CitadelRoomType)
{
case CitadelRoomType.EMPTY_ROOM: tag = "Empty Dungeon"; break;
case CitadelRoomType.GUARD_ROOM: tag = "Guard Dungeon"; break;
case CitadelRoomType.UTILITY_ROOM: tag = "Utility Dungeon"; break;
case CitadelRoomType.TREASURE_ROOM: tag = "Treasure Dungeon"; break;
case CitadelRoomType.WILD_ROOM: tag = "Empty Dungeon"; break;
default:
throw new NotImplementedException("Dungeon Room " + room.CitadelRoomType + " not planned for yet.");
}
//Generate it :)
Maplet maplet = xmlGen.ParseMapletFromTag(tag);
Actor[] acts = null;
MapletActorWanderArea[] wanderAreas = null;
MapletPatrolPoint[] patrolPoints = null;
MapletFootpathNode[] footPath = null;
gennedMap = gen.GenerateMap(25, null, maplet, true, "", OwningFactions.ORCS ,out acts,out wanderAreas,out patrolPoints,out footPath);
enemies.AddRange(acts);
//Is it a treasure room?
if (room.CitadelRoomType == CitadelRoomType.TREASURE_ROOM)
{
//Generate some loot
GenerateLoot(gennedMap, room.TierNumber);
}
PointOfInterest mapletInterest = null;
if (room.CitadelRoomType == CitadelRoomType.GUARD_ROOM || room.CitadelRoomType == CitadelRoomType.TREASURE_ROOM)
{
//This will be a point of interest. Select a random walkable point in the room and mark the place as such
for (int tryAmount = 0; tryAmount < 50; tryAmount++)
{
//Try for a maximum of 50 times
int x = random.Next(gennedMap.GetLength(0));
int y = random.Next(gennedMap.GetLength(1));
if (gennedMap[x, y].Tile.MayContainItems)
{
//Put this as the point
PointOfInterest interest = new PointOfInterest();
interest.Coordinate = new MapCoordinate(x, y, 0, MapType.LOCAL);
if (room.CitadelRoomType == CitadelRoomType.GUARD_ROOM)
{
interest.Type = PointOfInterestType.GUARD_ROOM;
}
else if (room.CitadelRoomType == CitadelRoomType.TREASURE_ROOM)
{
interest.Type = PointOfInterestType.TREASURE;
}
pointsOfInterest.Add(interest);
mapletInterest = interest;
break;
}
}
}
DRObjects.Actor[] roomEnemies = new DRObjects.Actor[] { };
if (room.CitadelRoomType == CitadelRoomType.GUARD_ROOM || room.CitadelRoomType == CitadelRoomType.TREASURE_ROOM)
{
//Create an amount of enemies - level doesn't matter, we'll regen later
gennedMap = gen.GenerateEnemies(gennedMap, random.Next(maxOwnedPopulation), ownerType, out roomEnemies, 10);
enemies.AddRange(roomEnemies);
}
if (room.CitadelRoomType == CitadelRoomType.WILD_ROOM)
{
//Create an amount of wild enemies - let's get a random type for this room. This will be of level 5. Later we'll have proper wildlife
string type = ActorGeneration.GetEnemyType(false);
gennedMap = gen.GenerateEnemies(gennedMap, random.Next(maxWildPopulation), type, out roomEnemies, 5);
//go through all of room enemies and set them to idle
foreach (var enemy in roomEnemies)
{
enemy.MissionStack.Clear();
enemy.MissionStack.Push(new IdleMission());
}
enemies.AddRange(roomEnemies);
}
//fit her onto the main map
int xIncreaser = room.SquareNumber * 20;
int yIncreaser = (room.TierNumber * 20) + 3;
//Fix the patrol points of any enemies
foreach (Actor enemy in roomEnemies.Union(acts))
{
if (enemy.MissionStack.Count != 0 && enemy.MissionStack.Peek().MissionType == DRObjects.ActorHandling.ActorMissionType.WANDER)
{
//Change patrol point
MapCoordinate point = (enemy.MissionStack.Peek() as WanderMission).WanderPoint;
point.X += xIncreaser;
point.Y += yIncreaser;
//Change the rectangle x and y too
Rectangle rect = (enemy.MissionStack.Peek() as WanderMission).WanderRectangle;
rect.X = xIncreaser;
rect.Y = yIncreaser;
(enemy.MissionStack.Peek() as WanderMission).WanderRectangle = rect; //apparently rectangles are immutable or something
}
}
//Update the point of interest if there is one
if (mapletInterest != null)
{
mapletInterest.Coordinate.X += xIncreaser;
mapletInterest.Coordinate.Y += yIncreaser;
}
for (int x = 0; x < gennedMap.GetLength(0); x++)
{
for (int y = 0; y < gennedMap.GetLength(1); y++)
{
map[x + xIncreaser, y + yIncreaser] = gennedMap[x, y];
map[x + xIncreaser, y + yIncreaser].Tile.Coordinate = new MapCoordinate(x + xIncreaser, y + yIncreaser, 0, DRObjects.Enums.MapType.LOCAL);
foreach (var item in map[x + xIncreaser, y + yIncreaser].GetItems())
{
item.Coordinate = new MapCoordinate(x + xIncreaser, y + yIncreaser, 0, DRObjects.Enums.MapType.LOCAL);
}
}
}
//Lets draw the connections - only the ones who's rooms we've drawn yet
ItemFactory.ItemFactory factory = new ItemFactory.ItemFactory();
foreach (var connection in room.Connections.Where(c => c < room.UniqueID))
{
if (connection == -1)
{
//Entrance hall!
//Create a line of 3 at the bottom and return the coordinates
int topEdgeY = yIncreaser;
int bottomEdgeXMin = 0 + xIncreaser;
int bottomEdgeXMax = gennedMap.GetLength(0) + xIncreaser;
//Find the start
int xStart = (bottomEdgeXMax - bottomEdgeXMin) / 2 + bottomEdgeXMin;
//Set the start point
startPoint = new MapCoordinate(xStart + 1, topEdgeY - 2, 0, MapType.LOCAL);
//Put the 'leave town' item on it
map[startPoint.X, startPoint.Y].ForcePutItemOnBlock(new LeaveTownItem());
int x = xStart;
int y = topEdgeY;
//go 3 steps down
for (int a = 0; a < 3; a++)
{
for (int x1 = 0; x1 < 3; x1++)
{
//Draw!
map[x + x1, y].Tile = factory.CreateItem("TILES", 25);
map[x + x1, y].Tile.Coordinate = new MapCoordinate(x + x1, y, 0, MapType.LOCAL);
}
y--; //move down
}
y = topEdgeY;
//Walk back
do
{
for (int x1 = 0; x1 < 3; x1++)
{
//Draw!
map[x + x1, y].Tile = factory.CreateItem("TILES", 25);
map[x + x1, y].Tile.Coordinate = new MapCoordinate(x + x1, y, 0, MapType.LOCAL);
}
y++; //move up
} while (x >= 0 && y < map.GetLength(1) && !map[x, y].Tile.MayContainItems);
//Put the spikes at the entrance
int dummy = -1;
map[xStart, topEdgeY - 2].ForcePutItemOnBlock(factory.CreateItem(Archetype.MUNDANEITEMS, "spikes", out dummy));
map[xStart + 2, topEdgeY - 2].ForcePutItemOnBlock(factory.CreateItem(Archetype.MUNDANEITEMS, "spikes", out dummy));
continue;
}
//Identify the room to be connected with
var roomToBeConnected = rooms.Where(r => r.UniqueID.Equals(connection)).FirstOrDefault();
//Determine the direction relative to the current room
if (roomToBeConnected.SquareNumber > room.SquareNumber)
{
//RIGHT
//Find the rightmost edge of the room and start... somewhere
int rightEdgeX = gennedMap.GetLength(0) + xIncreaser;
int rightEdgeYMin = 0 + yIncreaser;
int rightEdgeYMax = gennedMap.GetLength(1) + yIncreaser;
//Pick a start at random
int yStart = random.Next(rightEdgeYMax - rightEdgeYMin - 2) + rightEdgeYMin;
//Now 'walk' from ystart-ystart+3 until you hit on something which has a block in it
int x = rightEdgeX;
int y = yStart;
while (x < map.GetLength(0) && y < map.GetLength(1) && !map[x, y].Tile.MayContainItems)
{
for (int y1 = 0; y1 < 3; y1++)
{
//Draw!
map[x, y + y1].Tile = factory.CreateItem("TILES", 25);
map[x, y + y1].Tile.Coordinate = new MapCoordinate(x, y + y1, 0, MapType.LOCAL);
}
x++; //increment x
}
x = rightEdgeX - 1;
//now lets walk backwards too
while (x >= 0 && x < map.GetLength(0) && y >= 0 && y < map.GetLength(1) && !map[x, y].Tile.MayContainItems)
{
for (int y1 = 0; y1 < 3; y1++)
{
//Draw!
map[x, y + y1].Tile = factory.CreateItem("TILES", 25);
map[x, y + y1].Tile.Coordinate = new MapCoordinate(x, y + y1, 0, MapType.LOCAL);
}
x--; //walk back
}
}
else if (roomToBeConnected.SquareNumber < room.SquareNumber)
{
//LEFT
//Find the leftMose edge of the room and start... somewhere
int leftEdgeX = xIncreaser;
int leftEdgeYMin = 0 + yIncreaser;
int leftEdgeYMax = gennedMap.GetLength(1) + yIncreaser;
//Pick a start at random
int yStart = random.Next(leftEdgeYMax - leftEdgeYMin - 2) + leftEdgeYMin;
//Now 'walk' from ystart-ystart+3 until you hit on something which has a block in it
int x = leftEdgeX;
int y = yStart;
do
{
for (int y1 = 0; y1 < 3; y1++)
{
//Draw!
map[x, y + y1].Tile = factory.CreateItem("TILES", 25);
map[x, y + y1].Tile.Coordinate = new MapCoordinate(x, y + y1, 0, MapType.LOCAL);
}
x--; //decrement x
} while (x >= 0 && x < map.GetLength(0) && y >= 0 && y < map.GetLength(1) && !map[x, y].Tile.MayContainItems);
x = leftEdgeX + 1;
//walk backwards
do
{
for (int y1 = 0; y1 < 3; y1++)
{
//Draw!
map[x, y + y1].Tile = factory.CreateItem("TILES", 25);
map[x, y + y1].Tile.Coordinate = new MapCoordinate(x, y + y1, 0, MapType.LOCAL);
}
x++; //walk back
} while (x >= 0 && x < map.GetLength(0) && y >= 0 && y < map.GetLength(1) && !map[x, y].Tile.MayContainItems);
}
else if (roomToBeConnected.TierNumber < room.TierNumber)
{
//BOTTOM
//Find the bottommost edge of the room and start... somewhere
int bottomEdgeY = yIncreaser;
int bottomEdgeXMin = 0 + xIncreaser;
int bottomEdgeXMax = gennedMap.GetLength(0) + xIncreaser;
//Pick a start at random
int xStart = random.Next(bottomEdgeXMax - bottomEdgeXMin - 2) + bottomEdgeXMin;
//Now 'walk' from xstart-xstart+3 until you hit on something which has a block in it
int x = xStart;
int y = bottomEdgeY;
do
{
for (int x1 = 0; x1 < 3; x1++)
{
//Draw!
map[x + x1, y].Tile = factory.CreateItem("TILES", 25);
map[x + x1, y].Tile.Coordinate = new MapCoordinate(x + x1, y, 0, MapType.LOCAL);
}
y--; //decrement y
} while (x >= 0 && x < map.GetLength(0) && y >= 0 && y < map.GetLength(1) && !map[x, y].Tile.MayContainItems);
y = bottomEdgeY + 1;
//Walk backwards
do
{
for (int x1 = 0; x1 < 3; x1++)
{
//Draw!
map[x + x1, y].Tile = factory.CreateItem("TILES", 25);
map[x + x1, y].Tile.Coordinate = new MapCoordinate(x + x1, y, 0, MapType.LOCAL);
}
y++; //walk back
} while (x >= 0 && x < map.GetLength(0) && y >= 0 && y < map.GetLength(1) && !map[x, y].Tile.MayContainItems);
}
else if (roomToBeConnected.TierNumber > room.TierNumber)
{
//TOP - Won't ever happen - but sure
//Find the topmost edge of the room and start... somewhere
int topEdgeY = yIncreaser + gennedMap.GetLength(1);
int bottomEdgeXMin = 0 + xIncreaser;
int bottomEdgeXMax = gennedMap.GetLength(0) + xIncreaser;
//Pick a start at random
int xStart = random.Next(bottomEdgeXMax - bottomEdgeXMin - 2) + bottomEdgeXMin;
//Now 'walk' from xstart-xstart+3 until you hit on something which has a block in it
int x = xStart;
int y = topEdgeY;
do
{
bool holed = false;
for (int x1 = 0; x1 < 3; x1++)
{
if (!holed)
{
//Have a chance of putting in a hole
if (random.Next(8) == 0)
{
holed = true;
continue; //don't put in a tile
}
}
//Draw!
map[x + x1, y].Tile = factory.CreateItem("TILES", 25);
map[x + x1, y].Tile.Coordinate = new MapCoordinate(x + x1, y, 0, MapType.LOCAL);
}
y++; //move up
} while (x >= 0 && x < map.GetLength(0) && y >= 0 && y < map.GetLength(1) && !map[x, y].Tile.MayContainItems);
//walk back
y = topEdgeY + 1;
do
{
for (int x1 = 0; x1 < 3; x1++)
{
//Draw!
map[x + x1, y].Tile = factory.CreateItem("TILES", 25);
map[x + x1, y].Tile.Coordinate = new MapCoordinate(x + x1, y, 0, MapType.LOCAL);
}
y--; //move down
} while (x >= 0 && x < map.GetLength(0) && y >= 0 && y < map.GetLength(1) && !map[x, y].Tile.MayContainItems);
}
}
}
//We need to fix the enemies to conform to the standards
ConformEnemies(enemies);
enemyArray = enemies.ToArray();
return map;
}
/// <summary>
/// Puts settlement items on a particular location pertianing to a particular settlement.
/// </summary>
/// <param name="capital">Whether it's the capital or not</param>
/// <param name="settlement">The settlement which it represents</param>
/// <param name="block">The block making up the center</param>
private static SettlementItem CreateSettlement(bool capital, Settlement settlement, MapBlock block, int owner)
{
//Put an entire group of SettlementItems on it
MapCoordinate[] settlementCoordinates = new MapCoordinate[10];
SettlementItem retItem = null;
settlementCoordinates[7] = new MapCoordinate(block.Tile.Coordinate.X - 1, block.Tile.Coordinate.Y - 1, 0, MapType.GLOBAL);
settlementCoordinates[8] = new MapCoordinate(block.Tile.Coordinate.X, block.Tile.Coordinate.Y - 1, 0, MapType.GLOBAL);
settlementCoordinates[9] = new MapCoordinate(block.Tile.Coordinate.X + 1, block.Tile.Coordinate.Y - 1, 0, MapType.GLOBAL);
settlementCoordinates[4] = new MapCoordinate(block.Tile.Coordinate.X - 1, block.Tile.Coordinate.Y, 0, MapType.GLOBAL);
settlementCoordinates[5] = new MapCoordinate(block.Tile.Coordinate.X, block.Tile.Coordinate.Y, 0, MapType.GLOBAL);
settlementCoordinates[6] = new MapCoordinate(block.Tile.Coordinate.X + 1, block.Tile.Coordinate.Y, 0, MapType.GLOBAL);
settlementCoordinates[1] = new MapCoordinate(block.Tile.Coordinate.X - 1, block.Tile.Coordinate.Y + 1, 0, MapType.GLOBAL);
settlementCoordinates[2] = new MapCoordinate(block.Tile.Coordinate.X, block.Tile.Coordinate.Y + 1, 0, MapType.GLOBAL);
settlementCoordinates[3] = new MapCoordinate(block.Tile.Coordinate.X + 1, block.Tile.Coordinate.Y + 1, 0, MapType.GLOBAL);
//Block the radius around it from colonising
MapBlock[] regionalBlocks = GetBlocksAroundPoint(block.Tile.Coordinate, HUMAN_COLONY_BLOCKING_RADIUS);
foreach (MapBlock rblock in regionalBlocks)
{
(rblock.Tile as GlobalTile).IsBlockedForColonisation = true;
}
//Claim the land around it
MapBlock[] claimedBlocks = GetBlocksAroundPoint(block.Tile.Coordinate, HUMAN_COLONY_CLAIMING_RADIUS);
foreach (MapBlock rblock in claimedBlocks)
{
//This is a disputed region. For now let's not allow creep.
//Later this might be cause for war
if (!(rblock.Tile as GlobalTile).Owner.HasValue)
{
(rblock.Tile as GlobalTile).Owner = owner;
}
}
for (int corner = 1; corner < 10; corner++)
{
var cornerBlock = GameState.GlobalMap.GetBlockAtCoordinate(settlementCoordinates[corner]);
//Cut any forests down
switch ((cornerBlock.Tile as GlobalTile).Biome)
{
case GlobalBiome.DENSE_FOREST:
(cornerBlock.Tile as GlobalTile).Biome = GlobalBiome.GRASSLAND;
break;
case GlobalBiome.WOODLAND:
(cornerBlock.Tile as GlobalTile).Biome = GlobalBiome.GRASSLAND;
break;
case GlobalBiome.POLAR_FOREST:
(cornerBlock.Tile as GlobalTile).Biome = GlobalBiome.POLAR_DESERT;
break;
}
var settlementItem = new SettlementItem()
{
Coordinate = settlementCoordinates[corner],
IsCapital = capital,
MayContainItems = true,
SettlementCorner = corner,
SettlementSize = settlement.SettlementSize,
Description = (capital ? "the capital of " + settlement.Name : "the settlement of " + settlement.Name) + " owned by " + settlement.Civilisation.Name,
Name = settlement.Name,
Settlement = settlement,
OwnerID = owner
};
GameState.GlobalMap.GetBlockAtCoordinate(settlementCoordinates[corner])
.ForcePutItemOnBlock(settlementItem);
if (settlementItem.SettlementCorner == 5) //center
{
retItem = settlementItem;
}
}
return retItem;
}
/// <summary>
/// Generates loot for treasure rooms. We will have LOOT_MULTIPLIER of loot multiplied by tierNumber
/// </summary>
public void GenerateLoot(MapBlock[,] blocks, int tierNumber)
{
//Determine the maximum total value we want to generate
int totalValue = tierNumber * LOOT_MULTIPLIER;
InventoryItemManager mgr = new InventoryItemManager();
var items = mgr.GetItemsWithAMaxValue(null, totalValue);
//Put the items on the map
foreach (var item in items)
{
//Find a random point. Try 50 times
for (int attempts = 0; attempts < 50; attempts++)
{
var chosenBlock = blocks[GameState.Random.Next(blocks.GetLength(0)), GameState.Random.Next(blocks.GetLength(1))];
if (chosenBlock.MayContainItems)
{
//Put it in
chosenBlock.ForcePutItemOnBlock(item);
break;
}
}
}
}
/// <summary>
/// Initialises the World Map in preperation. Creates the regions with empty ones, and sets the default tile settings
/// </summary>
private static void Initialisation()
{
//start the map
GameState.GlobalMap = new GlobalMap(WORLDSIZE);
regions = new Region[REGIONSIZE + 1];
//fill the regions with new regions
for (int i = 0; i < regions.Length; i++)
{
regions[i] = new Region();
}
//populate the world map with a number of tiles with an elevation of 40
for (int x = 0; x < WORLDSIZE; x++)
{
lock (GlobalMap.lockMe)
{ //this is rather inefficient, but it will allow the interface to draw something
//CurrentStep = "Populating Tiles for line :" + x;
for (int y = 0; y < WORLDSIZE; y++)
{
MapBlock block = new MapBlock();
block.Tile = new GlobalTile();
block.Tile.Coordinate = new MapCoordinate(x, y, 0, MapType.GLOBAL);
GlobalTile gTile = (block.Tile as GlobalTile);
gTile.Elevation = 40;
gTile.ClimateTemperature = 0;
gTile.HasHillSlope = false;
gTile.HasRiver = false;
gTile.Rainfall = 0;
GameState.GlobalMap.AddToGlobalMap(block);
}
}
}
}
/// <summary>
/// Generates a camp
/// </summary>
/// <returns></returns>
public static MapBlock[,] GenerateCamp(int enemies, out MapCoordinate startPoint, out DRObjects.Actor[] enemyArray)
{
MapBlock[,] map = new MapBlock[MAP_EDGE, MAP_EDGE];
Random random = new Random();
ItemFactory.ItemFactory factory = new ItemFactory.ItemFactory();
int grassTileID = 0;
factory.CreateItem(Archetype.TILES, "grass", out grassTileID);
//Create a new map which is edge X edge in dimensions and made of grass
for (int x = 0; x < MAP_EDGE; x++)
{
for (int y = 0; y < MAP_EDGE; y++)
{
MapBlock block = new MapBlock();
map[x, y] = block;
block.Tile = factory.CreateItem("tile", grassTileID);
block.Tile.Coordinate = new MapCoordinate(x, y, 0, MapType.LOCAL);
}
}
//Now created a wall
int pallisadeID = 0;
factory.CreateItem(Archetype.MUNDANEITEMS, "pallisade wall lr", out pallisadeID);
//Create a square of pallisade wall
int startCoord = (MAP_EDGE - FORTIFICATION_EDGE) / 2;
int endCoord = MAP_EDGE - ((MAP_EDGE - FORTIFICATION_EDGE) / 2);
for (int x = startCoord + 1; x < endCoord; x++)
{
MapBlock block = map[x, startCoord];
MapItem item = factory.CreateItem("mundaneitems", pallisadeID);
block.ForcePutItemOnBlock(item);
block = map[x, endCoord];
item = factory.CreateItem("mundaneitems", pallisadeID);
block.ForcePutItemOnBlock(item);
}
pallisadeID = 0;
for (int y = startCoord + 1; y < endCoord; y++)
{
factory.CreateItem(Archetype.MUNDANEITEMS, "pallisade wall tb", out pallisadeID);
MapBlock block = map[startCoord, y];
MapItem item = factory.CreateItem("mundaneitems", pallisadeID);
block.ForcePutItemOnBlock(item);
factory.CreateItem(Archetype.MUNDANEITEMS, "pallisade wall bt", out pallisadeID);
block = map[endCoord, y];
item = factory.CreateItem("mundaneitems", pallisadeID);
block.ForcePutItemOnBlock(item);
}
//We need to poke a hole in wall as an entrance
//Let's poke one at the top and one at the bottom
int center = MAP_EDGE / 2;
int rValue = GameState.Random.Next(2);
for (int x = -1; x < 2; x++)
{
if (rValue == 1)
{
MapBlock block = map[center + x, startCoord];
block.RemoveTopItem();
}
else
{
MapBlock block = map[center + x, endCoord];
block.RemoveTopItem();
}
}
rValue = GameState.Random.Next(2);
for (int y = -1; y < 2; y++)
{
if (rValue == 1)
{
MapBlock block = map[startCoord, y + center];
block.RemoveTopItem();
}
else
{
MapBlock block = map[endCoord, y + center];
block.RemoveTopItem();
}
}
//Now, let's create some maplets in there
//There's a single maplet containing the other maplets - let's get it
LocalMapXMLParser lm = new LocalMapXMLParser();
Maplet maplet = lm.ParseMapletFromTag("camp");
LocalMapGenerator gen = new LocalMapGenerator();
//TODO: LATER THE OWNER MIGHT NOT BE A BANDIT
MapletActorWanderArea[] wanderAreas = null;
MapletPatrolPoint[] patrolPoints = null;
MapletFootpathNode[] footPath = null;
var gennedMap = gen.GenerateMap(grassTileID, null, maplet, false, "", OwningFactions.BANDITS, out enemyArray, out wanderAreas, out patrolPoints,out footPath);
gen.JoinMaps(map, gennedMap, startCoord + 1, startCoord + 1);
//Let's add some trees and stuff
int decorCount = (int)(map.GetLength(1) * 0.50);
//Just find as many random points and if it happens to be grass, drop them
int itemID = 0;
for (int i = 0; i < decorCount; i++)
{
//Just trees
MapItem decorItem = factory.CreateItem(Archetype.MUNDANEITEMS, "tree", out itemID);
//Pick a random point
MapBlock randomBlock = map[random.Next(map.GetLength(0)), random.Next(map.GetLength(1))];
//Make sure its not inside the camp
if (randomBlock.Tile.Coordinate.X >= startCoord && randomBlock.Tile.Coordinate.X <= endCoord && randomBlock.Tile.Coordinate.Y >= startCoord && randomBlock.Tile.Coordinate.Y <= endCoord)
{
//Not within the camp
i--;
continue; //try again
}
if (randomBlock.MayContainItems && randomBlock.Tile.Name == "Grass")
{
//Yes, can support it
randomBlock.ForcePutItemOnBlock(decorItem);
}
//Otherwise forget all about it
}
//Now select all the border tiles and put in a "Exit here" border
for (int x = 0; x < map.GetLength(0); x++)
{
MapCoordinate coo = new MapCoordinate(x, 0, 0, MapType.LOCAL);
LeaveTownItem lti = new LeaveTownItem();
lti.Coordinate = coo;
lti.Description = "path outside the town";
lti.Name = "Leave Town";
lti.Coordinate = coo;
map[x, 0].ForcePutItemOnBlock(lti);
coo = new MapCoordinate(x, map.GetLength(1) - 1, 0, MapType.LOCAL);
lti = new LeaveTownItem();
lti.Coordinate = coo;
lti.Description = "path outside the town";
lti.Name = "Leave Town";
lti.Coordinate = coo;
map[x, map.GetLength(1) - 1].ForcePutItemOnBlock(lti);
}
for (int y = 0; y < map.GetLength(1); y++)
{
MapCoordinate coo = new MapCoordinate(0, y, 0, MapType.LOCAL);
LeaveTownItem lti = new LeaveTownItem();
lti.Coordinate = coo;
lti.Description = "path outside the town";
lti.Name = "Leave Town";
lti.Coordinate = coo;
map[0, y].ForcePutItemOnBlock(lti);
coo = new MapCoordinate(map.GetLength(0) - 1, y, 0, MapType.LOCAL);
lti = new LeaveTownItem();
lti.Coordinate = coo;
lti.Description = "path outside the town";
lti.Name = "Town Borders";
lti.Coordinate = coo;
map[map.GetLength(0) - 1, y].ForcePutItemOnBlock(lti);
}
#region Treasure Room
//This is a bit naughty. We need to locate where the tiles become soil
MapCoordinate soilStart = null;
bool breakOut = false;
for (int x = 0; x < map.GetLength(0); x++)
{
for (int y = 0; y < map.GetLength(1); y++)
{
if (map[x, y].Tile.Name.ToLower().Equals("soil"))
{
soilStart = new MapCoordinate(x, y, 0, MapType.LOCAL);
breakOut = true;
break;
}
}
if (breakOut)
{
break;
}
}
//Also naughty, we know it's 5x5
#region Inner Wall
for (int x = 0; x < 5; x++)
{
factory.CreateItem(Archetype.MUNDANEITEMS, "pallisade wall lr", out pallisadeID);
MapItem item = factory.CreateItem("mundaneitems", pallisadeID);
if (x != 2) //hole in the top
{
map[soilStart.X + x, soilStart.Y].ForcePutItemOnBlock(item);
}
factory.CreateItem(Archetype.MUNDANEITEMS, "pallisade wall lr", out pallisadeID);
item = factory.CreateItem("mundaneitems", pallisadeID);
map[soilStart.X + x, soilStart.Y + 5].ForcePutItemOnBlock(item);
}
for (int y = 0; y < 5; y++)
{
factory.CreateItem(Archetype.MUNDANEITEMS, "pallisade wall tb", out pallisadeID);
MapItem item = factory.CreateItem("mundaneitems", pallisadeID);
map[soilStart.X - 1, soilStart.Y + y].ForcePutItemOnBlock(item);
factory.CreateItem(Archetype.MUNDANEITEMS, "pallisade wall bt", out pallisadeID);
item = factory.CreateItem("mundaneitems", pallisadeID);
map[soilStart.X + 5, soilStart.Y + y].ForcePutItemOnBlock(item);
}
#endregion
#endregion
#region Patrol Points
//Now let's collect the patrol points. We're going to have two possible patrols - one around each of the entrances - and another on the outside corners of the map
List<MapCoordinate> outsidePatrol = new List<MapCoordinate>();
outsidePatrol.Add(new MapCoordinate(startCoord - 2, startCoord, 0, MapType.LOCAL));
outsidePatrol.Add(new MapCoordinate(endCoord + 2, startCoord, 0, MapType.LOCAL));
outsidePatrol.Add(new MapCoordinate(endCoord + 2, endCoord, 0, MapType.LOCAL));
outsidePatrol.Add(new MapCoordinate(startCoord - 2, endCoord, 0, MapType.LOCAL));
List<MapCoordinate> insidePatrol = new List<MapCoordinate>();
insidePatrol.Add(new MapCoordinate(center, startCoord + 1, 0, MapType.LOCAL));
insidePatrol.Add(new MapCoordinate(center, endCoord - 1, 0, MapType.LOCAL));
insidePatrol.Add(new MapCoordinate(startCoord + 1, center, 0, MapType.LOCAL));
insidePatrol.Add(new MapCoordinate(endCoord - 1, center, 0, MapType.LOCAL));
//Go through all of those and make sure they're clear of anything that wouldn't let them walk upon them
foreach (var coordinate in outsidePatrol)
{
map[coordinate.X, coordinate.Y].RemoveTopItem();
}
foreach (var coordinate in insidePatrol)
{
map[coordinate.X, coordinate.Y].RemoveTopItem();
}
#endregion
#region Actors
enemyArray = CreateBandits(enemies, outsidePatrol.Select(op => new PatrolPoint() { AcceptableRadius = 2, Coordinate = op }).ToList(), insidePatrol.Select(op => new PatrolPoint() { AcceptableRadius = 2, Coordinate = op }).ToList());
int tries = 0;
//Put them on the mappity map
for (int i = 0; i < enemyArray.Length; i++)
{
Actor actor = enemyArray[i];
int randomX = random.Next(map.GetLength(0));
int randomY = random.Next(map.GetLength(1));
if (map[randomX, randomY].MayContainItems)
{
//Plop it on there
actor.MapCharacter.Coordinate = new MapCoordinate(randomX, randomY, 0, MapType.LOCAL);
map[randomX, randomY].ForcePutItemOnBlock(actor.MapCharacter);
tries = 0;
////If they are wandering, make them wander in the right place
//var mission = actor.MissionStack.Peek();
//if (mission.MissionType == ActorMissionType.WANDER)
//{
// var wander = mission as WanderMission;
// wander.WanderPoint = new MapCoordinate(actor.MapCharacter.Coordinate);
// wander.WanderRectangle = new Rectangle(startCoord, startCoord, FORTIFICATION_EDGE, FORTIFICATION_EDGE);
//}
}
else
{
tries++;
i--;
}
if (tries >= 50)
{
//give up
continue;
}
}
#endregion
startPoint = new MapCoordinate(map.GetLength(0) / 2, 0, 0, MapType.LOCAL);
return map;
}
/// <summary>
/// Places the contents of the items in the maplet into the base map. Tiles must already have been set at this point, as this will only place mapitems.
/// </summary>
/// <param name="baseMap">The Base Map</param>
/// <param name="maplet">The maplet items to place</param>
/// <param name="startX">The x coordinate on the basemap where to start</param>
/// <param name="startY">The y coordinate on the basemap where to start</param>
/// <returns></returns>
public MapBlock[,] JoinMaps(MapBlock[,] baseMap, MapBlock[,] maplet, int startX, int startY)
{
for (int x = 0; x < maplet.GetLength(0); x++)
{
for (int y = 0; y < maplet.GetLength(1); y++)
{
MapBlock block = baseMap[x + startX, y + startY];
MapBlock mapletBlock = maplet[x, y];
if (block.GetItems().Length == 0)
{
//This means there is nothing on this block, so lets replace it
//The only time when this will be true is if there is a shared wall, in which case we'll keep the parent wall type
baseMap[x + startX, y + startY] = mapletBlock;
//Fix the base coordinate
baseMap[x + startX, y + startY].Tile.Coordinate = new MapCoordinate(x + startX, y + startY, 0, DRObjects.Enums.MapType.LOCAL);
//also fix any items on the tile
foreach (MapItem item in baseMap[x + startX, y + startY].GetItems())
{
item.Coordinate = new MapCoordinate(x + startX, y + startY, 0, DRObjects.Enums.MapType.LOCAL);
}
}
}
}
return baseMap;
}
public static MapBlock[] GetBlocksAroundPoint(MapBlock[,] map, MapCoordinate centre, int radius)
{
int minY = centre.Y - Math.Abs(radius);
int maxY = centre.Y + Math.Abs(radius);
int minX = centre.X - Math.Abs(radius);
int maxX = centre.X + Math.Abs(radius);
List<MapBlock> returnList = new List<MapBlock>();
//go through all of them
for (int yLoop = maxY; yLoop >= minY; yLoop--)
{
for (int xLoop = minX; xLoop <= maxX; xLoop++)
{
MapCoordinate coord = new MapCoordinate(xLoop, yLoop, 0, MapType.GLOBAL);
if (xLoop >= 0 && xLoop < map.GetLength(0) && yLoop >= 0 && yLoop < map.GetLength(1))
{ //make sure they're in the map
returnList.Add(map[xLoop, yLoop]);
}
}
}
return returnList.ToArray();
}
/// <summary>
/// Generates a map based on the maplet assigned
/// </summary>
/// <param name="maplet">The maplet to generate</param>
/// <param name="parentWallID">The wall that the parent has</param>
/// <param name="parentTileID">The ID of the tiles used in the parent maplet item</param>
/// <param name="enemyType">The type of actor which is dominant in this map</param>
/// <param name="owner">The owner of the map. Any maplet items which don't belong will be hidden</param>
/// <param name="actors">The actors which we have generated</param>
/// <param name="actorType">The type of actors to generate</param>
/// <returns></returns>
public MapBlock[,] GenerateMap(int parentTileID, int? parentWallID, Maplet maplet, bool preferSides, string actorType, OwningFactions owner,
out Actor[] actors, out MapletActorWanderArea[] wAreas, out MapletPatrolPoint[] patrolRoutes, out MapletFootpathNode[] footpathNodes)
{
List<Actor> actorList = new List<Actor>();
List<MapletActorWanderArea> wanderAreas = new List<MapletActorWanderArea>();
List<MapletPatrolPoint> patrolRouteList = new List<MapletPatrolPoint>();
List<MapletFootpathNode> footpathNodeList = new List<MapletFootpathNode>();
PlanningMapItemType[,] planningMap = new PlanningMapItemType[maplet.SizeX, maplet.SizeY];
//Step 1: Plan how the map will look
//Step 1a: Set all tiles to available, and set the frame to walls if there's a wall
planningMap = this.CreateBlueprint(maplet);
//Step 1b: Put in the tiles in the actual map, and the walls if they are present
MapBlock[,] generatedMap = new MapBlock[maplet.SizeX, maplet.SizeY];
ItemFactory.ItemFactory factory = new ItemFactory.ItemFactory();
int tileID = 0;
if (maplet.Tiled)
{
if (maplet.TileID.HasValue)
{
tileID = maplet.TileID.Value;
}
else
{
//Load the tileID from the factory
factory.CreateItem(Archetype.TILES, maplet.TileTag, out tileID);
}
}
else
{
tileID = parentTileID;
}
//That's the tiles done
for (int x = 0; x < generatedMap.GetLength(0); x++)
{
for (int y = 0; y < generatedMap.GetLength(1); y++)
{
MapItem tile = factory.CreateItem("tile", tileID);
tile.Coordinate = new MapCoordinate(x, y, 0, DRObjects.Enums.MapType.LOCAL);
MapBlock block = new MapBlock();
block.Tile = tile;
generatedMap[x, y] = block;
}
}
//Do the walls now if they are required
int? wallID = null;
int tempWallID = -1;
if (parentWallID.HasValue)
{
MapItem wall = factory.CreateItem("MUNDANEITEMS", parentWallID.Value);
wallID = parentWallID;
}
else
{
MapItem wall = factory.CreateItem(DRObjects.Enums.Archetype.MUNDANEITEMS, "wall", out tempWallID);
wallID = tempWallID;
}
if (maplet.Walled && wallID.HasValue)
{
//wall the edge tiles
for (int x = 0; x < maplet.SizeX; x++)
{
generatedMap[x, 0].PutItemOnBlock(factory.CreateItem("mundaneitems", wallID.Value));
generatedMap[x, maplet.SizeY - 1].PutItemOnBlock(factory.CreateItem("mundaneitems", wallID.Value));
if (maplet.WindowProbability.HasValue && maplet.WindowProbability.Value > 0)
{
if (random.Next(100) < maplet.WindowProbability.Value)
{
int itemID;
//Put a window :)
generatedMap[x, 0].ForcePutItemOnBlock(factory.CreateItem(DRObjects.Enums.Archetype.MUNDANEITEMS, "window", out itemID));
}
else if (random.Next(100) < maplet.WindowProbability.Value)
{
int itemID;
//Put a window :)
generatedMap[x, maplet.SizeY - 1].ForcePutItemOnBlock(factory.CreateItem(DRObjects.Enums.Archetype.MUNDANEITEMS, "window", out itemID));
}
}
}
for (int y = 0; y < maplet.SizeY; y++)
{
generatedMap[0, y].PutItemOnBlock(factory.CreateItem("mundaneitems", wallID.Value));
generatedMap[maplet.SizeX - 1, y].PutItemOnBlock(factory.CreateItem("mundaneitems", wallID.Value));
if (maplet.WindowProbability.HasValue && maplet.WindowProbability.Value > 0)
{
if (random.Next(100) < maplet.WindowProbability.Value)
{
int itemID;
//Put a window :)
generatedMap[0, y].ForcePutItemOnBlock(factory.CreateItem(DRObjects.Enums.Archetype.MUNDANEITEMS, "window", out itemID));
}
else if (random.Next(100) < maplet.WindowProbability.Value)
{
int itemID;
//Put a window :)
generatedMap[maplet.SizeX - 1, y].ForcePutItemOnBlock(factory.CreateItem(DRObjects.Enums.Archetype.MUNDANEITEMS, "window", out itemID));
}
}
}
}
//Step 1c: Determine where we'll put the maplets
foreach (MapletContentsMaplet childMaplet in maplet.MapletContents.Where(mc => (mc is MapletContentsMaplet)).OrderByDescending(mc => mc.ProbabilityPercentage).ThenBy(mc => random.Next()))
{
//Calculate the probability of putting the item in, and how many items we're putting
for (int i = 0; i < childMaplet.MaxAmount; i++)
{
if (random.NextDouble() * 100 <= childMaplet.ProbabilityPercentage)
{
//Does it fit?
int x = -1;
int y = -1;
PlanningMapItemType[,] newMap;
//Convert the child maplet into a planning map
PlanningMapItemType[,] childMapletBlueprint = this.CreateBlueprint(childMaplet.Maplet);
//mark the areas covered by the blueprint as being held by that blueprint
if (childMaplet.Position == PositionAffinity.FIXED)
{
if (Fits(planningMap, childMapletBlueprint, childMaplet.x.Value, childMaplet.y.Value, out newMap))
{
//it fits, generate it - <3 Recursion
Actor[] childActors = null;
MapletActorWanderArea[] wanderA = null;
MapletPatrolPoint[] patrolPoints = null;
MapletFootpathNode[] fpNodes = null;
MapBlock[,] childMap = this.GenerateMap(tileID, wallID.Value, childMaplet.Maplet, childMaplet.Position == DRObjects.LocalMapGeneratorObjects.Enums.PositionAffinity.SIDES, actorType, owner, out childActors, out wanderA, out patrolPoints, out fpNodes);
//Add the child actors
actorList.AddRange(childActors);
//Update any actors's locations should they have any
foreach (var actor in childActors)
{
if (actor.MissionStack.Count() > 0)
{
var wander = actor.MissionStack.Peek() as WanderMission;
if (wander != null)
{
wander.WanderPoint.X += childMaplet.x.Value;
wander.WanderPoint.Y += childMaplet.y.Value;
wander.WanderRectangle = new Rectangle(wander.WanderRectangle.X + childMaplet.x.Value, wander.WanderRectangle.Y + childMaplet.y.Value, wander.WanderRectangle.Width, wander.WanderRectangle.Height);
}
}
}
//Update any wander areas too
foreach (var area in wanderA)
{
area.WanderRect = new Rectangle(area.WanderRect.X + childMaplet.x.Value, area.WanderRect.Y + childMaplet.y.Value, area.WanderRect.Width, area.WanderRect.Height);
area.WanderPoint.X += childMaplet.x.Value;
area.WanderPoint.Y += childMaplet.y.Value;
}
//and patrol points
foreach (var point in patrolPoints)
{
point.Point.X += childMaplet.x.Value;
point.Point.Y += childMaplet.y.Value;
}
foreach (var n in fpNodes)
{
n.Point.X += childMaplet.x.Value;
n.Point.Y += childMaplet.y.Value;
}
//And add them
wanderAreas.AddRange(wanderA);
patrolRouteList.AddRange(patrolPoints);
footpathNodeList.AddRange(fpNodes);
//Join the two maps together
generatedMap = this.JoinMaps(generatedMap, childMap, childMaplet.x.Value, childMaplet.y.Value);
}
}
else
{
if (Fits(planningMap, childMapletBlueprint, childMaplet.Position == DRObjects.LocalMapGeneratorObjects.Enums.PositionAffinity.SIDES, childMaplet.FirstFit, childMaplet.Padding, out x, out y, out newMap))
{
//it fits, generate it - <3 Recursion
Actor[] childActors = null;
MapletActorWanderArea[] wanderA = null;
MapletPatrolPoint[] patrolPoints = null;
MapletFootpathNode[] fpNodes = null;
MapBlock[,] childMap = this.GenerateMap(tileID, wallID.Value, childMaplet.Maplet, childMaplet.Position == DRObjects.LocalMapGeneratorObjects.Enums.PositionAffinity.SIDES, actorType, owner, out childActors, out wanderA, out patrolPoints, out fpNodes);
//Add the child actors
actorList.AddRange(childActors);
//Update any actors's locations should they have any
foreach (var actor in childActors)
{
if (actor.MissionStack.Count() > 0)
{
var wander = actor.MissionStack.Peek() as WanderMission;
if (wander != null)
{
wander.WanderPoint.X += x;
wander.WanderPoint.Y += y;
wander.WanderRectangle = new Rectangle(wander.WanderRectangle.X + x, wander.WanderRectangle.Y + y, wander.WanderRectangle.Width, wander.WanderRectangle.Height);
}
}
}
//Update any wander areas too
foreach (var area in wanderA)
{
area.WanderRect = new Rectangle(area.WanderRect.X + x, area.WanderRect.Y + y, area.WanderRect.Width, area.WanderRect.Height);
area.WanderPoint.X += x;
area.WanderPoint.Y += y;
}
//and patrol routes
foreach (var point in patrolPoints)
{
point.Point.X += x;
point.Point.Y += y;
}
foreach (var n in fpNodes)
{
n.Point.X += x;
n.Point.Y += y;
}
//And add them
wanderAreas.AddRange(wanderA);
patrolRouteList.AddRange(patrolPoints);
footpathNodeList.AddRange(fpNodes);
//Join the two maps together
generatedMap = this.JoinMaps(generatedMap, childMap, x, y);
}
}
}
}
}
//Step 2: Put the items into the map
//Lets list places we can put it in
List<MapBlock> candidateBlocks = new List<MapBlock>();
for (int x = 0; x < planningMap.GetLength(0); x++)
{
for (int y = 0; y < planningMap.GetLength(1); y++)
{
if (planningMap[x, y] == PlanningMapItemType.FREE)
{
candidateBlocks.Add(generatedMap[x, y]);
}
}
}
List<MapBlock> edgeBlocks = new List<MapBlock>();
//Lets also get the edge mapblocks - for those who prefer being on the edge
for (int x = 0; x < planningMap.GetLength(0); x++)
{
if (!maplet.Walled)
{
if (planningMap[x, 0] == PlanningMapItemType.FREE)
{
edgeBlocks.Add(generatedMap[x, 0]);
}
if (planningMap[x, planningMap.GetLength(1) - 1] == PlanningMapItemType.FREE)
{
edgeBlocks.Add(generatedMap[x, planningMap.GetLength(1) - 1]);
}
}
else
{
if (planningMap[x, 1] == PlanningMapItemType.FREE)
{
edgeBlocks.Add(generatedMap[x, 1]);
}
if (planningMap[x, planningMap.GetLength(1) - 2] == PlanningMapItemType.FREE)
{
edgeBlocks.Add(generatedMap[x, planningMap.GetLength(1) - 2]);
}
}
}
//Doing the y parts
for (int y = 0; y < planningMap.GetLength(1); y++)
{
if (!maplet.Walled)
{
if (planningMap[0, y] == PlanningMapItemType.FREE)
{
edgeBlocks.Add(generatedMap[0, y]);
}
if (planningMap[planningMap.GetLength(0) - 1, y] == PlanningMapItemType.FREE)
{
edgeBlocks.Add(generatedMap[planningMap.GetLength(0) - 1, y]);
}
}
else
{
if (planningMap[1, y] == PlanningMapItemType.FREE)
{
edgeBlocks.Add(generatedMap[1, y]);
}
if (planningMap[planningMap.GetLength(0) - 2, y] == PlanningMapItemType.FREE)
{
edgeBlocks.Add(generatedMap[planningMap.GetLength(0) - 2, y]);
}
}
}
//go through the maplet contents
//Get the smallest x and y coordinate in the candidate blocks so we can use it for fixed things
int smallestX = -1;
int smallestY = -1;
try
{
smallestX = candidateBlocks.Select(b => b.Tile.Coordinate.X).Min();
smallestY = candidateBlocks.Select(b => b.Tile.Coordinate.Y).Min();
}
catch
{
//No space :(
}
foreach (MapletContents contents in maplet.MapletContents.Where(mc => mc is MapletContentsItem || mc is MapletContentsItemTag || mc is MapletContentsItemSpecial).OrderByDescending(mc => mc.ProbabilityPercentage))
{
//We'll see if we even put this at all
MapItem itemPlaced = null;
for (int i = 0; i < contents.MaxAmount; i++)
{
//lets see what the probability of putting it in is
if ((random.NextDouble() * 100) <= contents.ProbabilityPercentage)
{
//Put it in
if (contents is MapletContentsItem)
{
MapletContentsItem mapletContent = (MapletContentsItem)contents;
itemPlaced = factory.CreateItem(mapletContent.ItemCategory, mapletContent.ItemID);
}
else
if (contents is MapletContentsItemTag)
{
MapletContentsItemTag mapletContent = (MapletContentsItemTag)contents;
int tempInt;
itemPlaced = factory.CreateItem(mapletContent.Category, mapletContent.Tag, out tempInt);
//I CHANGED THIS
itemPlaced.OwnedBy = mapletContent.Factions;
}
else
if (contents is MapletContentsItemSpecial)
{
//what type is it
switch ((contents as MapletContentsItemSpecial).Type)
{
case "StairsUp":
itemPlaced = new DungeonStairs(true); break;
case "StairsDown":
itemPlaced = new DungeonStairs(false); break;
case "SummoningCircle":
itemPlaced = new SummoningCircle(); break;
case "TreasureChest":
itemPlaced = new TreasureChest(); break;
case "Altar":
itemPlaced = new Altar(); break;
case "WishingWell":
itemPlaced = new WishingWell(); break;
case "Potion":
var potionType = (PotionType[]) Enum.GetValues(typeof(PotionType));
var potion = potionType.GetRandom();
itemPlaced = new Potion(potion);
break;
default:
throw new NotImplementedException("No code for " + (contents as MapletContentsItemSpecial).Type + " can be found");
}
}
if (candidateBlocks.Count != 0)
{
//Lets decide where to put it
if (contents.Position == DRObjects.LocalMapGeneratorObjects.Enums.PositionAffinity.SIDES && edgeBlocks.Count != 0)
{
//pick a place at random and add it to the maplet
int position = random.Next(edgeBlocks.Count);
edgeBlocks[position].PutItemOnBlock(itemPlaced);
if (!contents.AllowItemsOnTop)
{
//remove it from both
candidateBlocks.Remove(edgeBlocks[position]);
edgeBlocks.RemoveAt(position);
}
}
if (contents.Position == DRObjects.LocalMapGeneratorObjects.Enums.PositionAffinity.MIDDLE && candidateBlocks.Except(edgeBlocks).Count() != 0)
{
//pick a place at random and add it to the maplet
int position = random.Next(candidateBlocks.Except(edgeBlocks).Count());
MapBlock block = candidateBlocks.Except(edgeBlocks).ToArray()[position];
block.PutItemOnBlock(itemPlaced);
if (!contents.AllowItemsOnTop)
{
//remove it from both
candidateBlocks.Remove(block);
edgeBlocks.Remove(block);
}
}
if (contents.Position == DRObjects.LocalMapGeneratorObjects.Enums.PositionAffinity.ANYWHERE)
{
//pick a place at random and add it to the maplet
int position = random.Next(candidateBlocks.Count);
candidateBlocks[position].PutItemOnBlock(itemPlaced);
if (!contents.AllowItemsOnTop)
{
//remove it from both
edgeBlocks.Remove(candidateBlocks[position]);
candidateBlocks.RemoveAt(position);
}
}
if (contents.Position == DRObjects.LocalMapGeneratorObjects.Enums.PositionAffinity.FIXED)
{
//Fix it in a particular position.
MapCoordinate coordinate = new MapCoordinate(smallestX + contents.x.Value, smallestY + contents.y.Value, 0, DRObjects.Enums.MapType.LOCAL);
var selectedBlock = candidateBlocks.Where(cb => cb.Tile.Coordinate.Equals(coordinate)).FirstOrDefault();
if (selectedBlock != null)
{ //maybe someone put something there already
selectedBlock.PutItemOnBlock(itemPlaced);
}
if (!contents.AllowItemsOnTop)
{
//and remoev it from both
candidateBlocks.Remove(selectedBlock);
edgeBlocks.Remove(selectedBlock);
}
}
}
}
}
}
//Step 3: Stripe through the map except for the current maplet's walls - work out where the walls are, and for each wall segment, put a door in
#region Wall Segments
List<Line> wallSegments = new List<Line>();
for (int x = 1; x < planningMap.GetLength(0) - 1; x++)
{
//lets see if we find a wall Segment
Line wallSegment = null;
for (int y = 1; y < planningMap.GetLength(1) - 1; y++)
{
if (planningMap[x, y] == PlanningMapItemType.WALL)
{
//Three possibilities exist. Either this is the start of a wall segment
//Or this is a continuation of a wall segment
//Or this is the end of a wall segment
// -> Because there is an intersection
// -> Because there was an active wall segment and there is no wall in this one
if (wallSegment == null)
{
//Its a start
wallSegment = new Line(new MapCoordinate(x, y, 0, DRObjects.Enums.MapType.LOCAL), null);
}
else
{
//Continuation or end
//Check if there's an interesection
//Go up one and down one. If there is the maplet's walls there won't be a door - but then there'll be a double wall anyway which makes no sense
if (planningMap[x + 1, y] == PlanningMapItemType.WALL || planningMap[x - 1, y] == PlanningMapItemType.WALL)
{
//terminate the wall - and start a new one
wallSegment.End = new MapCoordinate(x, y, 0, DRObjects.Enums.MapType.LOCAL);
wallSegments.Add(wallSegment);
wallSegment = new Line(new MapCoordinate(x, y, 0, DRObjects.Enums.MapType.LOCAL), null);
}
else
{
//do nothing, its a continuation
}
}
}
else
{
//Mayhaps a line has stopped?
if (wallSegment != null)
{
//It has - lets terminate it
wallSegment.End = new MapCoordinate(x, y - 1, 0, DRObjects.Enums.MapType.LOCAL);
wallSegments.Add(wallSegment);
wallSegment = null;
}
}
}
//Check if there's an active line - maybe it reaches till the end of the maplet
if (wallSegment != null)
{
wallSegment.End = new MapCoordinate(x, (planningMap.GetLength(1) - 1), 0, DRObjects.Enums.MapType.LOCAL);
wallSegments.Add(wallSegment);
wallSegment = null;
}
}
//Now stripe in the other direction
for (int y = 1; y < planningMap.GetLength(1) - 1; y++)
{
//lets see if we find a wall Segment
Line wallSegment = null;
for (int x = 1; x < planningMap.GetLength(0) - 1; x++)
{
if (planningMap[x, y] == PlanningMapItemType.WALL)
{
//Three possibilities exist. Either this is the start of a wall segment
//Or this is a continuation of a wall segment
//Or this is the end of a wall segment
// -> Because there is an intersection
// -> Because there was an active wall segment and there is no wall in this one
if (wallSegment == null)
{
//Its a start
wallSegment = new Line(new MapCoordinate(x, y, 0, DRObjects.Enums.MapType.LOCAL), null);
}
else
{
//Continuation or end
//Check if there's an interesection
//Go up one and down one. If there is the maplet's walls there won't be a door - but then there'll be a double wall anyway which makes no sense
if (planningMap[x, y + 1] == PlanningMapItemType.WALL || planningMap[x, y - 1] == PlanningMapItemType.WALL)
{
//terminate the wall - and start a new one
wallSegment.End = new MapCoordinate(x, y, 0, DRObjects.Enums.MapType.LOCAL);
wallSegments.Add(wallSegment);
wallSegment = new Line(new MapCoordinate(x, y, 0, DRObjects.Enums.MapType.LOCAL), null);
}
else
{
//do nothing, its a continuation
}
}
}
else
{
//Mayhaps a line has stopped?
if (wallSegment != null)
{
//It has - lets terminate it
wallSegment.End = new MapCoordinate(x - 1, y, 0, DRObjects.Enums.MapType.LOCAL);
wallSegments.Add(wallSegment);
wallSegment = null;
}
}
}
//Check if there's an active line - maybe it reaches till the end of the maplet
if (wallSegment != null)
{
wallSegment.End = new MapCoordinate(planningMap.GetLength(0) - 1, y, 0, DRObjects.Enums.MapType.LOCAL);
wallSegments.Add(wallSegment);
wallSegment = null;
}
}
#endregion Wall Segments
#region Doors
//Get all wall segments larger than 0, and we can put a door there
foreach (Line segment in wallSegments.Where(ws => ws.Length() > 1))
{
//Put a door somewhere, as long as its not the start or end
//Oh and remove the wall
MapBlock block = null;
if (segment.Start.X == segment.End.X)
{
//Get the entirety of the segment
List<int> possibleYs = new List<int>();
int smallerY = Math.Min(segment.Start.Y, segment.End.Y);
int largerY = Math.Max(segment.Start.Y, segment.End.Y);
//Check in the real map whether the tile next to it is free for walking in
for (int y = smallerY + 1; y <= largerY; y++)
{
if (generatedMap[segment.Start.X - 1, y].MayContainItems && generatedMap[segment.Start.X + 1, y].MayContainItems)
{
possibleYs.Add(y);
}
}
//Now check whether there's a possible y, and pick a random one from it
if (possibleYs.Count != 0)
{
block = generatedMap[segment.Start.X, possibleYs[random.Next(possibleYs.Count - 1)]];
}
else
{
//nothing to do - take smallest
block = generatedMap[segment.Start.X, segment.Start.Y + 1];
}
}
else
{
List<int> possibleXs = new List<int>();
int smallerX = Math.Min(segment.Start.X, segment.End.X);
int largerX = Math.Max(segment.Start.X, segment.End.X);
//Check in the real map whether the tile next to it is free for walking in
for (int x = smallerX + 1; x <= largerX; x++)
{
if (generatedMap[x, segment.Start.Y - 1].MayContainItems && generatedMap[x, segment.Start.Y + 1].MayContainItems)
{
possibleXs.Add(x);
}
}
//Now check whether there's a possible x, and pick a random one from it
if (possibleXs.Count != 0)
{
block = generatedMap[possibleXs[random.Next(possibleXs.Count - 1)], segment.Start.Y];
}
else
{
//nothing to do - take the smallest one
block = generatedMap[segment.Start.X + 1, segment.Start.Y];
}
}
try
{
if (block != null)
{
block.RemoveTopItem();
int doorID = -1;
block.PutItemOnBlock(factory.CreateItem(DRObjects.Enums.Archetype.MUNDANEITEMS, "door", out doorID));
}
}
catch { }
}
#endregion
#region Enemies
//Now lets create enemies :)
foreach (var mc in maplet.MapletContents.Where(mc => mc.GetType().Equals(typeof(MapletActor))).OrderByDescending(o => o.ProbabilityPercentage))
{
var actor = mc as MapletActor;
for (int i = 0; i < actor.MaxAmount; i++)
{
//Check the random
if (random.Next(100) < actor.ProbabilityPercentage)
{
int actorID = 0;
string enemyType = actor.UseLocalType ? actorType : actor.EnemyType;
//For now set gear cost to 0
Actor newActor = ActorGeneration.CreateActor(enemyType, actor.EnemyTag, null, 10, 0, null, out actorID);
if (actor.VendorType.HasValue)
{
GenerateVendor(newActor, actor);
}
//Generate the map character
var mapCharacter = factory.CreateItem("enemies", actorID);
newActor.MapCharacter = mapCharacter;
if (!actor.Factions.HasFlag(owner))
{
//inactive character
newActor.MapCharacter.IsActive = false;
}
(mapCharacter as LocalCharacter).Actor = newActor;
//Lets position them randomly
for (int attempt = 0; attempt < 150; attempt++)
{
//Try 150 times
int x = random.Next(maplet.SizeX);
int y = random.Next(maplet.SizeY);
if (generatedMap[x, y].MayContainItems)
{
//Put it there
mapCharacter.Coordinate = new MapCoordinate(x, y, 0, MapType.LOCAL);
generatedMap[x, y].ForcePutItemOnBlock(mapCharacter);
actorList.Add(newActor);
//What mission does he have?
if (actor.EnemyMission == ActorMissionType.WANDER)
{
newActor.MissionStack.Push(new WanderMission()
{
LoiterPercentage = 80,
WanderPoint = new MapCoordinate(mapCharacter.Coordinate),
WanderRectangle = new Rectangle(0, 0, generatedMap.GetLength(0), generatedMap.GetLength(1))
});
}
break;
}
}
}
}
}
#endregion
#region Wander Areas
foreach (var mc in maplet.MapletContents.Where(mc => mc.GetType().Equals(typeof(MapletActorWanderArea))))
{
var wander = mc as MapletActorWanderArea;
//The area of this is going to be the entire maplet (so if we're in a submaplet, they'll wander in there - Awesome no ?)
wander.WanderRect = new Rectangle(0, 0, generatedMap.GetLength(0), generatedMap.GetLength(1));
//Pick the wander point to be the middle of the rectangle. If the point isn't valid we might have a problem
wander.WanderPoint = new MapCoordinate(generatedMap.GetLength(0) / 2, generatedMap.GetLength(1) / 2, 0, MapType.LOCAL);
MapletActorWanderArea clone = new MapletActorWanderArea();
clone.WanderPoint = new MapCoordinate(wander.WanderPoint);
clone.WanderRect = new Rectangle(wander.WanderRect.X, wander.WanderRect.Y, wander.WanderRect.Width, wander.WanderRect.Height);
clone.Profession = wander.Profession;
clone.OwnerFactions = wander.OwnerFactions;
wanderAreas.Add(clone);
}
wAreas = wanderAreas.ToArray();
#endregion
#region Patrol Points & Paths
foreach (var mc in maplet.MapletContents.Where(mc => mc.GetType().Equals(typeof(MapletPatrolPoint))))
{
var point = mc as MapletPatrolPoint;
//The point is going to be in the middle of the entire maplet
point.Point = new MapCoordinate(generatedMap.GetLength(0) / 2, generatedMap.GetLength(1) / 2, 0, MapType.LOCAL);
MapletPatrolPoint clone = new MapletPatrolPoint();
clone.Point = new MapCoordinate(point.Point);
clone.OwnerFactions = point.OwnerFactions;
clone.Profession = point.Profession;
clone.PointRadius = point.PointRadius;
patrolRouteList.Add(clone);
}
patrolRoutes = patrolRouteList.ToArray();
foreach (var n in maplet.MapletContents.Where(mc => mc.GetType().Equals(typeof(MapletFootpathNode))))
{
var node = n as MapletFootpathNode;
//Point is going to be in the middle of the entire maplet
node.Point = new MapCoordinate(generatedMap.GetLength(0) / 2, generatedMap.GetLength(1) / 2, 0, MapType.LOCAL);
//Better create a new one
MapletFootpathNode clone = new MapletFootpathNode();
clone.Point = new MapCoordinate(node.Point);
clone.IsPrimary = node.IsPrimary;
footpathNodeList.Add(clone);
}
footpathNodes = footpathNodeList.ToArray();
#endregion
#region Aniamls
//Now lets create enemies :)
foreach (var mc in maplet.MapletContents.Where(mc => mc.GetType().Equals(typeof(MapletHerd))).OrderByDescending(o => o.ProbabilityPercentage))
{
var herd = mc as MapletHerd;
for (int i = 0; i < herd.MaxAmount; i++)
{
//Check the random
if (random.Next(100) < herd.ProbabilityPercentage)
{
var herds = ActorGeneration.CreateAnimalHerds(herd.Biome, herd.Domesticated, herd.HerdTag, 1);
foreach (var animalHerd in herds)
{
foreach (var animal in animalHerd)
{
//Position them on the map
for (int attempt = 0; attempt < 150; attempt++)
{
//Try 150 times
int x = random.Next(maplet.SizeX);
int y = random.Next(maplet.SizeY);
if (generatedMap[x, y].MayContainItems)
{
//Put it there
animal.MapCharacter.Coordinate = new MapCoordinate(x, y, 0, MapType.LOCAL);
generatedMap[x, y].ForcePutItemOnBlock(animal.MapCharacter);
actorList.Add(animal);
//Wander around does he have?
animal.MissionStack.Push(new WanderMission()
{
LoiterPercentage = 80,
WanderPoint = new MapCoordinate(animal.MapCharacter.Coordinate),
WanderRectangle = new Rectangle(0, 0, generatedMap.GetLength(0), generatedMap.GetLength(1))
});
break;
}
}
}
}
}
}
}
#endregion
actors = actorList.ToArray();
#region Ownership
//Go through all map items - If they're not valid for this particular owner, make them inactive.
foreach (var mapBlock in generatedMap)
{
foreach (var item in mapBlock.GetItems())
{
if (!item.OwnedBy.HasFlag(owner))
{
item.IsActive = false;
}
}
}
#endregion
//we're done
return generatedMap;
}
/// <summary>
/// Part 1 - Generate the base map
/// </summary>
/// <param name="level"></param>
/// <param name="percentCovered"></param>
/// <returns></returns>
private static MapBlock[,] GenerateBaseMap(int level, int percentCovered, out List<Rectangle> rectangles, out int tileID)
{
MapBlock[,] map = new MapBlock[SIZE, SIZE];
ItemFactory.ItemFactory fact = new ItemFactory.ItemFactory();
//Put the tiles
tileID = -1;
var dummy = fact.CreateItem("tiles", "cave", out tileID);
for (int x = 0; x < SIZE; x++)
{
for (int y = 0; y < SIZE; y++)
{
map[x, y] = new MapBlock(); //Start with air :)
map[x, y].Tile = new Air();
map[x, y].Tile.Coordinate = (new MapCoordinate(x, y, 0, MapType.LOCAL));
}
}
//Now we need to drop particular shapes on the map, with a minimum area of MINIMUM_AREA until we reach a particular percentage covered
int totalCovered = 0;
//Or until we run out of attempts
int attempts = 0;
rectangles = new List<Rectangle>();
while (totalCovered < AREA && attempts < 50)
{
attempts++;
//Pick a random spot to drop it in
Random random = GameState.Random;
Point p = new Point(random.Next(SIZE), random.Next(SIZE));
//From this point, draw a rectangle with a random size from Edge to Edge
Rectangle rect = new Rectangle(p.X, p.Y, random.Next(MINIMUM_EDGE, MAXIMUM_EDGE), random.Next(MINIMUM_EDGE, MAXIMUM_EDGE));
//Does it have a valid area? Is it within the current map
if ((rect.Width * rect.Height) >= MINIMUM_AREA && rect.Right < SIZE && rect.Bottom < SIZE)
{
//Does it intersect or is contained within another rectangle ?
//(This will not preclude two rectangles next to each other, as long as they don't intersect)
if (rectangles.Any(r => r.Intersects(rect) || r.Contains(rect) || rect.Contains(r)))
{
//invalid
continue;
}
rectangles.Add(rect); //Valid
totalCovered += (rect.Width * rect.Height);
attempts = 0;
}
else
{
//invalid
continue;
}
}
//Now we should have a number of rectangles, let's turn those into actual rooms
foreach (var rect in rectangles)
{
for (int x = 0; x < rect.Width; x++)
{
for (int y = 0; y < rect.Height; y++)
{
MapCoordinate coord = new MapCoordinate(rect.X + x, rect.Y + y, 0, MapType.LOCAL);
MapBlock b = map[coord.X, coord.Y];
b.Tile = fact.CreateItem("tiles", tileID);
b.Tile.Coordinate = coord;
}
}
}
int pathTile = -1;
dummy = fact.CreateItem("tiles", "pavement", out pathTile);
//Let's connect each room with each other room
for (int i = 0; i < rectangles.Count; i++)
{
Rectangle curr = rectangles[i];
Rectangle next = i == rectangles.Count - 1 ? rectangles[0] : rectangles[i + 1]; //Next rectangle is either the one in the list, or the first one
PathfinderInterface.Nodes = GeneratePathfindingMapConnector(map);
//Path from the center of the rectangles
var path = PathfinderInterface.GetPath(new MapCoordinate(curr.Center.X, curr.Center.Y, 0, MapType.LOCAL), new MapCoordinate(next.Center.Y, next.Center.Y, 0, MapType.LOCAL));
if (path != null)
{
//Path it!
foreach (var p in path)
{
if (!map[p.X, p.Y].MayContainItems)
{
MapCoordinate coord = new MapCoordinate(p.X, p.Y, 0, MapType.LOCAL);
MapBlock b = map[coord.X, coord.Y];
b.Tile = fact.CreateItem("tiles", pathTile);
b.Tile.Coordinate = coord;
}
}
}
}
//Now we can go through the blocks and put walls around the border
int borderID = -1;
dummy = fact.CreateItem("mundaneitems", "dungeon wall", out borderID);
for (int x = 0; x < SIZE; x++)
{
for (int y = 0; y < SIZE; y++)
{
MapBlock current = map[x, y];
if (!current.MayContainItems)
{
//Are we near one which can contain items?
if (GetBlocksAroundPoint(map, current.Tile.Coordinate, 1).Any(b => b.MayContainItems))
{
//Yep - put a wall there
current.ForcePutItemOnBlock(fact.CreateItem("mundaneitems", borderID));
}
}
}
}
return map;
}
/// <summary>
/// Returns true if this block is a distance of 1 away from any of the blocks in this region
/// </summary>
/// <param name="block"></param>
/// <returns></returns>
public bool IsNeighbour(MapBlock block)
{
return Blocks.Any(b => Math.Abs(b.Tile.Coordinate - block.Tile.Coordinate) <= 1);
}
/// <summary>
/// Generates a pathfinding map for connecting
/// </summary>
/// <param name="map"></param>
/// <returns></returns>
private static byte[,] GeneratePathfindingMapConnector(MapBlock[,] map)
{
//Generate a byte map of x and y
int squareSize = PathfinderInterface.CeilToPower2(Math.Max(map.GetLength(0), map.GetLength(1)));
byte[,] pf = new byte[squareSize, squareSize];
for (int i = 0; i < map.GetLength(0); i++)
{
for (int j = 0; j < map.GetLength(1); j++)
{
if (i < map.GetLength(0) - 1 && j < map.GetLength(1) - 1)
{
//To promote path reuse - if it contains a path give it a weight of 1, otherwise 5, otherwise 50
if (map[i, j] == null)
{
pf[i, j] = Byte.MaxValue;
}
else if (map[i, j].MayContainItems)
{
if (map[i, j].Tile.InternalName.ToLower() == "pavement")
{
pf[i, j] = (byte)1;
}
else
{
pf[i, j] = (byte)5;
}
}
else
{
pf[i, j] = (byte)50;
}
}
else
{
//Put in the largest possible weight
pf[i, j] = Byte.MaxValue;
}
}
}
return pf;
}
/// <summary>
/// Generates a pathfinding map from the mapl pushed in
/// </summary>
/// <returns></returns>
private static byte[,] GeneratePathfindingMap(MapBlock[,] map)
{
//Generate a byte map of x and y
int squareSize = PathfinderInterface.CeilToPower2(Math.Max(map.GetLength(0), map.GetLength(1)));
byte[,] pf = new byte[squareSize, squareSize];
for (int i = 0; i < map.GetLength(0); i++)
{
for (int j = 0; j < map.GetLength(1); j++)
{
if (i < map.GetLength(0) - 1 && j < map.GetLength(1) - 1)
{
//Copyable - if it may contain items, put a weight of 1, otherwise an essagerated one. Also consider who the owners are. If it's owned by someone in particular then ignore it
pf[i, j] = map[i, j] != null ? map[i, j].MayContainItems || map[i,j].GetTopItem().OwnedBy != (OwningFactions.ABANDONED | OwningFactions.BANDITS | OwningFactions.HUMANS | OwningFactions.ORCS | OwningFactions.UNDEAD )
? (byte)1 : Byte.MaxValue : Byte.MaxValue;
}
else
{
//Put in the largest possible weight
pf[i, j] = Byte.MaxValue;
}
}
}
return pf;
}
/// <summary>
/// Add a block to a local map
/// </summary>
/// <param name="block"></param>
public void AddToLocalMap(MapBlock block)
{
//Does it belong on the local map?
MapCoordinate coord = block.Tile.Coordinate;
try
{
//Check whether the block is within the bounds of the map
if (block.Tile.Coordinate.X < this.localGameMap.GetLength(0) && block.Tile.Coordinate.X >= 0)
{
if (block.Tile.Coordinate.Y < this.localGameMap.GetLength(1) && block.Tile.Coordinate.Y >= 0)
{
if (block.Tile.Coordinate.Z < this.localGameMap.GetLength(2) && block.Tile.Coordinate.Z >= 0)
{
//write it
localGameMap[block.Tile.Coordinate.X, block.Tile.Coordinate.Y, block.Tile.Coordinate.Z] = block;
}
}
}
}
catch
{
//Error
throw new Exception("The map already has data at the coordinate " + block.Tile.Coordinate);
}
}