public static void Fill(PatternTable table)
{
var madePatterns = HandMadePatternList()
.SelectMany(p => AddReverse(p.Pattern)
.SelectMany(pStr => DifferentAnchor(pStr))
.Select(pStr => new PatternScore {
Pattern = pStr, Score = p.Score
}))
.Select(p =>
{
var(before, after) = p.Pattern.ToPatternPair();
return(new { Before = before, After = after, p.Score });
})
.ToList();
foreach (var(before, after) in table.EveryPattern())
{
foreach (var madePattern in madePatterns)
{
if (before.IsPrefix(madePattern.Before) && after.IsPrefix(madePattern.After))
{
table[before, after] = madePattern.Score;
break;
}
}
}
}
private object TargetFrameworkName_Parser(
string name,
PatternTable table)
{
object obj = null;
// Check for replacements
if (table != null)
{
if (table.TryLookup(PropertyNames.TargetFrameworkMoniker, name, out obj))
{
return(obj);
}
}
// Check the cache for an exact match
if (!string.IsNullOrEmpty(name))
{
NuGetFramework cachedResult;
if (!_frameworkCache.TryGetValue(name, out cachedResult))
{
// Parse and add the framework to the cache
cachedResult = TargetFrameworkName_ParserCore(name);
_frameworkCache.Add(name, cachedResult);
}
return(cachedResult);
}
// Let the framework parser handle null/empty and create the error message.
return(TargetFrameworkName_ParserCore(name));
}
public TokenSegment(string token, char delimiter, bool matchOnly, PatternTable table)
{
_token = token;
_delimiter = delimiter;
_matchOnly = matchOnly;
_table = table;
}
public GraphicsEditor()
{
InitializeComponent();
CompositeTable = ProjectController.GraphicsManager.BuildPatternTable(0);
CmbPalettes.DisplayMember = "Name";
foreach (var p in ProjectController.PaletteManager.Palettes)
{
CmbPalettes.Items.Add(p);
}
CmbGraphics1.DisplayMember = CmbGraphics2.DisplayMember = CmbGraphics3.DisplayMember = CmbGraphics4.DisplayMember = "Name";
foreach (var g in ProjectController.GraphicsManager.GraphicsInfo)
{
CmbGraphics1.Items.Add(g);
CmbGraphics2.Items.Add(g);
CmbGraphics3.Items.Add(g);
CmbGraphics4.Items.Add(g);
}
CmbGraphics1.SelectedIndex = 0;
CmbGraphics2.SelectedIndex = 1;
CmbGraphics3.SelectedIndex = 2;
CmbGraphics4.SelectedIndex = 3;
CmbPalettes.SelectedIndex = 0;
PtvTileSelector.CurrentTable = CompositeTable;
SelectionMode = SelectionMode.Quarter;
PslView.SelectedIndexChanged += new EventHandler(PslView_SelectedIndexChanged);
PslView.SelectedOffsetChanged += new EventHandler(PslView_SelectedOffsetChanged);
PtvTileSelector.SelectionChanged += new EventHandler(PtvTileSelector_SelectionChanged);
PtvTileSelector.UpdateSelection();
}
private PatternTable TestPatternTable()
{
PatternTable patternTable = new PatternTable();
patternTable["_ o o _ * _ _ _ _ _".ToPatternPair()] = 1;
patternTable["_ o * _ o _ _ _".ToPatternPair()] = 2;
return(patternTable);
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.PropertyField(serializedObject.FindProperty("rowNo"), true);
//EditorGUILayout.PropertyField (serializedObject.FindProperty ("pattern"), true);
PatternTable.Show(serializedObject.FindProperty("pattern"));
serializedObject.ApplyModifiedProperties();
}
public Evaluator(Board board, PatternTable patternTable)
{
this.board = board;
this.PatternTable = patternTable;
this.patternExtractor = new CachedPatternExtractor(new PatternExtractor(board));
this.ownScoreCalc = new CachedScoreCalculator(board.FlattenedSize);
InitializeScore();
this.board.ChessPlaced += Board_ChessPlaced;
this.board.ChessTakenBack += Board_ChessTakenBack;
}
public void PatternTable_LookupWhenEmpty()
{
// Arrange
var table = new PatternTable();
// Act
object obj;
var b = table.TryLookup("tfm", "any", out obj);
// Assert
Assert.False(b);
Assert.Null(obj);
}
public override PatternTable LoadBgPatternTable_ChrUsage(bool linear, int bankIndex)
{
var oBgPatterns = MMC3PatternOffsets.GetChrBank(bankIndex);
PatternTable pt = new PatternTable(linear);
try {
pt.BeginWrite();
pt.LoadTiles(Level.Rom.data, oBgPatterns, 0, 0x100);
return(pt);
} finally {
pt.EndWrite();
}
}
public override PatternTable LoadSpritePatternsTable(bool linear)
{
var oSpritePatterns = EnhancedPatternOffsets.GetSprBank(Level.Index);
PatternTable pt = new PatternTable(linear);
try {
pt.BeginWrite();
pt.LoadTiles(Level.Rom.data, oSpritePatterns, 0, 0x100);
return(pt);
} finally {
pt.EndWrite();
}
}
private static object CodeLanguage_Parser(string name, PatternTable table)
{
if (table != null)
{
object val;
if (table.TryLookup(PropertyNames.CodeLanguage, name, out val))
{
return(val);
}
}
// Code language values must be alpha numeric.
return(name.All(c => char.IsLetterOrDigit(c)) ? name : null);
}
public LayoutEditor()
{
InitializeComponent();
CmbLayouts.DisplayMember = CmbGraphics1.DisplayMember = CmbGraphics2.DisplayMember = CmbPalettes.DisplayMember = CmbDefinitions.DisplayMember = "Name";
foreach (var g in ProjectController.GraphicsManager.GraphicsInfo)
{
CmbGraphics1.Items.Add(g);
CmbGraphics2.Items.Add(g);
}
foreach (var p in ProjectController.PaletteManager.Palettes)
{
CmbPalettes.Items.Add(p);
}
foreach (var l in ProjectController.LevelManager.LevelTypes)
{
CmbDefinitions.Items.Add(l);
}
foreach (var l in ProjectController.LayoutManager.BlockLayouts)
{
if (!l.IsDefault)
{
CmbLayouts.Items.Add(l);
}
}
if (CmbLayouts.SelectedIndex != -1)
{
CmbLayouts.SelectedIndex = 0;
}
CurrentTable = ProjectController.GraphicsManager.BuildPatternTable(0);
BlsFrom.CurrentTable = CurrentTable;
BlsTo.CurrentTable = CurrentTable;
BlsFrom.BlockLayout = ProjectController.LayoutManager.BlockLayouts[0];
CmbGraphics1.SelectedIndex = 8;
CmbGraphics2.SelectedIndex = 0x64;
CmbPalettes.SelectedIndex = 0;
CmbDefinitions.SelectedIndex = 0;
BlsFrom.SpecialPalette = BlsTo.SpecialPalette = ProjectController.SpecialManager.SpecialPalette;
BlsFrom.SpecialTable = BlsTo.SpecialTable = ProjectController.SpecialManager.SpecialTable;
ProjectController.LayoutManager.LayoutAdded += new EventHandler <TEventArgs <BlockLayout> >(LayoutManager_LayoutAdded);
ProjectController.LayoutManager.LayoutRemoved += new EventHandler <TEventArgs <BlockLayout> >(LayoutManager_LayoutRemoved);
}
public void SearchToScore()
{
PatternTable patternTable = new PatternTable();
patternTable["_ _ o o o * _ _ _ _".ToPatternPair()] = 100;
AlphaBetaEngine engine = new AlphaBetaEngine(patternTable);
var board = new Player[10, 10];
board[2, 2] = board[3, 2] = board[5, 2] = Player.Own;
engine.SetBoard(board);
engine.HasTimeLimit = false;
var score = engine.AlphaBetaSearch(2);
Assert.Equal(100, score);
}
public Map16Editor()
{
InitializeComponent();
CmbGraphics1.DisplayMember = CmbGraphics2.DisplayMember = CmbPalettes.DisplayMember = CmbDefinitions.DisplayMember = "Name";
foreach (var g in ProjectController.GraphicsManager.GraphicsInfo)
{
CmbGraphics1.Items.Add(g);
CmbGraphics2.Items.Add(g);
}
foreach (var p in ProjectController.PaletteManager.Palettes)
{
CmbPalettes.Items.Add(p);
}
foreach (var l in ProjectController.LevelManager.LevelTypes)
{
CmbDefinitions.Items.Add(l);
}
CurrentTable = ProjectController.GraphicsManager.BuildPatternTable(0);
PtvTable.CurrentTable = CurrentTable;
BlsBlocks.CurrentTable = CurrentTable;
BlsBlocks.BlockLayout = ProjectController.LayoutManager.BlockLayouts[0];
BlvCurrent.CurrentTable = CurrentTable;
BlsBlocks.SpecialTable = ProjectController.SpecialManager.SpecialTable;
BlsBlocks.SpecialPalette = ProjectController.SpecialManager.SpecialPalette;
CmbGraphics1.SelectedIndex = 8;
CmbGraphics2.SelectedIndex = 0x64;
CmbPalettes.SelectedIndex = 0;
CmbDefinitions.SelectedIndex = 0;
BlsBlocks.SelectionChanged += new EventHandler <TEventArgs <MouseButtons> >(BlsBlocks_SelectionChanged);
BlsBlocks.SelectedIndex = 0;
solidityMap[0] = BlockProperty.Background;
solidityMap[1] = BlockProperty.Foreground;
solidityMap[2] = BlockProperty.Water;
solidityMap[3] = BlockProperty.Water | BlockProperty.Foreground;
solidityMap[4] = BlockProperty.SolidTop;
solidityMap[5] = BlockProperty.SolidBottom;
solidityMap[6] = BlockProperty.SolidAll;
solidityMap[7] = BlockProperty.CoinBlock;
for (int i = 0; i < 16; i++)
{
SpecialTypes.Add(((BlockProperty)(0xF0 | i)).ToString());
}
}
public void Fill()
{
PatternTable patternTable = new PatternTable();
HandMadePatternScore.Fill(patternTable);
void assert(int score, string pattern)
{
Assert.Equal(score, patternTable[pattern.ToPatternPair()]);
}
assert(HandMadePatternScore.WinScore, "o * o o o");
assert(HandMadePatternScore.WinScore, "o * o o o o");
assert(HandMadePatternScore.WinScore, "o * o o o _");
assert(HandMadePatternScore.FourScore, "_ o * o o _ _");
assert(HandMadePatternScore.FourScore, "_ o * o o _ o");
}
public BackgroundHandler(
IPPUMemoryMap ppuMemoryMap,
PPURegisters registers,
PPUInternalRegisters internalRegisters,
ScrollHandler scrollHandler,
PaletteHandler paletteHandler)
{
this.registers = registers;
this.ppuMemoryMap = ppuMemoryMap;
this.scrollHandler = scrollHandler;
this.paletteHandler = paletteHandler;
this.internalRegisters = internalRegisters;
foreach (var patternTable in this.ppuMemoryMap.GetMemorySegments <PatternTable>())
{
if (patternTable.Range.Min == 0x0000)
{
this.patternTable0 = patternTable;
}
else if (patternTable.Range.Min == 0x1000)
{
this.patternTable1 = patternTable;
}
}
foreach (var nameTable in this.ppuMemoryMap.GetMemorySegments <Nametable>())
{
if (nameTable.Range.Min == 0x2000)
{
this.nameTable0 = nameTable;
}
else if (nameTable.Range.Min == 0x2400)
{
this.nameTable1 = nameTable;
}
else if (nameTable.Range.Min == 0x2800)
{
this.nameTable2 = nameTable;
}
else if (nameTable.Range.Min == 0x2C00)
{
this.nameTable3 = nameTable;
}
}
}
public void PatternTable_LookupWithMiss()
{
// Arrange
var data = new List <PatternTableEntry>()
{
new PatternTableEntry("tfm", "dotnet", NuGetFramework.Parse("dotnet"))
};
var table = new PatternTable(data);
// Act
object obj;
var b = table.TryLookup("tfm", "any", out obj);
// Assert
Assert.False(b);
Assert.Null(obj);
}
public void PatternTable_LookupWithValue()
{
// Arrange
var dotnet = NuGetFramework.Parse("dotnet");
var data = new List <PatternTableEntry>()
{
new PatternTableEntry("tfm", "any", dotnet)
};
var table = new PatternTable(data);
// Act
object obj;
var b = table.TryLookup("tfm", "any", out obj);
// Assert
Assert.True(b);
Assert.Equal(dotnet, obj);
}
private static object Locale_Parser(string name, PatternTable table)
{
if (table != null)
{
object val;
if (table.TryLookup(PropertyNames.Locale, name, out val))
{
return(val);
}
}
if (name.Length == 2)
{
return(name);
}
else if (name.Length >= 4 && name[2] == '-')
{
return(name);
}
return(null);
}
private PatternTable LoadBgPatternTable_ChrAnimation(bool linear, ChrAnimationTable anim)
{
//PatternTable pt = new PatternTable(linear);
var frame = anim.Frames[0];
var bank0Offset = Level.Rom.Format.ChrRomOffset + Mmc3.ChrBankSize * frame.Bank0;
var bank1Offset = Level.Rom.Format.ChrRomOffset + Mmc3.ChrBankSize * frame.Bank1;
var bank2Offset = Level.Rom.Format.ChrRomOffset + Mmc3.ChrBankSize * frame.Bank2;
var bank3Offset = Level.Rom.Format.ChrRomOffset + Mmc3.ChrBankSize * frame.Bank3;
PatternTable pt = new PatternTable(linear);
try {
pt.BeginWrite();
pt.LoadTiles(Level.Rom.data, bank0Offset, 0x00, 0x40);
pt.LoadTiles(Level.Rom.data, bank1Offset, 0x40, 0x40);
pt.LoadTiles(Level.Rom.data, bank2Offset, 0x80, 0x40);
pt.LoadTiles(Level.Rom.data, bank3Offset, 0xC0, 0x40);
return(pt);
} finally {
pt.EndWrite();
}
}
/// <summary>
/// Renders a screen using GDI+.
/// </summary>
/// <param name="g">GDI+ graphic destination.</param>
/// <remarks>This overload performs very poorly due to GDI+'s very poor
/// optimizations for paletted bitmaps. This overload also does not render
/// enemies in the screen, mainly because of the palette limitations of GDI+.</remarks>
public void Render(Graphics g)
{
Rectangle source = new Rectangle(0, 0, 8, 8);
Rectangle dest = source;
PatternTable patTable = Level.Patterns;
Bitmap patterns = patTable.PatternImage;
//patTable.Palette = palettes[colors[0, 0]];
for (int x = 0; x < 32; x++)
{
dest.Y = 0;
for (int y = 0; y < 32; y++)
{
//patTable.Palette = palettes[colors[x, y]];
source.X = tiles[x, y] * 8;
g.DrawImage(patterns, dest, source, GraphicsUnit.Pixel);
dest.Y += 8;
//if(x == 0 && y == 8) System.Windows.Forms.MessageBox.Show(tiles[x, y].ToString());
}
dest.X += 8;
}
}
public PatternExpression(PatternDefinition pattern)
{
_table = pattern.Table;
_defaults = pattern.Defaults.ToDictionary(p => p.Key, p => p.Value);
Initialize(pattern.Pattern);
}
/// <summary>
/// BGイメージ情報をネーム・属性・パターンテーブルから作成
/// </summary>
/// <param name="p"></param>
/// <param name="t"></param>
/// <returns></returns>
private IEnumerable<byte> ExpandBgImage(Tuple<NameTable, AttributeTable> p, PatternTable t)
{
//var bgImage = p.Item1
// .Select((x, i) =>
// {
// var point = PointAbstract.ConvertPoint<NameTablePoint>(i);
// var high2Bit = p.Item2.GetAttributeHigh2Bit(point);
// return new { Data = x, HighBitData = high2Bit };
// })
// .SelectMany(x => t[x.Data].Select(xx => (byte)((x.HighBitData << 2) | xx)))
// .Buffer(64)
// .Buffer(32)
// .SelectMany(x =>
// {
// var data = x.ToArray();
// byte[] buf = new byte[64 * 32];
// for (int line = 0; line < 8; line++)
// {
// for (int i = 0; i < 32; i++)
// {
// for (int j = 0; j < 8; j++)
// {
// var index = i * 8 + j + (line * 256);
// buf[index] = data[i][j + (line * 8)];
// }
// }
// }
// return buf;
// //return x.SelectMany(xx => xx.Select((xxx, i) => new { Data = xxx, PointY = i / 8 }))
// // .GroupBy(xx => xx.PointY)
// // .SelectMany(xx => xx.Select(xxx => xxx.Data));
// })
// .ToArray();
var bgImage = p.Item1
.Select((x, i) =>
{
var pointTuple = NameTablePoint.ConvertPoint(i, NameTable.MaxWidth);
var point = new NameTablePoint(pointTuple.Item1, pointTuple.Item2);
var high2Bit = p.Item2.GetAttributeHigh2Bit(point);
return new { Data = x, HighBitData = high2Bit };
})
.Select(x => t[x.Data].Select(xx => (byte)((x.HighBitData << 2) | xx)).ToArray())
.Buffer(32)
.SelectMany(x =>
{
var data = x;
byte[] buf = new byte[64 * 32];
for (int line = 0; line < 8; line++)
{
for (int i = 0; i < 32; i++)
{
for (int j = 0; j < 8; j++)
{
var index = i * 8 + j + (line * 256);
buf[index] = data[i][j + (line * 8)];
}
}
}
return buf;
// forループの処理に置き換えたのでコメントアウト
//return x.SelectMany(xx => xx.Select((xxx, i) => new { Data = xxx, PointY = i / 8 }))
// .GroupBy(xx => xx.PointY)
// .SelectMany(xx => xx.Select(xxx => xxx.Data));
});
return bgImage;
}
private static object AllowEmptyFolderParser(string s, PatternTable table)
{
// Accept "_._" as a pseudo-assembly
return(PackagingCoreConstants.EmptyFolder.Equals(s, StringComparison.Ordinal) ? s : null);
}
public override PatternTable LoadSpritePatternsTable(bool linear)
{
return(PatternTable.LoadNewTableForExpandedRom(linear, PatternTableType.sprite, Level));
}
public override PatternTable LoadBgPatternTable(bool linear)
{
return(PatternTable.LoadNewTableForExpandedRom(linear, PatternTableType.background, Level));
}
public void AcceptAttributePatternTable(PatternTable patternTable, PrintContext parameter)
{
parameter.WriteLine("Pattern Table: {0} ({1} by {2})", patternTable.Index, patternTable.Width, patternTable.Height);
}
public PatternExpression(PatternDefinition pattern)
{
_table = pattern.Table;
_defaults = pattern.Defaults;
Initialize(pattern.Pattern);
}
public virtual void AcceptAttributePatternTable(PatternTable patternTable, T parameter)
{
// intentionally left blank
}
