private static void Main(string[] args)
{
if (args.Length == 0)
{
return;
}
if (!IOHelper.IsThisADirectory(args[0]))
{
return;
}
string directory = args[0];
RulesReader.FromFile("codeDefinition.json");
ExcludeWordsConfig excludeWordsConfig = ExcludeWordsConfig.FromJsonFile("excludeWords.json");
LinesOfCode.LineProcessComplete += LinesOfCode_LineProcessComplete;
FilesOfCode.FileFound += (f) => LinesOfCode.CountLinesOfCodeInFile(f);
FilesOfCode.Find(directory);
foreach (KeyValuePair <string, int> k in _occurrances
.Where(kvp => kvp.Value > THRESHOLD)
.Where(kvp => !excludeWordsConfig.ExcludeWords.Contains(kvp.Key))
.OrderByDescending(kvp => { return(kvp.Value); }))
{
Console.WriteLine(k.Value + ":\t" + k.Key);
}
#if DEBUG
Console.ReadLine();
#endif
}
public static void Main()
{
var lexerData = MakeLexer();
var rulesReader = new RulesReader();
var rules = rulesReader.GetRules();
var slr = new Slr(rules);
var table = slr.GetTable();
var grouping = table.reestr
.GroupBy(item => item.name)
.Select(qb => new ColumnOfReestr
{
name = qb.Key,
nextElement = qb.First().nextElement,
countOfArgs = qb.First().countOfArgs,
nameOfFunction = qb.First().nameOfFunction,
nameOfNewToken = qb.First().nameOfNewToken,
})
.ToList();
PrintRegistryTable(grouping);
MakeAndLaunchRunner(table.rules, table.resultTable, grouping, lexerData);
Console.ReadLine();
}
private void ConvertToMindMap()
{
Wnlib.WNCommon.path = "C:\\Program Files (x86)\\WordNet\\2.1\\dict\\";
rulesReader = new RulesReader(Application.StartupPath + "\\EngParserCFG\\Rules.txt");
Control.CheckForIllegalCrossThreadCalls = false;
Thread th = new Thread(new ThreadStart(BeginConversion));
//BeginConversion();
}
private void ConvertToMindMap()
{
//////////////////////////initialization ////////////////
Wnlib.WNCommon.path = "C:\\Program Files (x86)\\WordNet\\2.1\\dict\\";
rr = new RulesReader(Lexicon.EnglishParserCFG + "\\Rules.txt");
////////////////////////////////////////////////
BeginConversion();
}
public void ExcludeLinesWithComments()
{
RulesReader.FromFile("codeDefinition.json");
Assert.IsFalse(LinesOfCode.DoCount("//"));
Assert.IsFalse(LinesOfCode.DoCount(" //"));
Assert.IsFalse(LinesOfCode.DoCount("///"));
}
private void ConvertToMindMap()
{
//////////////////////////initialization ////////////////
Wnlib.WNCommon.path = "C:\\Program Files (x86)\\WordNet\\2.1\\dict\\";
//rr = new RulesReader("C:\\Rules.txt");
rr = new RulesReader(Application.StartupPath + "\\EngParserCFG\\Rules.txt");
////////////////////////////////////////////////
BeginConversion();
}
public void ExcludeLinesThatOnlyContainBrackets()
{
RulesReader.FromFile("codeDefinition.json");
Assert.IsFalse(LinesOfCode.DoCount(" }"));
Assert.IsFalse(LinesOfCode.DoCount("{"));
Assert.IsFalse(LinesOfCode.DoCount("{}"));
Assert.IsTrue(LinesOfCode.DoCount("{ i=0;"));
}
public void DoIt2()
{
var rulesReader = new RulesReader();
var glossaryReader = new GlossaryReader();
var xmlParser = new XmlParser();
var rulebook = new Rulebook()
{
Disciplines = new List <Discipline>()
};
var root = AppDomain.CurrentDomain.BaseDirectory;
string[] filenames = { "ActionAir", "Handgun", "Shotgun", "Rifle", "MiniRifle", "PCC" };
string[] languageNames = { "English", "Brazilian" };
var converts = new Dictionary <string, RulesReader.ConversionResult>();
var glossaries = new Dictionary <string, List <Glossary> >();
foreach (var languageName in languageNames)
{
var rootPath = $"{root}/{languageName}";
if (!Directory.Exists(rootPath))
{
continue;
}
foreach (var filename in filenames)
{
if (File.Exists($"{rootPath}/{filename}.txt"))
{
converts.Add(filename, rulesReader.ConvertFromTxtFile($"{rootPath}/{filename}.txt"));
}
if (File.Exists($"{rootPath}/{filename} - Glossary.txt"))
{
glossaries.Add(filename, glossaryReader.ConvertFromTxtFile($"{rootPath}/{filename} - Glossary.txt"));
}
}
var disciplines = new List <Discipline>();
foreach (var convert in converts)
{
var glossaryList = glossaries[convert.Key];
disciplines.Add(rulesReader.CreateRuleChapters(convert.Value, convert.Key, glossaryList));
}
rulebook.Disciplines.AddRange(disciplines);
}
xmlParser.CreateXmlRulebook(rulebook);
}
public void When_Json_File_Is_Empty_Then_Rules_Are_Empty()
{
RulesReader.FromFile("empty.json");
Assert.AreEqual(0, Rules.FilesMustMatch.Count);
Assert.AreEqual(0, Rules.CodeLineMustContain.Count);
Assert.AreEqual(0, Rules.IgnoreFilesThatMatch.Count);
Assert.AreEqual(0, Rules.IgnoreFoldersThatMatch.Count);
Assert.AreEqual(0, Rules.IgnoreIfLineContainsOnly.Count);
Assert.AreEqual(0, Rules.IgnoreLinesThatStartWith.Count);
Assert.AreEqual(0, Rules.IgnoreLinesThatContains.Count);
}
public void ReadConfigWithRulesReader()
{
RulesReader.FromFile("codeDefinition.json");
Assert.AreEqual(1, Rules.FilesMustMatch.Count);
Assert.AreEqual(0, Rules.CodeLineMustContain.Count);
Assert.AreEqual(3, Rules.IgnoreFilesThatMatch.Count);
Assert.AreEqual(3, Rules.IgnoreFoldersThatMatch.Count);
Assert.AreEqual(8, Rules.IgnoreIfLineContainsOnly.Count);
Assert.AreEqual(6, Rules.IgnoreLinesThatStartWith.Count);
Assert.AreEqual(2, Rules.IgnoreLinesThatContains.Count);
}
public Form1()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
//Wnlib.WNCommon.path = @"..\..\..\dict\";
//rr = new RulesReader(Wnlib.WNCommon.path + "\\Rules.txt");
Wnlib.WNCommon.path = "C:\\Program Files (x86)\\WordNet\\2.1\\dict\\";
rr = new RulesReader(Lexicon.EnglishParserCFG + "\\Rules.txt");
}
private void buttonPrecheck_Click(object sender, EventArgs e)
{
try
{
List <Rule> rules = RulesReader.readRules();
RuleEvaluator evaluator = new RuleEvaluator(rules);
RuleInterpreter interpreter = new RuleInterpreter(settings.SmallBlind, settings.BigBlind);
DateTime startCheck = DateTime.Now;
interpreter.precheck(rules);
Log.Info("# prechecking rules took " + DateTime.Now.Subtract(startCheck).TotalMilliseconds + " ms");
}
catch (Exception ex)
{
ErrorHandler.ReportException(ex, "precheck rules");
MessageBox.Show(ex.Message, "Error Precheck", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void DoIt1()
{
Console.WriteLine("Loading Rules Reader Service...");
var rulesReader = new RulesReader();
var glossaryReader = new GlossaryReader();
Console.WriteLine("Rules Reader Service Initialized!");
Console.WriteLine();
Console.WriteLine("Please add source files to root of this utility file.");
Console.WriteLine("Press Enter to Continue...");
Console.ReadLine();
var root = AppDomain.CurrentDomain.BaseDirectory;
string[] filenames = { "ActionAir", "Handgun", "Shotgun", "Rifle", "MiniRifle", "PCC" };
string[] languageNames = { "English" };
Console.WriteLine();
Console.WriteLine("Converting text files to OO Rulebooks");
var converts = new Dictionary <string, RulesReader.ConversionResult>();
var glossaries = new Dictionary <string, List <Glossary> >();
var rootPath = $"{root}/English";
foreach (var filename in filenames)
{
converts.Add(filename, rulesReader.ConvertFromTxtFile($"{rootPath}/{filename}.txt"));
glossaries.Add(filename, glossaryReader.ConvertFromTxtFile($"{rootPath}/{filename} - Glossary.txt"));
}
Console.WriteLine("Conversions complete! Rules now parsed!");
Console.WriteLine($"WARNINGS:");
Console.WriteLine($"Rules 3.2.1 and 4.1.1.2 have bullet points which do not translate and need manual entry.");
Console.WriteLine($"Rules with names that include parantheses will end up in description");
Console.WriteLine();
Console.WriteLine("Creating Rules Book from parsings!");
var disciplines = new List <Discipline>();
foreach (var convert in converts)
{
var glossaryList = glossaries[convert.Key];
disciplines.Add(rulesReader.CreateRuleChapters(convert.Value, convert.Key, glossaryList));
}
Console.WriteLine("Individual rules parsed.");
Console.WriteLine("");
Console.WriteLine("Creating Combined rules book...");
var ruleMerger = new RuleMerger();
disciplines.Add(ruleMerger.MergeDisciplines(disciplines));
Console.WriteLine("Rules book parsed. Printing...");
Console.WriteLine();
Console.WriteLine("Loading File Writer Service...");
var fileWriter = new WebsiteCreator();
Console.WriteLine("File Writer Service Initialized!");
Console.WriteLine();
Console.WriteLine("Creating Website Structure...");
fileWriter.CreateWebsiteFilesDirectory(disciplines);
Console.WriteLine();
Console.WriteLine("Website Created!");
Console.WriteLine();
Console.WriteLine("Creating CSV and XML Files of Disciplines...");
var csvParser = new CsvParser();
var xmlParser = new XmlParser();
var rulebook = new Rulebook()
{
Disciplines = disciplines
};
foreach (var discipline in disciplines)
{
csvParser.CreateCsvDiscipline(discipline);
xmlParser.CreateXmlDiscipline(discipline);
if (glossaries.ContainsKey(discipline.Name))
{
csvParser.CreateCsvGlossary(discipline.Name, glossaries[discipline.Name]);
xmlParser.CreateXmlGlossary(discipline.Name, glossaries[discipline.Name]);
}
}
xmlParser.CreateXmlRulebook(rulebook);
Console.WriteLine("Individual disciplines parsed successfully");
Console.WriteLine("Creating master file...");
csvParser.CreateCsvDisciplines(disciplines);
Console.WriteLine("Master file created!");
var csvReader = new CsvReader();
var readDisciplines = csvReader.ReadCsvDisciplines();
}
public void When_Json_File_Does_Not_Exist_Then_Exception_Is_Thrown()
{
RulesReader.FromFile("doesNotExist.json");
}
public void SetUp()
{
reader = new RulesReader();
}
private static int Main(string[] args)
{
// Show change since last run (which files have a difference in loc?)
// Break out ConsoleApplicationLogic and test it.
// Solve the output-problem/Break out printing from Program
// Refactor how parameters effect the output. Break out most of the logic.
// Break out arguments analysis from Program.
string path;
if (args.Length > 0)
{
path = args[0];
}
else
{
PrintUsage();
return(0);
}
RulesReader.FromFile("codeDefinition.json");
if (args.Length > 1)
{
string lastArgument = args[args.Length - 1];
_verboseOutput = lastArgument == "-v";
_minimalOutput = lastArgument == "-m";
_orderedOutput = lastArgument == "-o";
}
if (_verboseOutput)
{
LinesOfCode.LineProcessComplete += LineProcessComplete;
}
if (IOHelper.IsThisAFile(path))
{
int loc = ProcessFile(path);
if (_minimalOutput)
{
Console.WriteLine(loc);
}
return(0);
}
if (IOHelper.IsThisADirectory(path))
{
// TODO: Refactor!
Dictionary <string, int> files = new Dictionary <string, int>();
if (!_minimalOutput)
{
Console.WriteLine();
}
if (_orderedOutput)
{
FilesOfCode.FileFound += f => files.Add(f, CountFile(f));
}
else
{
FilesOfCode.FileFound += f => ProcessFile(f);
}
FilesOfCode.Find(path);
if (_orderedOutput)
{
var orderedFiles = files.OrderByDescending(kvp => { return(kvp.Value); });
foreach (KeyValuePair <string, int> k in orderedFiles)
{
FileProcessComplete(k.Key, k.Value);
}
Console.Write("\nTotal lines of code: ");
}
else if (!_minimalOutput)
{
foreach (KeyValuePair <string, int> k in files)
{
FileProcessComplete(k.Key, k.Value);
}
Console.Write("\nTotal lines of code: ");
}
Console.WriteLine(_totalLinesOfCode);
#if DEBUG
Console.ReadLine();
#endif
return(0);
}
PrintUsage();
return(1);
}
public static void Main(string[] args)
{
Log.SetLevel(Log.Level.FINE);
BotAppLogic.Beep(settings);
Point offset;
Iterator <Image> screen;
DeviceControl deviceControl;
if (INPUT_MODE == InputMode.WIN32)
{
Console.WriteLine("## win32 mode ##");
deviceControl = new Win32Control();
// wait
Log.Info("waiting ...");
Thread.Sleep(10000);
// full screen
Console.WriteLine("## scanning for table ##");
Image fullScreen = new ScreenImageIterator(deviceControl).next();
offset = PatternLocator.locateTable(fullScreen);
Console.WriteLine("table found at x=" + offset.X + " y=" + offset.Y);
// desk
screen = new ScreenImageIterator(deviceControl, new Rectangle(offset.X, offset.Y, new TableLayout9().Size.Width, new TableLayout9().Size.Height));
screen = new WaitDeltaImageIterator(screen);
}
else if (INPUT_MODE == InputMode.VM)
{
Console.WriteLine("## vm mode ##");
// boot
deviceControl = new VirtualBoxControl(BotAppLogic.ReadConfig()["vm"]);
// poker
Console.WriteLine("waiting for pokerstars ...");
Console.ReadKey();
// mouse
deviceControl.ResetMouse();
// full screen
Console.WriteLine("## scanning for table ##");
Image fullScreen = new ScreenImageIterator(deviceControl).next();
offset = PatternLocator.locateTable(fullScreen);
Console.WriteLine("table found at x=" + offset.X + " y=" + offset.Y);
// desk
screen = new ScreenImageIterator(deviceControl, new Rectangle(offset.X, offset.Y, new TableLayout9().Size.Width, new TableLayout9().Size.Height));
screen = new WaitDeltaImageIterator(screen);
}
else
{
Console.WriteLine("## mock mode ##");
screen = new MockWaitImageIterator(1000, ImageTools.toImage(new Bitmap("test/table_check_free.png")));
offset = new Point(renderer.Control.Location.X + 5, renderer.Control.Location.Y + 15);
deviceControl = new Win32Control();
}
// identifier
TableLayout layout = new TableLayout9(offset);
TableIdentifier tableIdentifier = new TableIdentifier(layout);
tableIdentifier.Renderer = renderer;
// evaluator
List <Rule> rules = RulesReader.readRules();
RuleEvaluator evaluator = new RuleEvaluator(rules);
RuleInterpreter interpreter = new RuleInterpreter(settings.SmallBlind, settings.BigBlind);
// controller
double betSlideTextLimit = settings.PlayMoney ? 100 : 0.2;
Mouse mouse = new HumanMouse(deviceControl);
Keyboard keyboard = new Keyboard(deviceControl);
Controller controller = new Controller(keyboard, mouse, betSlideTextLimit, tableIdentifier, new ScreenImageIterator(deviceControl));
// replayer
Replayer replayer = new Replayer(deviceControl);
// auto-click
RandomClicker clicker = new RandomClicker(new Point(deviceControl.DisplayWidth, 0), mouse);
// initial table
Console.WriteLine("## initial table scan ##");
string player = BotAppLogic.ReadConfig()["name"];
Console.WriteLine("looking for '" + player + "'");
int seat = -1;
/*while (seat == -1)
* {
* Table previousTable = tableIdentifier.identifyTable(screen.next(), TableIdentifier.PlayerInfoEnum.BOTH);
* seat = BotAppLogic.IdentifySeat(previousTable, player);
* Thread.Sleep(1000);
* }
* Console.WriteLine("my seat = " + (seat+1)); */
seat = 4;
// loop
while (screen.hasNext())
{
// start
Console.WriteLine("## iteration -> start ##");
DateTime start = DateTime.Now;
// table
Console.WriteLine("# next table image");
Image tableImage = screen.next();
// render table
renderer.clearImages();
renderer.renderImage(tableImage, 0, 0);
// identify table
//try
//{
if (tableIdentifier.identifyMove(tableImage))
{
Table table = tableIdentifier.identifyTable(tableImage, seat);
List <TableControl> controls = tableIdentifier.identifyControls(tableImage);
table.MaxBet = BotAppLogic.GetMaxBet(controls);
TableContainer container = new TableContainer(0, null, null, layout, seat, false, null);
new BotAppLogic(deviceControl).ProcessTable(settings, tableImage, renderer, table, container, evaluator, interpreter, controller, replayer, clicker, controls);
}
else
{
BotAppLogic.Sleep(settings, 1000);
}
/*}
* catch(Exception ex)
* {
* Console.WriteLine("Unable to identify table");
* Console.WriteLine(ex.ToString());
* Thread.Sleep(5000);
* continue;
* }*/
// end
double time = DateTime.Now.Subtract(start).TotalMilliseconds;
Console.WriteLine("## iteration -> end -> " + time + " ms ##");
}
}
public void CountOneLine()
{
RulesReader.FromFile("codeDefinition.json");
Assert.IsTrue(LinesOfCode.DoCount("i=0;\n"));
}
