private async Task PlayRuleAsync(RuleCard thisCard)
{
if (thisCard.Deck == EnumRuleText.ReverseOrder)
{
if (_gameContainer.PlayerList.Count() == 2)
{
_gameContainer.SaveRoot !.AnotherTurn = true;
await _gameContainer.AnimatePlayAsync !(thisCard);
await _analyzeProcesses.AnalyzeQueAsync();
return;
}
}
if (thisCard.Category != EnumRuleCategory.Basic && thisCard.Category != EnumRuleCategory.None)
{
var thisCat = thisCard.Category;
_gameContainer.SaveRoot !.RuleList.RemoveAllOnly(items => items.Category == thisCat);
}
_gameContainer.SaveRoot !.RuleList.Add(thisCard);
_gameContainer.RefreshRules();
if (_gameContainer !.QuePlayList.Count == 0)
{
_analyzeProcesses.AnalyzeRules();
if (_gameContainer.LeftToDraw > 0)
{
_gameContainer.SaveRoot.DoAnalyze = true;
await _gameContainer.DrawAsync !();
return;
}
}
await _analyzeProcesses.AnalyzeQueAsync();
}
// - la dernière mesure de la partition doit comporter une ou plusieurs notes, sans accord
public LastMeasureValidationRule(int n, params Measure[] measures)
{
RuleList.Add(new ValidationRule <Measure[]>(measures, m => m.Last().Type == MeasureType.ACCORD || m.Last().Type == MeasureType.SILENCE)
{
Number = n,
Measures = measures,
ErrorCode = ValidationError.HARMONY_LAST_MEASUREMENT_TYPE_ERROR,
});
}
/// <summary>
/// Executes the specified builderSource.
/// </summary>
/// <returns></returns>
/// ///
public RuleList BuildRules()
{
Rules = new RuleList();
foreach (var attribute in ValidationAttributes)
{
ValidationAttribute validation = (ValidationAttribute)attribute;
Rules.Add(validation.CreateRule(validation.Target));
}
return(Rules);
}
private Rule(Conclusion conclusion, Dictionary <string, List <Rule> > RuleLists)
{
this.conclusion = conclusion;
if (this.RuleList is null)
{
RuleList = new List <Rule>();
RuleLists.Add(conclusion.ToString(), RuleList);
}
RuleList.Add(this);
this.RuleLists = RuleLists;
}
//private static bool fieldsNotEmpty(RuleGrid grid, int row, int[] columns)
//{
// foreach (int i in columns)
// {
// if (((String)grid[row, i].Value) == null)
// {
// //throw new Exception("Some fields are incomplete.");
// return false;
// }
// if (((String)grid[row, i].Value).Equals(String.Empty))
// {
// return false;
// }
// }
// return true;
//}
public static RuleList ParseRule(string text)
{
StringReader sr = new StringReader(Helper.CleanRuleText(text));
// format string
RuleList rules = new RuleList(sr.ReadLine()); ;
string[] tokens;
string s;
while ((s = sr.ReadLine()) != null)
{
// rule
tokens = s.Split('\t');
if (tokens[0].Equals("copy") || tokens[0].Equals("cpy"))
//Copy Rule
{
string[] searchPatterns = new string[tokens.Length - 2];
Array.Copy(tokens, 2, searchPatterns, 0, searchPatterns.Length);
rules.Add(new CopyRule(tokens[1], searchPatterns));
}
else if (tokens[0].Equals("delete") || tokens[0].Equals("del"))
//Delete Rule
{
if (tokens.Length == 1)
throw new System.ArgumentException(Textual.ErrorDeleteRule);
string[] searchPatterns = new string[tokens.Length - 1];
Array.Copy(tokens, 1, searchPatterns, 0, searchPatterns.Length);
rules.Add(new DeleteRule(searchPatterns));
}
else if (tokens[0].Equals("replace") || tokens[0].Equals("rpl"))
//Replace Rule
{
if (tokens.Length < 3)
throw new System.ArgumentException(Textual.ErrorReplaceRule);
string[] searchPatterns = new string[tokens.Length - 2];
Array.Copy(tokens, 2, searchPatterns, 0, searchPatterns.Length);
rules.Add(new ReplaceRule(tokens[1], tokens[2], searchPatterns));
}
}
return rules;
}
internal static RuleList getRuleList(HttpResponseMessage responce)
{
var ruleList = new RuleList();
var jsonObj = JsonConvert.DeserializeObject<Dictionary<string, object>>(responce.Content.ReadAsStringAsync().Result);
if(jsonObj.ContainsKey("rules"))
{
var rulesArray = JsonConvert.DeserializeObject<List<object>>(jsonObj["rules"].ToString());
foreach(var ruleObj in rulesArray)
{
var rule = new Rule();
rule = JsonConvert.DeserializeObject<Rule>(ruleObj.ToString());
ruleList.Add(rule);
}
}
return ruleList;
}
internal static RuleList getRuleList(HttpResponseMessage responce)
{
var ruleList = new RuleList();
var jsonObj = JsonConvert.DeserializeObject <Dictionary <string, object> >(responce.Content.ReadAsStringAsync().Result);
if (jsonObj.ContainsKey("rules"))
{
var rulesArray = JsonConvert.DeserializeObject <List <object> >(jsonObj["rules"].ToString());
foreach (var ruleObj in rulesArray)
{
var rule = new Rule();
rule = JsonConvert.DeserializeObject <Rule>(ruleObj.ToString());
ruleList.Add(rule);
}
}
return(ruleList);
}
public static RuleList ParseRules(string newFormat, RuleGrid grid)
{
// format string
RuleList rules = new RuleList(newFormat);
for (int r = grid.FixedRows; r < grid.RowsCount; r++)
{
if (!(bool)grid[r, RuleGrid.ColControl].Value)
continue;
if (!grid.CheckRow(r))
continue;
rules.Add(ParseRule(grid.GetCellsAtRow(r)));
}
return rules;
}
public RuleList parseRuleset(string rulesIn, string homeMt)
{
var pmt = ParseKEText(homeMt, rulesIn, false, true);
if (pmt != null && pmt.Count == 1)
{
var ruleList0 = pmt.Values.FirstOrDefault();
return(ruleList0);
}
string[] rules = rulesIn.Split('\n');
RuleList ruleList = new RuleList();
var outi = 0;
for (var r = 0; r < rules.Length; r++)
{
string rule = rules[r];
if (rule.Length > 0)
{
if (rule.Substring(0, 1) == "#" || rule == "")
{
continue;
}
var or = ParseRule(new Tokeniser(rule), homeMt);
if (or == null)
{
continue;
}
or.OptionalHomeMt = homeMt;
ruleList.Add(or);
// print ("Rule "+outi+" is : ");
if (show)
{
or.print(Console.Write);
}
}
}
return(ruleList);
}
public MeasuresValidationRule(int n, params Measure[] measures)
{
// - un silence doit être suivi d'un accord
RuleList.Add(new ValidationRule <Measure[]>(measures,
m => m[0].Type == MeasureType.SILENCE &&
m[1].Type != MeasureType.ACCORD)
{
Number = n,
Measures = measures,
ErrorCode = ValidationError.HARMONY_NEXT_MEASUREMENT_TYPE_ACCORD_ERROR,
});
// - un accord ne peut être suivi d'un silence
RuleList.Add(new ValidationRule <Measure[]>(measures,
m => m[0].Type == MeasureType.ACCORD &&
m[1].Type == MeasureType.SILENCE)
{
Number = n,
Measures = measures,
ErrorCode = ValidationError.HARMONY_NEXT_MEASUREMENT_TYPE_EXC_ERROR,
});
// - si deux accords se suivent, ils doivent être au maximum espacés d'une note en hauteur
// Exemples:
// - un accord de B peut être suivi par un accord de A, B ou C
// - un accord de G peut être suivi par un accord de F, G ou A
RuleList.Add(new ValidationRule <Measure[]>(measures,
m => m[0].Type == MeasureType.ACCORD &&
m[1].Type == MeasureType.ACCORD &&
!AreConsecutiveNotes(measures[0][0], measures[1][0], step: 1))
{
Number = n,
Measures = measures,
ErrorCode = ValidationError.HARMONY_MEASUREMENT_HIGH_NOTE_SEP_ERROR,
});
}
/// <summary>
/// Executes the specified builderSource.
/// </summary>
/// <returns></returns>
/// ///
public RuleList BuildRules()
{
Rules = new RuleList();
foreach(var attribute in ValidationAttributes)
{
ValidationAttribute validation = (ValidationAttribute)attribute;
Rules.Add(validation.CreateRule(validation.Target));
}
return Rules;
}
/// <summary>
/// Adds a rule to the executer with an already known identifier
/// </summary>
/// <param name="identifier">Known unique identifier</param>
/// <param name="newRule">Rule to add</param>
/// <returns>Known unique identifier</returns>
public Guid AddRule(Guid identifier, Rule <TFact, TOutput> newRule)
{
RuleList.Add(identifier, newRule);
return(identifier);
}
//TODO disable enable rule
//TODO get and send db log to server
public void AddRuleToList(_m_USB_Watcher_Disable_Enable_Node RuleToAdd)
{
mUSBwdeDB.AddRuleToDB(RuleToAdd);
RuleList.Add(RuleToAdd);
}
//TODO disable enable rule
/// <summary>
/// Adds the rule to list.
/// </summary>
/// <param name="RuleToAdd">The rule to add.</param>
public void AddRuleToList(_m_Internet_Connection_Disable_Enable_Node RuleToAdd)
{
micdeDB.AddRuleToDB(RuleToAdd);
RuleList.Add(RuleToAdd);
}
