public static void Fill(MapBlock _block, int _worldSeed, EMapBlockTypes _baseType)
{
if (_baseType == EMapBlockTypes.NONE) return;
switch (Constants.WORLD_SEED)
{
case 0:
World.TheWorld.Avatar.GeoInfo.Layer.Ambient = FColor.Empty;
_block.Map[16, 16] = ETerrains.GRAY_BRICK_WALL;
_block.AddEssence(new IndoorLight(new LightSource(32, new FColor(1f, 1f, 0f, 0f)), EssenceHelper.GetFirstFoundedMaterial<MetalMaterial>()), new Point(10, 17));
_block.AddEssence(new IndoorLight(new LightSource(32, new FColor(1f, 0f, 1f, 0f)), EssenceHelper.GetFirstFoundedMaterial<MetalMaterial>()), new Point(22, 22));
_block.AddEssence(new IndoorLight(new LightSource(32, new FColor(1f, 0f, 0f, 1f)), EssenceHelper.GetFirstFoundedMaterial<MetalMaterial>()), new Point(22, 10));
break;
case 1:
_block.AddEssence(EssenceHelper.GetFirstFoundedThing<ClosedDoor>(), new Point(2, 1));
_block.AddEssence(EssenceHelper.GetFirstFoundedThing<ClosedDoor>(), new Point(1, 2));
_block.AddEssence(EssenceHelper.GetRandomFakedItem<AbstractWeapon>(World.Rnd), new Point(4, 1));
_block.AddEssence(EssenceHelper.GetRandomFakedItem<AbstractWeapon>(World.Rnd), new Point(3, 2));
_block.AddEssence(EssenceHelper.GetRandomFakedItem<Ring>(World.Rnd), new Point(5, 5));
_block.AddEssence(EssenceHelper.GetRandomFakedItem<StackOfAmmo>(World.Rnd), new Point(5, 5));
break;
case 2:
_block.AddEssence(new MagicPlate(EssenceHelper.GetFirstFoundedMaterial<MetalMaterial>(), 0, EMagicPlateEffect.RANDOM_MONSTER_APPEAR), new Point(10, 10));
_block.AddEssence(new Button(EssenceHelper.GetFirstFoundedMaterial<MetalMaterial>(), 0), new Point(1, 1));
break;
}
}
public void SetMapCell(MapBlock _mapBlock, Point _inBlockCoords, float _rnd, Point _onLiveMapCoords, LiveMap _liveMap)
{
ResetCached();
Rnd = _rnd;
m_items.Clear();
Thing = null;
InBlockCoords = _inBlockCoords;
m_mapBlock = _mapBlock;
m_seenMask = ((UInt32)1) << InBlockCoords.X;
Terrain = _mapBlock.Map[_inBlockCoords.X, _inBlockCoords.Y];
TerrainAttribute = TerrainAttribute.GetAttribute(Terrain);
IsSeenBefore = (_mapBlock.SeenCells[_inBlockCoords.Y] & m_seenMask) != 0;
OnLiveMapCoords = _onLiveMapCoords;
ClearTemp();
}
protected override MapBlock GenerateBlock(Point _blockId)
{
var block = new MapBlock(_blockId);
block.Clear(World.Rnd, this, DefaultEmptySpaces);
if (_blockId.Y == 0 && _blockId.X == 0)
{
//block.Fill(World.Rnd, this, DefaultEmptySpaces, new Rct(0, 0, Constants.MAP_BLOCK_SIZE, 13));
block.AddEssence(new IndoorLight(new LightSource(38, new FColor(1f, 1f, 1f, 1f)), EssenceHelper.GetFirstFoundedMaterial<MetalMaterial>()), new Point(2, 4));
block.Map[1, 0] = ETerrains.STONE_WALL;
block.Map[1, 1] = ETerrains.STONE_WALL;
block.Map[1, 2] = ETerrains.STONE_WALL;
block.Map[1, 3] = ETerrains.STONE_WALL;
block.Map[1, 4] = ETerrains.STONE_WALL;
block.Map[1, 5] = ETerrains.STONE_WALL;
block.Map[1, 6] = ETerrains.STONE_WALL;
//block.Map[3, 1] = ETerrains.STONE_WALL;
//block.Map[3, 2] = ETerrains.YELLOW_BRICK_WINDOW;
//block.AddEssence(new IndoorLight(new LightSource(18, new FColor(1f, 1f, 1f, 0f)), EssenceHelper.GetFirstFoundedMaterial<MetalMaterial>()), new Point(10, 10));
//block.AddEssence(new IndoorLight(new LightSource(18, new FColor(1f, 0f, 1f, 0f)), EssenceHelper.GetFirstFoundedMaterial<MetalMaterial>()), new Point(15, 0));
//block.Map[1, 2] = ETerrains.STONE_WALL;
//block.Map[2, 2] = ETerrains.STONE_WALL;
//block.Map[3, 2] = ETerrains.STONE_WALL;
//block.Map[0, 3] = ETerrains.STONE_WALL;
//block.Map[0, 4] = ETerrains.STONE_WALL;
//block.Map[0, 5] = ETerrains.STONE_WALL;
}
else
{
//block.Clear(World.Rnd, this, DefaultWalls);
}
return block;
}
public void SetMapBlock(MapBlock _mapBlock)
{
MapBlock = _mapBlock;
Fill();
}
public void SetMapBlock(MapBlock _mapBlock)
{
MapBlock = _mapBlock;
Fill();
}
private static void GenerateRandomItems(Random _rnd, MapBlock _block)
{
var itmcnt = 20 + _rnd.Next(_rnd.Next(20));
for (var i = 0; i < itmcnt; ++i)
{
var x = _rnd.Next(Constants.MAP_BLOCK_SIZE);
var y = _rnd.Next(Constants.MAP_BLOCK_SIZE);
var attr = TerrainAttribute.GetAttribute(_block.Map[x, y]);
if (attr.IsNotPassable) continue;
var point = new Point(x, y);
var thing = World.Rnd.Next(2) == 0 ? EssenceHelper.GetFakedThing(_rnd) : EssenceHelper.GetRandomFakedItem(_rnd);
if (thing.Is<Stair>())
{
if (x == Constants.MAP_BLOCK_SIZE - 1 || y == Constants.MAP_BLOCK_SIZE - 1)
{
continue;
}
}
var any = _block.Objects.Where(_tuple => _tuple.Item2 == point).Select(_tuple => _tuple.Item1);
if (thing is Item)
{
if (any.Any(_thing => !(_thing is Item)))
{
continue;
}
}
else if (any.Any())
{
continue;
}
_block.AddEssence(thing, point);
}
}
public static MapBlock GenerateBlock(Point _blockId, Surface _surface)
{
var block = new MapBlock(_blockId);
var baseType = _surface.GetBlockType(_blockId);
if (baseType == EMapBlockTypes.NONE)
{
return block;
}
var rnd = new Random(block.RandomSeed);
var pm = new EMapBlockTypes[Constants.MAP_BLOCK_SIZE, Constants.MAP_BLOCK_SIZE];
var points = Constants.MAP_BLOCK_SIZE * Constants.MAP_BLOCK_SIZE;
var toAdd = new List<EMapBlockTypes> { baseType, baseType, baseType };
#region размытие границ с соседними блоками
foreach (var dir in Util.AllDirections)
{
Point from;
Point to;
switch (dir)
{
case EDirections.UP:
from = Point.Zero;
to = new Point(Constants.MAP_BLOCK_SIZE - 2, 0);
break;
case EDirections.DOWN:
from = new Point(1, Constants.MAP_BLOCK_SIZE - 1);
to = new Point(Constants.MAP_BLOCK_SIZE - 1, Constants.MAP_BLOCK_SIZE - 1);
break;
case EDirections.LEFT:
from = new Point(0, Constants.MAP_BLOCK_SIZE - 1);
to = new Point(0, 1);
break;
case EDirections.RIGHT:
from = new Point(Constants.MAP_BLOCK_SIZE - 1, 0);
to = new Point(Constants.MAP_BLOCK_SIZE - 1, Constants.MAP_BLOCK_SIZE - 2);
break;
default:
throw new ArgumentOutOfRangeException();
}
var delta = dir.GetDelta();
var nearestBlockId = _blockId + delta;
var type = _surface.GetBlockType(nearestBlockId);
if (type == EMapBlockTypes.NONE)
{
type = baseType;
}
toAdd.Add(type);
if (_surface.Blocks.ContainsKey(nearestBlockId))
{
var nearestBlock = _surface.Blocks[nearestBlockId];
foreach (var point in from.GetLineToPoints(to))
{
type =
TerrainAttribute.GetMapBlockType(
nearestBlock.Map[
(point.X + delta.X + Constants.MAP_BLOCK_SIZE) % Constants.MAP_BLOCK_SIZE,
(point.Y + delta.Y + Constants.MAP_BLOCK_SIZE) % Constants.MAP_BLOCK_SIZE]);
pm[point.X, point.Y] = type;
points--;
}
}
else
{
foreach (var point in from.GetLineToPoints(to))
{
pm[point.X, point.Y] = type;
points--;
}
}
}
#endregion
foreach (var t in toAdd)
{
var pnt = Point.Zero;
while (pm[pnt.X, pnt.Y] != EMapBlockTypes.NONE)
{
pnt = new Point(1 + rnd.Next(Constants.MAP_BLOCK_SIZE - 2), 1 + rnd.Next(Constants.MAP_BLOCK_SIZE - 2));
}
pm[pnt.X, pnt.Y] = t;
points--;
}
var dpoints = Util.AllDeltas;
while (points > 0)
{
foreach (var point in Point.AllBlockPoints)
{
var xy = pm[point.X, point.Y];
if (xy == 0) continue;
var dpoint = dpoints[rnd.Next(4)];
var x1 = point.X + dpoint.X;
if (x1 < 0 || x1 == Constants.MAP_BLOCK_SIZE) continue;
var y1 = point.Y + dpoint.Y;
if (y1 < 0 || y1 == Constants.MAP_BLOCK_SIZE) continue;
var xy1 = pm[x1, y1];
if (xy1 == 0)
{
pm[x1, y1] = xy;
points--;
}
}
}
#region заполнение карты блока
foreach (var pnt in new Rct(0, 0, Constants.MAP_BLOCK_SIZE, Constants.MAP_BLOCK_SIZE).AllPoints)
{
ETerrains tr;
switch (pm[pnt.X, pnt.Y])
{
case EMapBlockTypes.NONE:
continue;
case EMapBlockTypes.GROUND:
tr = ETerrains.GRASS;
break;
case EMapBlockTypes.FOREST:
tr = ETerrains.FOREST;
break;
case EMapBlockTypes.SEA:
tr = ETerrains.SEA;
break;
case EMapBlockTypes.DEEP_SEA:
tr = ETerrains.DEEP_SEA;
break;
case EMapBlockTypes.FRESH_WATER:
tr = ETerrains.FRESH_WATER;
break;
case EMapBlockTypes.DEEP_FRESH_WATER:
tr = ETerrains.DEEP_FRESH_WATER;
break;
case EMapBlockTypes.CITY:
tr = ETerrains.GROUND;
break;
case EMapBlockTypes.COAST:
tr = ETerrains.COAST;
break;
case EMapBlockTypes.LAKE_COAST:
tr = ETerrains.LAKE_COAST;
break;
case EMapBlockTypes.MOUNT:
tr = ETerrains.MOUNT;
break;
case EMapBlockTypes.SWAMP:
tr = ETerrains.SWAMP;
break;
case EMapBlockTypes.ETERNAL_SNOW:
tr = ETerrains.ETERNAL_SNOW;
break;
case EMapBlockTypes.SHRUBS:
tr = ETerrains.SHRUBS;
break;
default:
throw new ArgumentOutOfRangeException();
}
block.Map[pnt.X, pnt.Y] = tr;
}
#endregion
return block;
}
public override void GenerateCityBlock(MapBlock _block, Random _rnd, WorldLayer _layer)
{
var roadPoints = new List<Point>();
for (var i = 0; i < Constants.MAP_BLOCK_SIZE; ++i)
{
if (_rnd.Next(2) == 0) roadPoints.Add(new Point(0, i));
if (_rnd.Next(2) == 0) roadPoints.Add(new Point(1, i));
if (_rnd.Next(2) == 0) roadPoints.Add(new Point(i, 0));
if (_rnd.Next(2) == 0) roadPoints.Add(new Point(i, 1));
}
if (roadPoints.All(point => TerrainAttribute.GetAttribute(_block.Map[point.X, point.Y]).IsPassable))
{
foreach (var point in roadPoints)
{
_block.Map[point.X, point.Y] = ETerrains.ROAD;
}
}
var terrains = m_buildings.Where(_building => _building.BlockId == _block.BlockId).ToDictionary(_b => _b, _building => _building.Room.AreaRectangle.AllPoints.Select(_point => _block.Map[_point.X, _point.Y]).Distinct().ToArray());
foreach (var pair in terrains)
{
if (pair.Value.Any(_terrains => TerrainAttribute.GetAttribute(_terrains).IsNotPassable))
{
m_buildings.Remove(pair.Key);
}
}
var buildings = m_buildings.Where(_pair => _pair.BlockId == _block.BlockId).ToArray();
foreach (var building in buildings)
{
_block.AddRoom(building.Room);
building.Fill(_block, _layer);
var citizens = m_citizens.Where(_citizen => _citizen.Roles.OfType<AbstractCitizenRole>().First().Building == building).ToArray();
foreach (var citizen in citizens)
{
if (m_already.Contains(citizen))
{
throw new ApplicationException();
}
m_already.Add(citizen);
Tuple<ETileset, FColor> tuple = null;
foreach (var color in citizen.Roles.First().Colors)
{
tuple = Tuple.Create(citizen.Tileset, color);
if (!m_conf.Contains(tuple))
{
break;
}
}
if (tuple == null)
{
throw new ApplicationException();
}
m_conf.Add(tuple);
citizen.SetLerpColor(tuple.Item2);
_block.CreaturesAdd(citizen, building.Room.RoomRectangle.Center);
}
}
}
