static void Main(string[] args)
{
try
{
var options = new Options();
if (!Parser.Default.ParseArguments(args, options))
{
return;
}
if (options.ShowRules)
{
IRulePrinter printer = new ConsolePrinter();
printer.PrintRules(GameRules);
printer = new MarkdownPrinter(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "rules.md"));
printer.PrintRules(GameRules);
printer = new HtmlPrinter(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "rules.html"));
printer.PrintRules(GameRules);
return;
}
Console.WriteLine("Starting new game");
var game = new BombermanGame();
if (options.ConsoleLogger)
{
game.Logger = new CombinedLogger(new InMemoryLogger(), new ConsoleLogger());
}
game.StartNewGame(options);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public HtmlPrinterTests()
{
_outputPath = Path.GetTempFileName();
File.Delete(_outputPath);
Directory.CreateDirectory(_outputPath);
_printer = new HtmlPrinter();
}
public void BookHtmlAreEqual()
{
IPrinter htmlPrinter = new HtmlPrinter();
string text = "long long text";
string htmlResult = string.Format("Print html:{0}", text);
string result;
Book book = new Book(htmlPrinter);
book.Text = text;
result = Example00.Instance.Main(book);
Assert.AreEqual(htmlResult, result);
}
public static void ProcessStage3(Syntax.Block document, TextWriter target, CommonMarkSettings settings = null)
{
if (document == null)
{
throw new ArgumentNullException("document");
}
if (target == null)
{
throw new ArgumentNullException("target");
}
if (document.Tag != Syntax.BlockTag.Document)
{
throw new ArgumentException("The block element passed to this method must represent a top level document.", "document");
}
if (settings == null)
{
settings = CommonMarkSettings.Default;
}
try
{
if (settings.OutputFormat == OutputFormat.SyntaxTree)
{
Printer.PrintBlocks(target, document, settings);
}
else
{
HtmlPrinter.BlocksToHtml(target, document, settings);
}
}
catch (CommonMarkException)
{
throw;
}
catch (IOException)
{
throw;
}
catch (Exception ex)
{
throw new CommonMarkException("An error occurred during formatting of the document.", ex);
}
}
public void HeaderH1Test()
{
var input = @"
<w:p>
<w:pPr>
<w:pStyle w:val=""Title""/>
</w:pPr>
<w:r>
<w:t>Title</w:t>
</w:r>
</w:p>
";
var expected = @"<div><h1><span>Title</span></h1></div>";
var l = TestHelper.ParseString(input, true);
var p = new HtmlPrinter();
p.Print(l);
Assert.AreEqual(expected, p.HtmlString);
}
public void ParagraphTest()
{
var input = @"
<w:body>
<w:p>
<w:pPr>
<w:rPr>
<w:b/>
<w:i/>
<w:color w:val=""538135"" w:themeColor=""accent6"" w:themeShade=""BF""/>
<w:sz w:val=""16""/>
<w:szCs w:val=""16""/>
</w:rPr>
</w:pPr>
<w:r>
<w:t xml:space=""preserve"">Abc louis</w:t>
</w:r>
<w:r>
<w:rPr>
<w:b/>
</w:rPr>
<w:t xml:space=""preserve"">def </w:t>
</w:r>
<w:r>
<w:t>ijk</w:t>
</w:r>
</w:p>
</w:body>
";
var expected = @"<div style=""font-size:16px;color:#538135;font-style:italic;font-weight:bold;""><span>Abc louis</span><span style=""font-weight:bold;"">def</span><span>ijk</span></div>";
var l = TestHelper.ParseString(input);
var p = new HtmlPrinter();
p.Print(l);
Console.WriteLine(p.HtmlString);
Assert.AreEqual(expected, p.HtmlString);
}
public static void Main(string[] args)
{
var data = "Hello World !";
AbstractMediator abstractMediator = new Mediator.Mediator();
AbstractPrinter textPrinter = new TextPrinter(abstractMediator);
AbstractPrinter xmlPrinter = new XmlPrinter(abstractMediator);
AbstractPrinter htmlPrinter = new HtmlPrinter(abstractMediator);
abstractMediator.Register(textPrinter);
abstractMediator.Register(xmlPrinter);
abstractMediator.Register(htmlPrinter);
Console.WriteLine("Text Printer talking ......\n");
textPrinter.Print(data, textPrinter.PrinterType);
textPrinter.PrintToOtherFormat(data, xmlPrinter.PrinterType, textPrinter.PrinterType);
Console.WriteLine("\nText Printer talking ......\n");
xmlPrinter.Print(data, xmlPrinter.PrinterType);
xmlPrinter.PrintToOtherFormat(data, textPrinter.PrinterType, xmlPrinter.PrinterType);
Console.WriteLine("\nText Printer talking ......\n");
htmlPrinter.PrintToOtherFormat(data, xmlPrinter.PrinterType, htmlPrinter.PrinterType);
}
public string Print(bool withHonoredHfs = false)
{
string html = "";
html += Name;
if (RequiredSkill != null)
{
html += "<br/>";
html += "<ol class='skills'>";
html += HtmlPrinter.SkillToString(SkillDictionary.LookupSkill(RequiredSkill));
html += "</ol>";
}
if (RequiredBattles > 0 || RequiredYears > 0 || RequiredKills > 0 || GivesPrecedence > 0 || GrantedToEverybody || RequiresAnyMeleeOrRangedSkill)
{
html += "<br/>";
html += "<ul>";
if (GivesPrecedence > 0)
{
html += "<li>";
html += "Gives Precedence: " + GivesPrecedence;
html += "</li>";
}
if (RequiredBattles > 0)
{
html += "<li>";
html += "Required Battles: " + RequiredBattles;
html += "</li>";
}
if (RequiredYears > 0)
{
html += "<li>";
html += "Required Years: " + RequiredYears;
html += "</li>";
}
if (RequiredKills > 0)
{
html += "<li>";
html += "Required Kills: " + RequiredKills;
html += "</li>";
}
if (GrantedToEverybody)
{
html += "<li>";
html += "Granted to everybody";
html += "</li>";
}
if (RequiresAnyMeleeOrRangedSkill)
{
html += "<li>";
html += "Requires any melee or ranged skill";
html += "</li>";
}
html += "</ul>";
}
if (withHonoredHfs)
{
if (HonoredHfs.Any())
{
html += "<ul>";
html += "<li><b>Honored Historical Figures:</b></li>";
html += "<ul>";
foreach (HistoricalFigure honoredHf in HonoredHfs)
{
html += "<li>";
html += honoredHf.ToLink();
html += "</li>";
}
html += "</ul>";
html += "</ul>";
}
}
return(html);
}
private string PrintClassInterfaceHtml(MimicGeneratedClass typeModels, ClassType classType)
{
var builder = new StringBuilder();
builder.Append(HtmlPrinter.Keyword("public"));
builder.Append(HtmlPrinter.Keyword(classType.ToString().ToLower()));
if (classType == ClassType.CLASS)
{
builder.Append(HtmlPrinter.Type(typeModels.ClassName));
if (typeModels.ParentClass == null)
{
if (typeModels.InheritedInterfaceNames != null && typeModels.InheritedInterfaceNames.Any())
{
builder.Append(HtmlPrinter.Standard(" : "));
builder.Append(HtmlPrinter.Type(string.Join(", ", typeModels.InheritedInterfaceNames)));
}
}
else
{
builder.Append(HtmlPrinter.Standard(" : "));
builder.Append(HtmlPrinter.Type(typeModels.ParentClass.ClassName));
}
}
else
{
builder.Append(HtmlPrinter.Type(typeModels.InterfaceName));
}
builder.Append(HtmlPrinter.NewLine);
builder.Append(HtmlPrinter.Standard("{"));
builder.Append(HtmlPrinter.NewLine);
var propertyTypes = typeModels.PropertyTypes;
if (classType == ClassType.CLASS && typeModels.ParentClass == null)
{
List <MimicPropertyType> list = new List <MimicPropertyType>();
foreach (var i in typeModels.Compositions)
{
list.AddRange(i.PropertyTypes);
}
propertyTypes.AddRange(list);
}
foreach (var prop in propertyTypes.OrderByDescending(pt => pt.IsMandatory))
{
var mandatory = classType == ClassType.CLASS && prop.IsMandatory;
if (mandatory)
{
builder.Append(HtmlPrinter.Standard("[", false));
builder.Append(HtmlPrinter.Type("Required", false));
builder.Append(HtmlPrinter.Standard("]"));
builder.Append(HtmlPrinter.NewLine);
}
if (classType == ClassType.CLASS)
{
builder.Append(HtmlPrinter.Keyword("public"));
}
var htmlClass = "dm-typ";
var propertyTypeName = prop.PropertyType.
ReplaceFirstOccurrence("<", "<span class=\"dm-std\"><</span>").
ReplaceLastOccurrence(">", "<span class=\"dm-std\">></span>");
if (AliasTypesMap.Contains(propertyTypeName))
{
htmlClass = "dm-kwd";
}
builder.AppendFormat("<span class=\"{0}\">{1}</span>", htmlClass, propertyTypeName);
builder.Append(HtmlPrinter.Space);
builder.Append(HtmlPrinter.Standard(prop.Name));
builder.Append(HtmlPrinter.Standard("{"));
builder.Append(HtmlPrinter.Keyword("get"));
builder.Append(HtmlPrinter.Standard(";"));
builder.Append(HtmlPrinter.Space);
builder.Append(HtmlPrinter.Keyword("set"));
builder.Append(HtmlPrinter.Standard(";"));
builder.Append(HtmlPrinter.Space);
builder.Append(HtmlPrinter.Standard("}"));
builder.Append(HtmlPrinter.NewLine);
if (mandatory)
{
builder.Append(HtmlPrinter.NewLine);
}
}
builder.Append(HtmlPrinter.Standard("}"));
builder.Append(HtmlPrinter.NewLine);
builder.Append(HtmlPrinter.NewLine);
var result = builder.ToString();
return(result);
}
