public void Reload()
{
if (ManifestFileName == null)
{
_campaign = new Campaign(_gameSystemManager.GameSystem);
return;
}
var contents = File.ReadAllText(ManifestFileName);
var manifest = JsonConvert.DeserializeObject<Campaign>(contents, _converter);
_campaign = new Campaign(_gameSystemManager.GameSystem)
{
Name = manifest.Name
};
_characterConverter = new CharacterConverter(_campaign);
var campaignDirectory = Path.GetDirectoryName(ManifestFileName);
CharacterFolder = Path.Combine(campaignDirectory, "Characters");
if (Directory.Exists(CharacterFolder))
{
foreach (var filename in Directory.EnumerateFiles(CharacterFolder))
{
var characterManager = new CharacterManager(this, filename, _characterConverter, CharacterFolder);
Characters.Add(characterManager);
_campaign.Characters.Add(characterManager.Character);
}
}
}
private Expression MagnitudeExpression(Lexemes lexemes, Expression lhs, ParseSettings parseSettings)
{
if (lexemes.AcceptToken(Constants.Power))
{
var constantExpression = this.ConstantExpression(lexemes, parseSettings);
return(this.MagnitudeExpression(
lexemes,
new MagnitudeExpression(lhs, constantExpression),
parseSettings));
}
string exponent;
if (lexemes.AcceptTokenType(TokenType.Exponent, out exponent))
{
var constantExpression =
new ConstantExpression(
double.Parse(CharacterConverter.FromExponentNotation(exponent), parseSettings.CultureInfo));
return(this.MagnitudeExpression(
lexemes,
new MagnitudeExpression(lhs, constantExpression),
parseSettings));
}
return(lhs);
}
public string OrderBy(IEnumerable <DynamicQueryOrder> orders, bool fieldConverter = true)
{
if (orders == null || !orders.Any())
{
return(string.Empty);
}
return(string.Join(",", orders.Select(item =>
{
var name = item.Name;
if (fieldConverter)
{
name = CharacterConverter.FieldConverter(item.Name);
}
if (SqlFieldMappings.Any(x => x.Key == name))
{
name = SqlFieldMappings.First(x => x.Key == name).SqlField;
}
var order = item.Sort == ListSortDirection.Ascending
? "ASC"
: "DESC";
return $" {name} {order} ";
})));
}
public void ToDomain_ShouldCalculateHpCorrectly_NoItems_MultipleClasses_WithConMod()
{
RpgClass firstClass = new RpgClass {
ClassLevel = 2, HitDiceValue = 10, Name = "firstClass"
};
RpgClass secondClass = new RpgClass {
ClassLevel = 1, HitDiceValue = 6, Name = "secondClass"
};
RpgClass thirdClass = new RpgClass {
ClassLevel = 5, HitDiceValue = 12, Name = "thirdClass"
};
List <RpgClass> singletonClass = new List <RpgClass> {
firstClass, secondClass, thirdClass
};
Stats conMod = new Stats {
Constitution = 14
};
Character noItemCharacter = new Character
{
Classes = singletonClass,
Stats = conMod,
};
DomainCharacter actualCharacter = CharacterConverter.ToDomain(noItemCharacter);
Assert.Equal(67, actualCharacter.MaxHitpoints);
Assert.Equal(67, actualCharacter.CurrentHitpoints);
}
public CharacterFileInfo(string fileName, CharacterConverter converter, string characterDirectory)
{
FileName = fileName;
_converter = converter;
_characterDirectory = characterDirectory;
}
/// <summary>
/// Visits a <see cref="MagnitudeExpression" />.
/// </summary>
/// <param name="magnitudeExpression">The magnitude expression.</param>
/// <param name="notationParameters">The notation parameters.</param>
/// <param name="notationVariables">The notation variables.</param>
public void Magnitude(
MagnitudeExpression magnitudeExpression,
NotationParameters notationParameters,
NotationVariables notationVariables)
{
var requestPrecendence = notationVariables.RequestPrecedence;
var stringBuilder = notationParameters.StringBuilder;
this.HandleLeftPrecedence(requestPrecendence, stringBuilder);
magnitudeExpression.Lhs.Visit(this, notationParameters, new NotationVariables(true, true));
var constant = magnitudeExpression.Rhs.Constant.ToString(notationParameters.FormatProvider);
switch (this.notationOptions.MagnitudeFormat)
{
case MagnitudeFormat.UseAboveLetter:
if (magnitudeExpression.Lhs is MagnitudeExpression)
{
stringBuilder.Append(Constants.Power);
}
stringBuilder.Append(CharacterConverter.ToExponentNotation(constant));
break;
default:
stringBuilder.Append(Constants.Power);
stringBuilder.Append(constant);
break;
}
this.HandleRightPrecedence(requestPrecendence, stringBuilder);
}
public void Delete(DTO.Character character)
{
Character domainCharacter = new Character();
CharacterConverter.MapDTOToDomain(character, domainCharacter);
_db.Characters.Remove(domainCharacter);
_db.SaveChanges();
}
// TODO: Figure out what to do re: gameSystemManager vs masterValuesTable.
public CharacterManager(CampaignManager campaignManager, string fileName, CharacterConverter converter, string characterDirectory)
{
FileName = fileName;
_masterValuesTable = campaignManager.MasterValuesTable;
_converter = converter;
_characterDirectory = characterDirectory;
}
public Character Add(DTO.Character character)
{
Character domainCharacter = CharacterConverter.DTOToDomain(character);
_db.Characters.Add(domainCharacter);
_db.SaveChanges();
return(domainCharacter);
}
public void ConvertToTest()
{
IConverterTo <char> c = new CharacterConverter();
var yang = c.ConvertTo(new Core.Painting(Core.YinYang.Yang));
Assert.AreEqual('⚊', yang);
var yin = c.ConvertTo(new Core.Painting(Core.YinYang.Yin));
Assert.AreEqual('⚋', yin);
var yangyang = c.ConvertTo(new Core.Painting(Core.YinYang.Yang, Core.YinYang.Yang));
Assert.AreEqual('⚌', yangyang);
var yangyin = c.ConvertTo(new Core.Painting(Core.YinYang.Yang, Core.YinYang.Yin));
Assert.AreEqual('⚍', yangyin);
var yinyang = c.ConvertTo(new Core.Painting(Core.YinYang.Yin, Core.YinYang.Yang));
Assert.AreEqual('⚎', yinyang);
var yinyin = c.ConvertTo(new Core.Painting(Core.YinYang.Yin, Core.YinYang.Yin));
Assert.AreEqual('⚏', yinyin);
var xun = c.ConvertTo(new Core.Painting(
Core.YinYang.Yin, Core.YinYang.Yang, Core.YinYang.Yang));
Assert.AreEqual('☴', xun);
var qian = c.ConvertTo(new Core.Painting(
Core.YinYang.Yang, Core.YinYang.Yang, Core.YinYang.Yang));
Assert.AreEqual('☰', qian);
var kun = c.ConvertTo(new Core.Painting(
Core.YinYang.Yin, Core.YinYang.Yin, Core.YinYang.Yin));
Assert.AreEqual('☷', kun);
var dui = c.ConvertTo(new Core.Painting(
Core.YinYang.Yang, Core.YinYang.Yang, Core.YinYang.Yin));
Assert.AreEqual('☱', dui);
var ze = c.ConvertTo(new Core.Painting(
Core.YinYang.Yin, Core.YinYang.Yang, Core.YinYang.Yin));
Assert.AreEqual('☵', ze);
var qian6 = c.ConvertTo(new Core.Painting(
Core.YinYang.Yang, Core.YinYang.Yang, Core.YinYang.Yang,
Core.YinYang.Yang, Core.YinYang.Yang, Core.YinYang.Yang));
Assert.AreEqual('䷀', qian6);
var weiji = c.ConvertTo(new Core.Painting(
Core.YinYang.Yin, Core.YinYang.Yang, Core.YinYang.Yin,
Core.YinYang.Yang, Core.YinYang.Yin, Core.YinYang.Yang));
Assert.AreEqual('䷿', weiji);
var r = c.ConvertTo(new Core.Painting(
Core.YinYang.Yin, Core.YinYang.Yang, Core.YinYang.Yang,
Core.YinYang.Yin, Core.YinYang.Yin, Core.YinYang.Yin));
Assert.AreEqual('䷭', r);
}
public Character Edit(DTO.Character character)
{
Character domainCharacter = Get(character.ID);
CharacterConverter.MapDTOToDomain(character, domainCharacter);
_db.Entry(domainCharacter).State = System.Data.Entity.EntityState.Modified;
_db.SaveChanges();
return(domainCharacter);
}
public void ToDomain_ShouldTranslateCharacterName()
{
Character namedCharacter = new Character {
Name = "bob"
};
DomainCharacter actualCharacter = CharacterConverter.ToDomain(namedCharacter);
Assert.Equal("bob", actualCharacter.Name);
}
public static void then_should_convert_a_to_single_plus_sign()
{
// Arrange
const char character = 'a';
// Act
var convertedValue = CharacterConverter.ToColumnValues(character);
// Assert
Assert.That(convertedValue, Is.EqualTo(new[] { '+' }));
}
public void TryConvertFromTest()
{
IConverterTo <char> c = new CharacterConverter();
IConverterFrom <char> cb = new CharacterConverter();
for (int i = 0; i < 10000; i++)
{
var painting = this.GetRandomPainting(random.Next(0, 4) switch {
0 => 1,
1 => 2,
2 => 3,
_ => 6
});
/// <summary>Creates an instance for the default language.</summary>
/// <returns>A repository.</returns>
public override ICharacterRepository ForDefaultCulture()
{
var genderConverter = new GenderConverter();
var professionConverter = new ProfesionConverter();
var raceConverter = new RaceConverter();
var characterConverter = new CharacterConverter(genderConverter, professionConverter, raceConverter);
var identifiersResponseConverter = new ResponseConverter <ICollection <string>, ICollection <string> >(new ConverterAdapter <ICollection <string> >());
var responseConverter = new ResponseConverter <CharacterDTO, Character>(characterConverter);
var bulkResponseConverter = new DictionaryRangeResponseConverter <CharacterDTO, string, Character>(characterConverter, c => c.Name);
var pageResponseConverter = new CollectionPageResponseConverter <CharacterDTO, Character>(characterConverter);
return(new CharacterRepository(this.serviceClient, identifiersResponseConverter, responseConverter, bulkResponseConverter, pageResponseConverter));
}
public GameSystemManager()
{
GameSystem = new GameSystem();
_characterConverter = new CharacterConverter(GameSystem);
var root = AppDomain.CurrentDomain.BaseDirectory;
CoreRuleBookDirectory = Path.Combine(root, "SourceBooks", "CoreRuleBook");
var userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
CharacterDirectory = Path.Combine(userProfile, "Pathfinder");
Characters = new List<CharacterFileInfo>();
}
public static void SeedDatabase(IApplicationBuilder app)
{
using (var serviceScope = app.ApplicationServices.CreateScope())
{
ICharacterRepositoryAdapter adapter = serviceScope.ServiceProvider.GetService <ICharacterRepositoryAdapter>();
using (StreamReader r = new StreamReader("briv.json"))
{
string json = r.ReadToEnd();
Character character = JsonConvert.DeserializeObject <Character>(json);
DomainCharacter initialChar = CharacterConverter.ToDomain(character);
adapter.SaveCharacter(initialChar);
}
}
}
public static void then_should_convert_j_to_plus_plus_dash_dash_asterisk_asterisk_asterisk_period_period_period()
{
// Arrange
const char character = 'j';
// Act
var convertedValue = CharacterConverter.ToColumnValues(character);
// Assert
Assert.That(convertedValue, Is.EqualTo(
new[]
{
'+', '+', '-', '-', '*', '*', '*', '.', '.', '.'
}));
}
static void Main()
{
#region to convert to characters and back
Console.OutputEncoding = Encoding.Unicode;
Painting yang = new Painting(
YinYang.Yang); // 阳
Painting shaoYin = new Painting(
YinYang.Yang, YinYang.Yin); // 少阴
Painting li = new Painting(
YinYang.Yang, YinYang.Yin, YinYang.Yang); // 离
Painting qian = new Painting(
YinYang.Yin, YinYang.Yin, YinYang.Yang,
YinYang.Yin, YinYang.Yin, YinYang.Yin); // 谦
Console.Write($"{yang}-{shaoYin}-{li}-{qian} ");
var characterConverter = new CharacterConverter();
char characterOfQian = characterConverter.ConvertTo(qian);
Console.Write($"{characterConverter.ConvertTo(yang)}-" +
$"{characterConverter.ConvertTo(shaoYin)}-" +
$"{characterConverter.ConvertTo(li)}-" +
$"{characterOfQian} ");
_ = characterConverter.TryConvertFrom(characterOfQian, out Painting result);
Console.WriteLine(result);
Console.WriteLine();
// Output: 1-10-101-001000 ⚊-⚍-☲-䷎ 001000
#endregion
#region to convert to string
StringConverter stringConverter = new StringConverter(
"-----", "-- --", Environment.NewLine);
Console.WriteLine(stringConverter.ConvertTo(qian));
Console.WriteLine();
/*
* Outputs:
* -- --
* -- --
* -- --
* -----
* -- --
* -- --
*/
#endregion
}
public void ToDomain_ShouldTranslateDefenseVulnerabilities()
{
CharacterDefense fireImmunity = new CharacterDefense {
Defense = "vulnerable", Type = "bludgeoning"
};
CharacterDefense slashingImmunity = new CharacterDefense {
Defense = "vulnerable", Type = "slashing"
};
Character characterWithImmunities = new Character {
Defenses = new List <CharacterDefense> {
fireImmunity, slashingImmunity
}
};
DomainCharacter actualCharacter = CharacterConverter.ToDomain(characterWithImmunities);
Assert.Equal(new List <string> {
"bludgeoning", "slashing"
}, actualCharacter.Vulnerabilities);
}
public void ToDomain_ShouldTranslateDefenseResistances()
{
CharacterDefense fireImmunity = new CharacterDefense {
Defense = "resistance", Type = "radiant"
};
CharacterDefense slashingImmunity = new CharacterDefense {
Defense = "resistance", Type = "force"
};
Character characterWithImmunities = new Character {
Defenses = new List <CharacterDefense> {
fireImmunity, slashingImmunity
}
};
DomainCharacter actualCharacter = CharacterConverter.ToDomain(characterWithImmunities);
Assert.Equal(new List <string> {
"radiant", "force"
}, actualCharacter.Resistances);
}
public HttpResponseMessage Edit(DTO.Character character)
{
string errorResponse = "";
try
{
character = CharacterConverter.DomainToDTO(RepositoryProxy.Instance.CharacterRepository.Edit(character));
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
JObject JCharacter = JObject.FromObject(character);
response.Content = new System.Net.Http.StringContent(JCharacter.ToString());
response.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
return(response);
}
catch (Exception ex)
{
errorResponse = ex.Message;
}
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
public void ToDomain_ShouldCalculateHpCorrectly_WithItemsThatModifyCon()
{
RpgClass firstClass = new RpgClass {
ClassLevel = 2, HitDiceValue = 10, Name = "firstClass"
};
RpgClass secondClass = new RpgClass {
ClassLevel = 1, HitDiceValue = 6, Name = "secondClass"
};
RpgClass thirdClass = new RpgClass {
ClassLevel = 5, HitDiceValue = 12, Name = "thirdClass"
};
List <RpgClass> singletonClass = new List <RpgClass> {
firstClass, secondClass, thirdClass
};
Modifier conModification = new Modifier
{
AffectedObject = "stats",
AffectedValue = "constitution",
Value = 2
};
Item item = new Item {
Name = "Ioun Stone of Fortitude", Modifier = conModification
};
Stats conMod = new Stats {
Constitution = 14
};
Character characterWithConItem = new Character
{
Classes = singletonClass,
Stats = conMod,
Items = new List <Item> {
item, item
}
};
DomainCharacter actualCharacter = CharacterConverter.ToDomain(characterWithConItem);
Assert.Equal(83, actualCharacter.MaxHitpoints);
Assert.Equal(83, actualCharacter.CurrentHitpoints);
}
public void ToDomain_ShouldCalculateHpCorrectly_NoItems_SingleClass_WithConMod(int constitutionScore, int classLevel, int hitDiceValue, int expectedHp)
{
RpgClass onlyClass = new RpgClass {
ClassLevel = classLevel, HitDiceValue = hitDiceValue, Name = "singleClass"
};
List <RpgClass> singletonClass = new List <RpgClass> {
onlyClass
};
Stats conMod = new Stats {
Constitution = constitutionScore
};
Character noItemCharacter = new Character
{
Classes = singletonClass,
Stats = conMod,
};
DomainCharacter actualCharacter = CharacterConverter.ToDomain(noItemCharacter);
Assert.Equal(expectedHp, actualCharacter.MaxHitpoints);
Assert.Equal(expectedHp, actualCharacter.CurrentHitpoints);
}
public void CharacterConverter_TestConversion(char input, int expectedOutput)
{
var output = CharacterConverter.ConvertCharacterToInt(input);
Assert.AreEqual(expectedOutput, output);
}
public void ToDomain_ShouldReturnNull_WhenNullCharacterPassed()
{
Assert.Null(CharacterConverter.ToDomain(null));
}
public void CharacterConverter_TryInvalidCharacter([Values('(', '*', '!', '@')] char input)
{
Assert.Throws <FormatException>(() => CharacterConverter.ConvertCharacterToInt(input));
}
public void TestMethod1()
{
Assert.AreEqual("ƒA", CharacterConverter.ConvertHira2Kata("‚ "));
Assert.AreEqual("ƒA", CharacterConverter.ConvertHan2Zen("±"));
Assert.AreEqual("±", CharacterConverter.ConvertZen2Han("ƒA"));
}
/// <summary>
/// Returns a <see cref="string" /> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string" /> that represents this instance.
/// </returns>
public override string ToString()
{
return(this.UnitExpression
+ CharacterConverter.ToExponentNotation(this.Exponent.ToString(CultureInfo.CurrentCulture)));
}
public ActionResult <DomainCharacter> AddCharacter([FromBody] Character characterToConvert)
{
return(repositoryAdapter.SaveCharacter(CharacterConverter.ToDomain(characterToConvert)));
}
public void TestSetup()
{
converter = new CharacterConverter();
}
public IActionResult HeadToHead()
{
var dbContext = new SmashggTrackerContext();
int user1 = 549;
int user2 = 544;
var player1 = dbContext.Players.FirstOrDefault(x => x.Id == user1);
var player2 = dbContext.Players.FirstOrDefault(x => x.Id == user2);
var matches = dbContext.Matches
.Where(x => (x.Player1.Id == user1 || x.Player2.Id == user1) &&
(x.Player2.Id == user2 || x.Player1.Id == user2)).Include(x => x.Player1)
.Include(x => x.Player2).Include(x => x.Matches).Include(x => x.Tournament).ToList();
ViewBag.Player1 = player1.Name;
ViewBag.Player2 = player2.Name;
var stageMatchupP1 = new StageMatchup();
var characterStatsP1 = new StageMatchup();
var characterStatsP2 = new StageMatchup();
foreach (var match in matches)
{
foreach (var game in match.Matches)
{
if (match.Player1.Id == user1)
{
if (game.StocksP1 > game.StocksP2)
{
if (!string.IsNullOrEmpty(StageConverter.GetStageById(game.StageId)))
{
stageMatchupP1.AddStageWin(game.StageId);
}
if (!string.IsNullOrEmpty(CharacterConverter.GetChracterById(game.CharacterIdP1 - 1)))
{
characterStatsP1.AddStageWin(game.CharacterIdP1);
}
if (!string.IsNullOrEmpty(CharacterConverter.GetChracterById(game.CharacterIdP2 - 1)))
{
characterStatsP2.AddStageLoss(game.CharacterIdP2);
}
}
else
{
if (!string.IsNullOrEmpty(StageConverter.GetStageById(game.StageId)))
{
stageMatchupP1.AddStageLoss(game.StageId);
}
if (!string.IsNullOrEmpty(CharacterConverter.GetChracterById(game.CharacterIdP1 - 1)))
{
characterStatsP1.AddStageLoss(game.CharacterIdP1);
}
if (!string.IsNullOrEmpty(CharacterConverter.GetChracterById(game.CharacterIdP2 - 1)))
{
characterStatsP2.AddStageWin(game.CharacterIdP2);
}
}
}
else if (!string.IsNullOrEmpty(StageConverter.GetStageById(game.StageId)))
{
if (game.StocksP1 > game.StocksP2)
{
if (!string.IsNullOrEmpty(StageConverter.GetStageById(game.StageId)))
{
stageMatchupP1.AddStageLoss(game.StageId);
}
if (!string.IsNullOrEmpty(CharacterConverter.GetChracterById(game.CharacterIdP1 - 1)))
{
characterStatsP1.AddStageLoss(game.CharacterIdP1);
}
if (!string.IsNullOrEmpty(CharacterConverter.GetChracterById(game.CharacterIdP2 - 1)))
{
characterStatsP2.AddStageWin(game.CharacterIdP2);
}
}
else
{
if (!string.IsNullOrEmpty(StageConverter.GetStageById(game.StageId)))
{
stageMatchupP1.AddStageWin(game.StageId);
}
if (!string.IsNullOrEmpty(CharacterConverter.GetChracterById(game.CharacterIdP1 - 1)))
{
characterStatsP1.AddStageWin(game.CharacterIdP1);
}
if (!string.IsNullOrEmpty(CharacterConverter.GetChracterById(game.CharacterIdP2 - 1)))
{
characterStatsP2.AddStageLoss(game.CharacterIdP2);
}
}
}
}
}
ViewBag.StagesP1 = stageMatchupP1;
ViewBag.CharacterP1 = characterStatsP1;
ViewBag.CharacterP2 = characterStatsP2;
return(View(matches));
}
