/// <summary>
/// Calculates attacks for the specified piece.
/// </summary>
/// <param name="pieceBitboard">The bitboard with set bit at piece position.</param>
/// <param name="excludedFields">The bitboard with excluded fields from attacks calculating.</param>
/// <param name="opt">The generator parameters.</param>
private static void CalculateAttacks(ulong pieceBitboard, ulong excludedFields, GeneratorParameters opt)
{
if ((opt.Mode & GeneratorMode.CalculateAttacks) == 0)
{
return;
}
var pieceIndex = BitOperations.GetBitIndex(pieceBitboard);
var blockersToRemove = opt.Bitboard.Pieces[FastArray.GetPieceIndex(opt.FriendlyColor, PieceType.Bishop)] |
opt.Bitboard.Pieces[FastArray.GetPieceIndex(opt.FriendlyColor, PieceType.Queen)];
var allPiecesOccupancy = opt.OccupancySummary & ~blockersToRemove;
var pattern = MagicContainer.GetBishopAttacks(pieceIndex, allPiecesOccupancy);
pattern = CalculatePawnBlockers(pieceIndex, pattern, opt);
pattern ^= excludedFields;
while (pattern != 0)
{
var patternLSB = BitOperations.GetLSB(pattern);
pattern = BitOperations.PopLSB(pattern);
var patternIndex = BitOperations.GetBitIndex(patternLSB);
opt.Bitboard.Attacks[patternIndex] |= pieceBitboard;
opt.Bitboard.AttacksSummary[(int)opt.FriendlyColor] |= patternLSB;
}
}
/// <summary>
/// Entry point.
/// </summary>
/// <param name="args">Program arguments.</param>
public static void Main(string[] args)
{
var generator = new Generator();
Console.WriteLine("Proxima b opening book generator");
Console.WriteLine();
PatternsContainer.Init();
MagicContainer.Init();
var openingBook = generator.GetOpeningBook("Book/input.book");
SaveOpeningBook("Book/output.book", openingBook);
}
/// <summary>
/// Calculates moves for the specified piece.
/// </summary>
/// <param name="pieceType">The piece type.</param>
/// <param name="pieceBitboard">The bitboard with set bit at piece position.</param>
/// <param name="opt">The generator parameters.</param>
/// <returns>The bitboard with available moves for the specified piece.</returns>
private static ulong CalculateMoves(PieceType pieceType, ulong pieceBitboard, GeneratorParameters opt)
{
if ((opt.Mode & GeneratorMode.CalculateMoves) == 0)
{
return(0);
}
var pieceIndex = BitOperations.GetBitIndex(pieceBitboard);
var piecePosition = BitPositionConverter.ToPosition(pieceIndex);
var pattern = MagicContainer.GetRookAttacks(pieceIndex, opt.OccupancySummary);
pattern &= ~opt.FriendlyOccupancy;
if (opt.QuiescenceSearch)
{
pattern &= opt.EnemyOccupancy;
}
var excludeFromAttacks = pattern;
while (pattern != 0)
{
var patternLSB = BitOperations.GetLSB(pattern);
pattern = BitOperations.PopLSB(pattern);
var patternIndex = BitOperations.GetBitIndex(patternLSB);
var to = BitPositionConverter.ToPosition(patternIndex);
if ((patternLSB & opt.EnemyOccupancy) == 0)
{
opt.Bitboard.Moves.AddLast(new QuietMove(piecePosition, to, pieceType, opt.FriendlyColor));
}
else
{
opt.Bitboard.Moves.AddLast(new KillMove(piecePosition, to, pieceType, opt.FriendlyColor));
}
if ((opt.Mode & GeneratorMode.CalculateAttacks) != 0)
{
opt.Bitboard.Attacks[patternIndex] |= pieceBitboard;
opt.Bitboard.AttacksSummary[(int)opt.FriendlyColor] |= patternLSB;
}
}
return(excludeFromAttacks);
}
public static void OpenMagicInventory(InventoryGui inventoryGui, int width, int height)
{
Player player = Player.m_localPlayer;
if ((bool)player)
{
ZNetView nview = (ZNetView)typeof(Player).GetField("m_nview", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy).GetValue(player);
long playerID = nview.GetZDO().GetLong("playerID");
MagicContainer magicContainer = player.gameObject.GetComponent <MagicInventory.MagicContainer>();
bool newContainer = magicContainer == null;
if (newContainer)
{
magicContainer = player.gameObject.AddComponent <MagicInventory.MagicContainer>();
}
MagicInventory.AllContainers.TryGetValue(playerID, out var magicInventory);
if (magicInventory == null)
{
magicInventory = MagicInventory.Create(playerID);
}
magicInventory.Width = width;
magicInventory.Height = height;
typeof(Container).GetField("m_inventory", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy).SetValue(magicContainer, magicInventory);
if (newContainer)
{
Action onContainerChanged = () => typeof(Container).GetMethod("OnContainerChanged", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(magicContainer, null);
magicInventory.m_onChanged = (Action)Delegate.Combine(magicInventory.m_onChanged, onContainerChanged);
}
inventoryGui.Show(magicContainer);
}
}
/// <summary>
/// Initializes chess engine (loads patterns, magic keys, sets converters, ...).
/// Must be called first, otherwise chess engine will crash :(
/// </summary>
public static void Init()
{
PatternsContainer.Init();
MagicContainer.Init();
OpeningBookContainer.Init();
}
public void PopulateExpandoObjectAsAProperty()
{
var container = new MagicContainer();
container.Name = "Container1";
container.Library = new ExpandoObject();
container.Library.Name = "1Items";
container.Library.ArticleArray = new Article[] { new Article("Article1") };
container.Library.ArticleList = new List<Article>() { new Article("Article1") };
container.Library.ArticleIList = new List<Article>() { new Article("Article1") };
container.Library.ArticleCollection = new ArticleCollection() { new Article("Article1") };
container.Library.StringArray = new[] { "Article1" };
Assert.AreEqual(1, container.Library.ArticleArray.Length);
Assert.AreEqual(1, container.Library.ArticleCollection.Count);
Assert.AreEqual(1, container.Library.ArticleList.Count);
Assert.AreEqual(1, container.Library.ArticleList.Count);
Assert.AreEqual(1, container.Library.StringArray.Length);
var settings = new JsonSerializerSettings { };
string json = JsonConvert.SerializeObject(container, Formatting.Indented, settings);
MagicContainer result = new MagicContainer();
JsonConvert.PopulateObject(json, result, settings);
Assert.AreEqual(result.Library.Name, container.Library.Name);
Assert.AreEqual(1, result.Library.ArticleArray.Length);
Assert.AreEqual(1, result.Library.ArticleCollection.Count);
Assert.AreEqual(1, result.Library.ArticleList.Count);
Assert.AreEqual(1, result.Library.ArticleList.Count);
Assert.AreEqual(1, result.Library.StringArray.Length);
}
