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;
}
}
private static void AddItems(MapBlock _block, Random _rnd)
{
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.IsPassable)
{
var point = new Point(x, y);
var any = _block.Objects.Where(_tuple => _tuple.Item2 == point).Select(_tuple => _tuple.Item1);
var thing = EssenceHelper.GetRandomFakedItem(_rnd);
if (any.Any(_thing => !(_thing is Item)))
{
continue;
}
_block.AddEssence(thing, point);
}
}
}
private void CreateDoor(MapBlock _mapBlock, ETerrains _floor, IEnumerable <Point> _borderPoints)
{
var doorCoords = Room.RoomRectangle.Center;
var prevPoint = doorCoords;
var direction = World.Rnd.GetRandomDirection();
var delta = direction.GetDelta();
while (!_borderPoints.Contains(doorCoords))
{
prevPoint = doorCoords;
doorCoords += delta;
}
var nextPoint = doorCoords + delta;
var borders = direction.GetBorders().ToArray();
DoorWorldCoords = _mapBlock.ToWorldCoords(doorCoords);
OutDoorWorldCoords = new[] { nextPoint + borders[0].Key, nextPoint, nextPoint + borders[1].Key }.Select(_mapBlock.ToWorldCoords).ToArray();
InDoorWorldCoords = new[] { prevPoint + borders[0].Key, prevPoint, prevPoint + borders[1].Key }.Select(_mapBlock.ToWorldCoords).ToArray();
_mapBlock.Map[doorCoords.X, doorCoords.Y] = _floor;
var doors = EssenceHelper.GetAllThings <ClosedDoor>().ToArray();
_mapBlock.AddEssence(doors[0], doorCoords);
}
protected Creature(EALNouns _name, WorldLayer _layer, int _speed)
: base(_name, EssenceHelper.GetMaterial <BodyMaterial>())
{
Speed = _speed;
Luck = 25;
m_layer = _layer;
}
public void RemoteActivation(Creature _creature, Point _worldCoords)
{
var creatureLiveCell = _creature[0, 0];
var delta = _worldCoords - creatureLiveCell.WorldCoords;
var myCell = _creature[delta.X, delta.Y];
switch (Effect)
{
case EMagicPlateEffect.RANDOM_MONSTER_APPEAR:
if (myCell.Creature == null)
{
var monster = (AbstractMonster)EssenceHelper.GetRandomFakedCreature <AbstractMonster>(World.Rnd).Essence.Clone(_creature);
monster.Behaviour = EMonsterBehaviour.IDLE;
World.TheWorld.CreatureManager.AddCreature(monster, myCell.WorldCoords, myCell.LiveCoords);
MessageManager.SendMessage(this, new SoundTextMessage("послышался всплеск"));
}
else
{
MessageManager.SendMessage(this, new SoundTextMessage("послышался треск"));
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private static void AddCreatures(MapBlock _block, Random _rnd)
{
var itmcnt = 2 + _rnd.Next(_rnd.Next(2));
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.IsPassable)
{
var point = new Point(x, y);
if (_block.Creatures.Values.Contains(point))
{
continue;
}
var creature = (AbstractMonster)EssenceHelper.GetRandomFakedCreature <AbstractMonster>(World.Rnd).Essence.Clone(World.TheWorld.Avatar);
if (creature.Is <Stair>() && (x == Constants.MAP_BLOCK_SIZE - 1 || y == Constants.MAP_BLOCK_SIZE - 1))
{
continue;
}
if (!_block.Rooms.Any(_room => _room.RoomRectangle.Contains(point) && _room.IsConnected))
{
continue;
}
_block.CreaturesAdd(creature, point);
}
}
}
protected override IEnumerable <Item> GenerateItems(Creature _creature)
{
var cnt = _creature.GetLuckRandom * 5.0;
for (var i = 0; i < cnt; i++)
{
yield return(EssenceHelper.GetRandomFakedItem(World.Rnd));
}
}
public void Шмотки()
{
var stack = EssenceHelper.GetRandomFakedItem <StackOfAmmo>(World.Rnd);
Avatar[1, 0].AddItem(stack);
var s = (StackOfAmmo)Avatar[1, 0].ResolveFakeItem(Avatar, stack);
s.Count = 10;
SendKey(ConsoleKey.NumPad6);
SendKey(ConsoleKey.OemComma);
SendKey(ConsoleKey.NumPad5);
}
public override void AddStair(WorldLayer _enterFromLayer, Point _worldCoords, Stair _stair)
{
var blockId = BaseMapBlock.GetBlockId(EnterCoords);
var inBlockCoords = BaseMapBlock.GetInBlockCoords(EnterCoords);
var block = this[blockId];
if (_stair is StairUp)
{
block.AddEssence(new StairDown(_enterFromLayer, EssenceHelper.GetFirstFoundedMaterial <MineralMaterial>()), inBlockCoords);
}
else
{
block.AddEssence(new StairUp(_enterFromLayer, EssenceHelper.GetFirstFoundedMaterial <MineralMaterial>()), inBlockCoords);
}
}
public override void DrawContent()
{
var strings = new List <string> {
"[z|Esc] - " + EALConst.EXIT.GetString()
};
m_messages.DrawLine(JoinCommandCaptions(strings), FColor.White, 0, 0, EAlignment.LEFT);
var liveCell = World.TheWorld.Avatar[TargetPoint];
if (liveCell.IsSeenBefore)
{
ETileset.TARGETING.GetTile(0).Draw(TargetPoint + m_avatarScreenPoint, FColor.Gold);
var lighted = liveCell.FinalLighted;
var list = new List <Noun> {
liveCell.Terrain.AsNoun()
};
if (lighted.Lightness() > World.TheWorld.Avatar.GeoInfo.Layer.FogLightness)
{
ETileset.TARGETING.GetTile(0).Draw(TargetPoint + m_avatarScreenPoint, FColor.Green);
if (liveCell.Creature != null)
{
list.Add(liveCell.Creature.Name);
}
if (liveCell.Thing != null)
{
list.Add(liveCell.Thing.Name);
}
var items = liveCell.Items.ToArray();
foreach (var item in items)
{
list.Add(EssenceHelper.GetName(item, World.TheWorld.Avatar));
}
m_messages.DrawLine(EALSentence.THERE_ARE.GetString(list.ToArray()), FColor.Gray, 1, 0, EAlignment.LEFT);
}
else
{
m_messages.DrawLine(EALSentence.THERE_ARE_WERE.GetString(list.ToArray()), FColor.Gray, 1, 0, EAlignment.LEFT);
}
}
else
{
ETileset.TARGETING.GetTile(0).Draw(TargetPoint + m_avatarScreenPoint, FColor.Red);
}
}
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 override void Fill(MapBlock _block, WorldLayer _layer)
{
var rnd = new Random(_block.RandomSeed);
InDoorWorldCoords = Room.RoomRectangle.Inflate(-1, -1).BorderPoints.ToArray();
OutDoorWorldCoords = Room.RoomRectangle.BorderPoints.ToArray();
MapBlockHelper.Fill(_block, rnd, _layer, _layer.DefaultEmptySpaces, Room.AreaRectangle);
var graves = EssenceHelper.GetAllThings <Grave>().ToArray();
foreach (var point in Room.RoomRectangle.AllPoints)
{
if (rnd.Next(4) == 0 && !InDoorWorldCoords.Contains(point))
{
_block.AddEssence(graves.RandomItem(rnd), point);
}
}
}
public Avatar(WorldLayer _surface)
: base(EALNouns.Avatar, _surface, 100, EIntellectGrades.INT)
{
if (!Constants.GAME_MODE)
{
return;
}
Tactic = ETactics.NORMAL;
Luck = 6;
AddRole(new AvatarRole());
Equip(EEquipmentPlaces.RIGHT_HAND, EssenceHelper.GetRandomFakedItem <AbstractMeleeWeapon>(World.Rnd));
Equip(EEquipmentPlaces.MISSILE_WEAPON, EssenceHelper.GetFirstFoundedItem <AbstractRangedWeapon>());
Tactic = ETactics.BERSERK;
var ammo = EssenceHelper.GetRandomFakedItem <StackOfAmmo>(World.Rnd).Essence.Clone(this) as StackOfAmmo;
ammo.Count = 100;
Equip(EEquipmentPlaces.MISSILES, ammo);
Equip(EEquipmentPlaces.TOOL, EssenceHelper.GetFirstFoundedItem <AbstractTorch>());
}
protected override MapBlock GenerateBlock(Point _blockId)
{
var block = new MapBlock(_blockId);
var rnd = new Random(block.RandomSeed);
MapBlockHelper.Clear(block, rnd, this, DefaultEmptySpaces);
const int v = Constants.MAP_BLOCK_SIZE / 2 - 2;
for (var i = 0; i < v; ++i)
{
block.Map[i, 0] = ETerrains.STONE_WALL;
block.Map[0, i] = ETerrains.STONE_WALL;
block.Map[Constants.MAP_BLOCK_SIZE - 1 - i, 0] = ETerrains.STONE_WALL;
block.Map[0, Constants.MAP_BLOCK_SIZE - 1 - i] = ETerrains.STONE_WALL;
}
block.AddEssence(new OnWallTorch(new LightSource(8, new FColor(5f, 1f, 0, 0)), EDirections.DOWN, EssenceHelper.GetFirstFoundedMaterial <WoodMaterial>()), new Point(1, 1));
block.AddEssence(new OnWallTorch(new LightSource(8, new FColor(1f, 0f, 1f, 0f)), EDirections.UP, EssenceHelper.GetFirstFoundedMaterial <WoodMaterial>()), new Point(Constants.MAP_BLOCK_SIZE - 1, Constants.MAP_BLOCK_SIZE - 1));
block.AddEssence(new OnWallTorch(new LightSource(8, new FColor(1f, 0f, 0f, 1f)), EDirections.RIGHT, EssenceHelper.GetFirstFoundedMaterial <WoodMaterial>()), new Point(Constants.MAP_BLOCK_SIZE - 1, 1));
block.AddEssence(new OnWallTorch(new LightSource(8, new FColor(1f, 1f, 0f, 1f)), EDirections.LEFT, EssenceHelper.GetFirstFoundedMaterial <WoodMaterial>()), new Point(1, Constants.MAP_BLOCK_SIZE - 1));
{
var x = rnd.Next(Constants.MAP_BLOCK_SIZE);
var y = rnd.Next(Constants.MAP_BLOCK_SIZE);
block.CreaturesAdd(EssenceHelper.GetFirstFoundedCreature <AbstractMonster>(), new Point(x, y));
}
block.Map[9, 9] = ETerrains.RED_BRICK_WALL;
block.Map[10, 9] = ETerrains.RED_BRICK_WINDOW;
block.Map[11, 9] = ETerrains.RED_BRICK_WALL;
block.Map[11, 10] = ETerrains.RED_BRICK_WINDOW;
block.Map[9, 10] = ETerrains.RED_BRICK_WINDOW;
block.Map[9, 11] = ETerrains.RED_BRICK_WALL;
block.AddEssence(new ClosedDoor(null), new Point(10, 11));
block.Map[11, 11] = ETerrains.RED_BRICK_WALL;
//block.AddLightSource(new Point(10, 10), new LightSource(18, new FColor(53f, 0f, 1f, 1f)));
return(block);
}
public TreeMazeDungeonLayer(Point _enterCoords, Random _rnd)
: base(_enterCoords)
{
var enterBlock = BaseMapBlock.GetBlockId(_enterCoords);
var size = _rnd.Next(5) + _rnd.Next(5) + 5;
var center = new Point(size, size) / 2;
var map = new EMapBlockTypes[size, size];
var list = LayerHelper.GetRandomPoints(center, _rnd, map, size, EMapBlockTypes.GROUND, EMapBlockTypes.NONE);
var blockIds = list.Distinct().Select(_point => _point - center + enterBlock).ToArray();
foreach (var blockId in blockIds)
{
BaseMapBlock block;
if (!m_mazeBlocks.TryGetValue(blockId, out block))
{
block = new BaseMapBlock(blockId);
}
if (BaseMapBlock.GetBlockId(EnterCoords) == blockId)
{
GenerateInternal(block, new[] { BaseMapBlock.GetInBlockCoords(EnterCoords) });
}
else
{
GenerateInternal(block);
}
m_mazeBlocks[block.BlockId] = block;
}
var connectionPoints = new List <ConnectionPoint>();
foreach (var block in blockIds.Select(_blockId => m_mazeBlocks[_blockId]))
{
var rnd = new Random(block.RandomSeed);
foreach (var room in block.Rooms)
{
connectionPoints.AddRange(AddConnectionPoints(block, room, rnd));
}
}
LinkRooms(connectionPoints);
foreach (var mapBlock in m_mazeBlocks.Values)
{
foreach (var room in mapBlock.Rooms.Where(_room => _room.IsConnected))
{
var border = room.RoomRectangle.BorderPoints.ToArray();
foreach (var point in border)
{
if (_rnd.NextDouble() > 0.7)
{
var dir = EDirections.NONE;
if (point.X > 0 && TerrainAttribute.GetAttribute(mapBlock.Map[point.X - 1, point.Y]).IsNotPassable)
{
dir = EDirections.RIGHT;
}
else if (point.X < Constants.MAP_BLOCK_SIZE - 1 && TerrainAttribute.GetAttribute(mapBlock.Map[point.X + 1, point.Y]).IsNotPassable)
{
dir = EDirections.LEFT;
}
else if (point.Y > 0 && TerrainAttribute.GetAttribute(mapBlock.Map[point.X, point.Y - 1]).IsNotPassable)
{
dir = EDirections.DOWN;
}
else if (point.Y < Constants.MAP_BLOCK_SIZE - 1 && TerrainAttribute.GetAttribute(mapBlock.Map[point.X, point.Y + 1]).IsNotPassable)
{
dir = EDirections.UP;
}
if (dir == EDirections.NONE)
{
continue;
}
var fColor = new FColor(3f, (float)_rnd.NextDouble(), (float)_rnd.NextDouble(), (float)_rnd.NextDouble());
mapBlock.AddEssence(new OnWallTorch(new LightSource(_rnd.Next(4) + 3, fColor), dir, EssenceHelper.GetFirstFoundedMaterial <WoodMaterial>()), point);
break;
}
}
}
}
}
public virtual void Fill(MapBlock _block, WorldLayer _layer)
{
var mapBlock = _block;
var roomRectangle = Room.RoomRectangle;
var wall = Walls.ToArray().RandomItem(World.Rnd);
var floor = Floors.ToArray().RandomItem(World.Rnd);
foreach (var point in roomRectangle.AllPoints)
{
mapBlock.Map[point.X, point.Y] = floor;
}
var borderPoints = roomRectangle.BorderPoints.ToArray();
var cornerPoints = roomRectangle.CornerPoints;
var i = 0;
foreach (var point in borderPoints)
{
if (cornerPoints.Contains(point))
{
mapBlock.Map[point.X, point.Y] = wall.Item1;
}
else
{
if (i++ % 3 == 0)
{
mapBlock.Map[point.X, point.Y] = wall.Item2;
}
else
{
mapBlock.Map[point.X, point.Y] = wall.Item1;
}
}
}
CreateDoor(mapBlock, floor, borderPoints);
mapBlock.AddEssence(new IndoorLight(new LightSource(10, new FColor(3f, 1f, 1f, 0.5f)), EssenceHelper.GetFirstFoundedMaterial <MetalMaterial>()), roomRectangle.Inflate(-1, -1).Random(World.Rnd));
}
protected override MapBlock GenerateBlock(Point _blockId)
{
var block = SurfaceBlockGenerator.GenerateBlock(_blockId, this);
var rnd = new Random(block.RandomSeed);
var baseType = GetBlockType(_blockId);
if (baseType == EMapBlockTypes.CITY)
{
City.GenerateCityBlock(block, rnd, this);
}
var trees = EssenceHelper.GetAllThings <Tree>().ToArray();
var shrubs = EssenceHelper.GetAllThings <Shrub>().ToArray();
foreach (var point in new Rct(0, 0, Constants.MAP_BLOCK_SIZE, Constants.MAP_BLOCK_SIZE).AllPoints)
{
switch (block.Map[point.X, point.Y])
{
case ETerrains.FOREST:
switch (rnd.Next(10))
{
case 0:
case 1:
block.AddEssence(shrubs.RandomItem(rnd), point);
break;
case 2:
case 3:
case 4:
block.AddEssence(trees.RandomItem(rnd), point);
break;
}
break;
case ETerrains.SHRUBS:
switch (rnd.Next(7))
{
case 0:
case 1:
case 2:
case 3:
block.AddEssence(shrubs.RandomItem(rnd), point);
break;
case 4:
block.AddEssence(trees.RandomItem(rnd), point);
break;
}
break;
}
}
if (Constants.WORLD_MAP_SIZE == 1)
{
TestSurfaceGenerator1x1.Fill(block, Constants.WORLD_SEED, baseType);
}
else
{
GenerateRandomItems(rnd, block);
}
return(block);
}
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);
}
