protected override Dictionary<PropertyEditor, RuleType> CollectPropertyEditors(IEnumerable<RuleSetValidationResultItem> result, RuleType ruleType) {
var propertyEditors = base.CollectPropertyEditors(result, ruleType);
foreach (var keyValuePair in propertyEditors.Where(IsNotCritical)) {
((BaseEdit)keyValuePair.Key.Control).ErrorIcon = CreateImageFromResources(keyValuePair.Value);
}
return propertyEditors;
}
public string ApplyModifiers(Modifier [] listModifiers, RuleType ruleType)
{
if (listModifiers == null) {
switch (ruleType){
case RuleType.RESULT:
return result_match;
case RuleType.FULL:
return full_match;
}
}
string result;
if (ruleType == RuleType.FULL) {
result = full_match;
foreach (Modifier modifier in listModifiers) {
result = ApplyModifier (result, modifier);
}
} else {
result = result_match;
foreach (Modifier modifier in listModifiers) {
result = ApplyModifier (result, modifier);
}
}
return result;
}
public Rule(RuleType T, Comparitor C, int V)
{
this.Type = T;
this.Compare = C;
this.Value = V;
this.SearchRadius = 1;
}
public Rule(Parser parser, RuleType ruleType, Predicate<Parser> lookAhead, RuleDelegate evaluate)
{
_parser = parser;
_ruleType = ruleType;
_lookAhead = lookAhead;
_evaluate = evaluate;
}
public TimeOffRequestRule(string ruleName, DTimeOffRequest timeOffRequest, IAssessor assessor, RuleType ruleType)
: base(-2, timeOffRequest.employee_id, ruleName, null, assessor, ruleType, ConstraintType.TimeOffRequest, timeOffRequest)
{
this.Id = int.Parse(string.Format("{0}{1}{2}", timeOffRequest.employee_id, timeOffRequest.week, timeOffRequest.days[0]));
this.Description = string.Format("Time off request by employee {0} for week {1} and days: {2}", timeOffRequest.employee_id, timeOffRequest.week, String.Join(",", timeOffRequest.days.ToArray()));
this.TimeOffRequest = timeOffRequest;
}
public NotifierRule(HotItem item, RuleType type, int value, ContextType contextType, INotificationHost host)
{
this.Host = host;
this.Money = new Money(0, 0, value) { Name = "Rule" };
this.Item = item;
this.SelectedRuleType = type;
this.ContextType = contextType;
}
internal void IgnoreRule(string propertyName, RuleType ruleType)
{
Rule found = Rules.Find(r => r.PropertyName == propertyName && r.RuleType == ruleType);
if (found != null)
{
found.ShouldIgnored = (() => true);
}
}
private Rule GenerateRule(RuleType type, string value) {
return new Rule {
Destination = _targetFolder,
MarkAsRead = false,
RuleName = "Learning-" + Guid.NewGuid(),
Type = type,
Value = value
};
}
protected override Dictionary<PropertyEditor, RuleType> CollectPropertyEditors(IEnumerable<RuleSetValidationResultItem> result, RuleType ruleType) {
var propertyEditors = base.CollectPropertyEditors(result, ruleType);
foreach (var keyValuePair in propertyEditors) {
var baseEdit = keyValuePair.Key.Control as BaseEdit;
if (baseEdit != null)
baseEdit.ErrorIcon = CreateImageFromResources(keyValuePair.Value);
}
return propertyEditors;
}
internal void IgnoreRuleOnCondition(string propertyName, RuleType ruleType, Func<bool> shouldIgnored)
{
Rule found = Rules.Find(r => r.PropertyName == propertyName && r.RuleType == ruleType);
if (found != null)
{
found.ShouldIgnored = shouldIgnored;
}
}
public ShiftRule(int id, int employeeId, string ruleName, string desc, IAssessor assessor, RuleType ruleType, ConstraintType constraintType, object refObject)
{
this.Id = id;
this.EmployeeId = employeeId;
this.Name = ruleName;
this.Assessor = assessor;
this.Description = desc;
this.ConstraintType = constraintType;
this.RuleType = ruleType;
this.Value = refObject;
}
public SelectionRule(string targetBrowserId, RuleType type, string ruleText)
{
TargetBrowserId = targetBrowserId;
_Type = type;
_RuleText = ruleText;
if (Type == RuleType.Regex)
{
RuleRegex = new Regex(ruleText, RegexOptions.CultureInvariant);
}
}
/// <summary>
/// Constructor of Filter.
/// </summary>
/// <param name="categories">A list of categories</param>
/// <param name="type">the rule</param>
public Filter(List<string> categories, RuleType type)
{
positiveCategories = new List<string>();
negativeCategories = new List<string>();
foreach (string item in categories)
{
if (item[0] != '!') positiveCategories.Add(item);
else negativeCategories.Add(item.Substring(1));
}
this.type = type;
}
/// <summary>
/// Constructeur d'une règle de validation
/// </summary>
/// <param name="codeMessage"> Identifiant de la règle ou code de règle </param>
/// <param name="description"> Informations de la règle </param>
/// <param name="severite"> Identification de la sévérité </param>
/// <param name="ruleType"> Type de règle de validation. </param>
/// <param name="parameter"> Paramètre utilisé pour la règle de validation. </param>
/// <param name="objectType"> Type d'objet à valider. </param>
/// <param name="validationObject"> Type de la classe de validation qui validera l'objet. </param>
/// <param name="allowNull"> Est-ce que la validation passera si le champ est Null. </param>
protected Rule(string codeMessage, string description, RuleSeverity severite, RuleType ruleType,
object parameter, Type objectType, Type validationObject, bool allowNull)
{
CodeMessage = codeMessage;
Description = description;
Severity = severite;
Type = ruleType;
Parameter = parameter;
AllowNull = allowNull;
ValidationObject = validationObject;
ObjectType = objectType;
}
private OperatorRule(RuleType ruleType, OperatorRule otherRule, Type type1)
{
_type = ruleType;
_type1 = type1;
if (otherRule != null)
{
if (otherRule._type == RuleType.OneIs && _type == RuleType.Specific ||
otherRule._type == RuleType.Specific && _type == RuleType.OneIs)
{
_type2 = otherRule._type1;
_type = RuleType.Specific;
}
}
}
public bool TryGetRuleType(Func<RuleIdMapItem, bool> predicate, out RuleType ruleType)
{
bool itemFound = false;
ruleType = default(RuleType);
RuleIdMapItem ruleMapItem = null;
ruleMapItem = m_MappingTable.SingleOrDefault(predicate);
if(ruleMapItem != null)
{
itemFound = true;
ruleType = ruleMapItem.MappedTo;
}
return itemFound;
}
protected override Dictionary<PropertyEditor, RuleType> CollectPropertyEditors(IEnumerable<DevExpress.Persistent.Validation.RuleSetValidationResultItem> result, RuleType ruleType) {
var dictionary = base.CollectPropertyEditors(result, ruleType);
foreach (var keyValuePair in dictionary) {
if (keyValuePair.Key.Control is TableEx) {
EventHandler[] eventHandler = { null };
var pair = keyValuePair;
eventHandler[0] = (sender, args) => {
var tableEx = ((TableEx)sender);
tableEx.PreRender -= eventHandler[0];
CreateRuleImage(pair, tableEx);
};
((TableEx)keyValuePair.Key.Control).PreRender += eventHandler[0];
}
}
return dictionary;
}
protected override Dictionary<PropertyEditor, RuleType> CollectPropertyEditors(IEnumerable<RuleSetValidationResultItem> result, RuleType ruleType) {
var dictionary = base.CollectPropertyEditors(result, ruleType);
foreach (var keyValuePair in dictionary.Where(pair => pair.Value!=RuleType.Critical)) {
var ex = keyValuePair.Key.Control as TableEx;
if (ex != null) {
EventHandler[] eventHandler = { null };
var pair = keyValuePair;
eventHandler[0] = (sender, args) => {
var tableEx = ((TableEx)sender);
tableEx.PreRender -= eventHandler[0];
CreateRuleImage(pair, tableEx);
};
ex.PreRender += eventHandler[0];
}
}
return dictionary;
}
public static Rule MakeRule(RuleType ruleType, PacketStatus ps, Direction dir, string args, bool log, bool notify)
{
switch (ruleType)
{
case RuleType.IP:
return GenIPRule(ps, args, dir, log, notify);
case RuleType.TCPALL:
return new TCPAllRule(ps, dir, log, notify);
case RuleType.TCPIPPORT:
return new TCPIPPortRule(ps, IPAddr.Parse(args.Split(' ')[0]), int.Parse(args.Split(' ')[1]), dir, log, notify);
case RuleType.TCPPORT:
return GenTCPPORT(ps, args, dir, log, notify);
case RuleType.UDPALL:
return new UDPAllRule(ps, dir, log, notify);
case RuleType.UDPPORT:
return GenUDPPORT(ps, args, dir, log, notify);
case RuleType.ALL:
return new AllRule(ps, dir, log, notify);
}
return null;
}
public RuleAlternate(RuleType ruleType)
{
_ruleType = ruleType;
}
protected virtual IShiftRule GetShiftRuleInstance(DTimeOffRequest request, RuleType type, ConstraintType constraintType)
{
IShiftRule ruleInstance = null;
IAssessor assessor = null;
assessor = new EmployeeTimeOffAssessor(request);
ruleInstance = new TimeOffRequestRule("TIME_OFF_REQUEST", request, assessor, type);
if (ruleInstance != null)
ruleInstance.Enabled = ruleInstance.IsRuleEnabled();
return ruleInstance;
}
protected virtual IShiftRule GetShiftRuleInstance(ShiftRuleValue shiftRuleValue, RuleType type, ConstraintType constraintType)
{
IShiftRule ruleInstance = null;
IAssessor assessor = null;
ShiftRuleDefinition ruleDefinition;
ruleDefinition = this.DataAccess.GetRuleDefinition(shiftRuleValue.rule_id);
switch (shiftRuleValue.rule_id)
{
case 2:
assessor = new MaxShiftsPerEmployeeInWeekAssessor(shiftRuleValue);
ruleInstance = new MaxEmployeeShiftsPerWeekRule(ruleDefinition, shiftRuleValue, assessor, type);
break;
case 4:
assessor = new MinShiftsPerEmployeeInWeekAssessor(shiftRuleValue);
ruleInstance = new MinEmployeeShiftsPerWeekRule(ruleDefinition, shiftRuleValue, assessor, type);
break;
case 7:
assessor = new EmployeesInShiftAssessor(shiftRuleValue.value);
ruleInstance = new MinEmployeesPerShiftRule(ruleDefinition, shiftRuleValue, assessor, type);
break;
default:
break;
}
if (ruleInstance != null)
ruleInstance.Enabled = ruleInstance.IsRuleEnabled();
return ruleInstance;
}
public CSSRule()
{
type_ = RuleType.UNKNOWN_RULE;
}
private static string CreateResourceName(NameType nameType, RuleType rt, string lang)
{
return(string.Format("{0}_{1}_{2}.txt",
nameType.GetName(), rt.GetName(), lang));
}
static void Main(string[] args)
{
Console.WriteLine("룰 타입을 선택하세요. (1:Basic, 2:Develop)");
int input = int.Parse(Console.ReadLine());
RuleType ruleType = (RuleType)input;
Printline();
List <Player> players = new List <Player>();
if (ruleType == RuleType.Basic)
{
players.Add(new RealPlayer());
players.Add(new ComputerPlayer());
}
else
{
for (int i = 0; i < 2; i++)
{
players.Add(new RealPlayer());
}
}
foreach (var player in players)
{
player.Money = SeedMoney;
}
int round = 1;
while (true)
{
Console.WriteLine();
Console.WriteLine();
Console.WriteLine();
// 한명이 오링이면 게임 종료
if (IsAnyoneOring(players))
{
break;
}
Console.WriteLine($"[Round {round}]을 진행합니다.");
Printline();
round++;
Dealer dealer = new Dealer();
// 학교 출석
foreach (var player in players)
{
player.Money -= BettingMoney;
dealer.PutMoney(BettingMoney);
}
// 카드 돌리기
foreach (var player in players)
{
player.Cards.Clear();
dealer.Cards.Clear();
for (int i = 0; i < 2; i++)
{
player.Cards.Add(dealer.DrawCard());
}
Console.WriteLine(player.GetCardText());
}
Printline();
Console.WriteLine("게임을 계속하시겠습니까? (1. 콜 2. 다이)");
Console.WriteLine("[콜] 하면 50원 추가 배팅 후 딜러 패 공개,");
Console.WriteLine("[다이]하면 모든 패 공개 후 패배로 처리.");
int sel = int.Parse(Console.ReadLine());
bool surren = Surren(sel);
//딜러 패 뽑기
dealer.Cards.Add(dealer.DrawCard());
//딜러가 뽑은 패 각자 덱으로 삽입
foreach (var player in players)
{
player.Cards.Add(dealer.DealerCard());
}
Printline();
//딜러가 뽑은 패 공개
Console.WriteLine(dealer.GetCardTextDealer());
Printline();
Console.WriteLine(players[0].GetCardText());
PrintMyGokbo(players);
Printline();
if (!surren)
{
foreach (var player in players)
{
player.Money -= CallBettingMoney;
dealer.PutMoney(CallBettingMoney);
}
Console.WriteLine("게임을 계속하시겠습니까? (1. 콜 2. 다이)");
Console.WriteLine("[콜]하면 모든 패 공개,");
Console.WriteLine("[다이]하면 패배로 처리.");
int finalsel = int.Parse(Console.ReadLine());
surren = Surren(finalsel);
Printline();
//무승부 찾기
if (Regame(players))
{
continue;
}
}
// 승자 찾기
Player winner = FindWinner(players, surren);
// 승자에게 상금 주기
winner.Money += dealer.GetMoney();
// 각 플레이어의 돈 출력
Printline();
foreach (var player in players)
{
Console.Write(player.Money + "\t");
}
Console.WriteLine();
Console.WriteLine("다음 라운드 진행을 위해 아무 숫자를 입력해 주세요.");
int nextRound = int.Parse(Console.ReadLine());
Printline();
}
}
public ParsesAsConstraint(RuleType ruleType, string[] expected)
: base(String.Join(Environment.NewLine, expected))
{
_ruleType = ruleType;
}
Image CreateImageFromResources(RuleType ruleType) {
return ImageLoader.Instance.GetEnumValueImageInfo(ruleType).Image;
}
/// <summary>
/// Initializes a new instance of the <see cref="ParserActionReduce"/> class.
/// </summary>
/// <param name="rule">The <see cref="RuleType"/> associated with this action.</param>
/// <remarks>
/// When this action is taken, elements will
/// be removed from the <see cref="ParserStack"/> based on <see cref="RuleType.Rhs"/> and a new
/// <see cref="ParserStackItem"/> containing a <see cref="Nonterminal"/> constructed by <see cref="RuleType.Lhs"/> will be added.
/// </remarks>
public ParserActionReduce(RuleType rule)
: base(ParserActionTypes.Reduce)
{
Rule = rule;
}
private IList <T> GetDirectives <T>(RuleType ruleType)
{
return(Rules.Where(r => r.RuleType == ruleType).Cast <T>().ToList());
}
public void AddRule(RuleType ruleType)
{
_alternates.Add(new RuleAlternate(ruleType));
}
/// <summary>
/// Function to find valid rule for Component from GameObject
/// </summary>
/// <param name="injector"></param>
/// <param name="gameObject"></param>
/// <param name="type"></param>
/// <param name="updateType"></param>
/// <returns></returns>
internal static bool FindComponentRule(Injector injector, GameObject gameObject, Type type, UpdateType updateType)
{
// Find relevant rule
Transform pointer = gameObject.transform;
do
{
// See if current GameObject has a NetworkModel Rule component
NetworkModelRule networkModelRule = pointer.GetComponent <NetworkModelRule>();
// If true, then a rule was found
if (networkModelRule != null)
{
// Check if the Rule was found in the passed GameObject
if (gameObject.transform == pointer)
{
// Check if the Rule is active for the GameObject it is attached to
if (networkModelRule.applyToObject)
{
// Get the correct Rule
RuleType ruleType = CheckComponentRule(networkModelRule, type, updateType);
// Check, if Rule is enabled
if (ruleType != RuleType.DISABLED)
{
return(ruleType.ToBool());
}
}
else
{
// Rule does not apply, continue with parent GameObject
pointer = pointer.parent;
continue;
}
}
// ELse, the Rule was found in a parent GameObject
else
{
// Check if the Rule is active for the GameObject it is attached to
if (networkModelRule.applyToChildren)
{
// Get the correct Rule
RuleType ruleType = CheckComponentRule(networkModelRule, type, updateType);
// Check, if Rule is enabled
if (ruleType != RuleType.DISABLED)
{
return(ruleType.ToBool());
}
}
else
{
// Rule does not apply, continue with parent GameObject
pointer = pointer.parent;
continue;
}
}
}
// Go one GameObject up in Hierarchy
pointer = pointer.parent;
} while (pointer != null);
LogUtility.Log(injector, LogType.INFORMATION, "No active rule found for Type " + type);
// Default value
return(RuleUtility.DEFAULT_RULE);
}
public async System.Threading.Tasks.Task <Guid> CreateConditionalDiscountAsync(Store store, string username, Guid storeId, RuleContext discountType, RuleType ruleType, double precent, string category = "", Guid productId = new Guid(),
double valueLessThan = int.MaxValue, double valueGreaterEQThan = 0, DateTime d1 = new DateTime(), DateTime d2 = new DateTime(), Guid originalDiscountId = new Guid())
{
if (store == null)
{
return(new Guid());
}
var d = CreateCalculator(discountType, precent, category, productId);
var r = CreateRule(discountType, ruleType, category, productId, valueLessThan, valueGreaterEQThan, d1, d2);
ConditionDiscount discount = new ConditionDiscount(d);
if (!originalDiscountId.Equals(new Guid()))
{
discount.Id = originalDiscountId;
}
discount.AddRule(r);
return(store.AddDiscount(username, discount));
}
public void writeXml(XmlWriter writer)
{
writer.WriteElementString("Type", RuleType.ToString());
writer.WriteElementString("Min", Min.ToString());
writer.WriteElementString("Max", Max.ToString());
}
public RuleAlternate(RuleType ruleType)
{
_ruleType = ruleType;
}
public void AddRule(RuleType ruleType)
{
_alternates.Add(new RuleAlternate(ruleType));
}
public AssetDeleter(RuleType rule, String UserName, Boolean DeleteAccount)
{
_rule = rule;
_userName = UserName;
_deleteAccount = DeleteAccount;
}
/// <summary>
/// Gets rules for a combination of name type, rule type and a single language.
/// <para/>
/// since 1.9
/// </summary>
/// <param name="nameType">The <see cref="NameType"/> to consider.</param>
/// <param name="rt">The <see cref="RuleType"/> to consider.</param>
/// <param name="lang">The language to consider.</param>
/// <returns>A map containing all <see cref="Rule"/>s that apply, grouped by the first character of the rule pattern.</returns>
public static IDictionary <string, IList <Rule> > GetInstanceMap(NameType nameType, RuleType rt,
string lang)
{
if (RULES.TryGetValue(nameType, out var nameTypes) && nameTypes != null &&
nameTypes.TryGetValue(rt, out var ruleTypes) && ruleTypes != null &&
ruleTypes.TryGetValue(lang, out var rules) && rules != null)
{
}
else
{
throw new ArgumentException(string.Format("No rules found for {0}, {1}, {2}.",
nameType.GetName(), rt.GetName(), lang));
}
return(rules);
}
public void StartRule(RuleType ruleType)
{
stack.Push(new AstNode(ruleType));
}
/// <summary>
/// Gets rules for a combination of name type, rule type and languages.
/// <para/>
/// since 1.9
/// </summary>
/// <param name="nameType">The <see cref="NameType"/> to consider.</param>
/// <param name="rt">The <see cref="RuleType"/> to consider.</param>
/// <param name="langs">The set of languages to consider.</param>
/// <returns>A map containing all <see cref="Rule"/>s that apply, grouped by the first character of the rule pattern.</returns>
public static IDictionary <string, IList <Rule> > GetInstanceMap(NameType nameType, RuleType rt,
LanguageSet langs)
{
return(langs.IsSingleton ? GetInstanceMap(nameType, rt, langs.GetAny()) :
GetInstanceMap(nameType, rt, Languages.ANY));
}
/// <summary>
/// Determines whether the specified <paramref name="item" /> matches the specified rule.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="rootProjectConfiguration">The root project configuration.</param>
/// <param name="ruleType">Type of the rule.</param>
/// <param name="targetProjectType">Type of the target project.</param>
/// <returns><c>true</c> if the item matches the rule; otherwise <c>false</c>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="item" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="rootProjectConfiguration" /> is <c>null</c>.</exception>
private bool MatchesRule(ProjectItem item, RootProject rootProjectConfiguration, RuleType ruleType, ProjectType targetProjectType)
{
Argument.IsNotNull("item", item);
Argument.IsNotNull("rootProjectConfiguration", rootProjectConfiguration);
foreach (var rule in rootProjectConfiguration.Rules)
{
if (rule.Type == ruleType)
{
if (string.Compare(rule.Name, item.GetNameRelativeToRoot()) == 0)
{
foreach (var ruledProjectType in rule.ProjectTypes)
{
if (ruledProjectType == targetProjectType)
{
return true;
}
}
}
}
}
return false;
}
private static PledgeRule CreateRule(List<int> indices, DataType dataType, RuleType ruleType, LogicType logicType, List<object> operands, EvaluationMode mode = EvaluationMode.Active)
{
return new PledgeRule
{
Columns = indices.Select(index => new Column {Index = index}).ToList(),
DataType = dataType,
RuleType = ruleType,
RuleId = Guid.NewGuid(),
LogicType = logicType,
Operands = operands,
Mode = mode,
Children = new List<PledgeRule>()
};
}
/// <summary>
/// Initializes a new instance of the <see cref="ParserActionAccept"/> class.
/// </summary>
/// <param name="rule">The <see cref="RuleType"/> associated with this action. The <see cref="NonterminalType.IsStart"/> property of <see cref="RuleType.Lhs"/> should
/// be <value>true</value>.</param>
public ParserActionAccept(RuleType rule)
: base(ParserActionTypes.Accept)
{
Rule = rule;
}
static void Main(string[] args)
{
Console.WriteLine("게임의 룰을 선택하세요. (1:기본룰, 2:확장룰, 3: 궁극의 룰)");
string inputText = Console.ReadLine();
int input = int.Parse(inputText);
RuleType ruleType = (RuleType)input;
// 각 선수들이 시드 머니를 가진다.
if (ruleType == RuleType.Basic)
{
Console.WriteLine("기본룰 모드로 경기를 시작합니다.");
List <BasicPlayer> players = new List <BasicPlayer>();
for (int i = 0; i < PlayerCount; i++)
{
players.Add(new BasicPlayer(SeedMoney));
}
int round = 1;
// 선수 중 파산(오링)하는 사람이 있을 때 까지 라운드를 진행한다.
while (true)
{
if (BasicRule.CanRunRound(players) == false)
{
break;
}
Console.WriteLine($"[Round {round++}]");
// 라운드를 진행한다
BasicRule.RunRound(players);
// 선수들이 가진 돈을 출력한다.
BasicRule.PrintMoney(players);
Console.WriteLine();
}
}
else if (ruleType == RuleType.Advanced)
{
Console.WriteLine("확장룰 모드로 경기를 시작합니다.");
List <Player> players = new List <Player>();
players.Add(new Human(SeedMoney));
for (int i = 0; i < PlayerCount - 1; i++)
{
players.Add(new Computer(SeedMoney));
}
int round = 1;
int winnerNo = 0;
winnerNo = AdvancedRule.DecideOrder(players);
Console.WriteLine($" 선 플레이어는 P[{winnerNo}] 입니다.");
// 선수 중 파산(오링)하는 사람이 있을 때 까지 라운드를 진행한다.
while (true)
{
if (AdvancedRule.CanRunRound(players) == false)
{
//Console.WriteLine($"P[{AdvancedRule.FindTajja(players)}]는 타짜!");
Console.WriteLine($"P[{AdvancedRule.FindBankrupt(players)}]는 파산자!");
break;
}
Console.WriteLine($"[Round {round++}]");
// 라운드를 진행한다
winnerNo = AdvancedRule.RunRound(players, winnerNo);
// 선수들이 가진 돈을 출력한다.
AdvancedRule.PrintMoney(players);
Console.WriteLine();
}
}
else if (ruleType == RuleType.Ultimate)
{
Console.WriteLine("궁극의 룰 모드로 경기를 시작합니다.");
List <Player> players = new List <Player>();
players.Add(new Human(SeedMoney));
for (int i = 0; i < PlayerCount - 1; i++)
{
players.Add(new Computer(SeedMoney));
}
int round = 1;
int winnerNo = 0;
Console.WriteLine("먼저 첫번째 카드를 뽑아 경기 순서를 결정합니다.");
winnerNo = UltimateRule.DecideOrder(players);
Console.WriteLine($" 선 플레이어는 P[{winnerNo}] 입니다.");
Console.WriteLine();
// 선수 중 파산(오링)하는 사람이 있을 때 까지 라운드를 진행한다.
while (true)
{
if (UltimateRule.CanRunRound(players) == false)
{
break;
}
Console.WriteLine($"[Round {round++}]");
// 라운드를 진행한다
winnerNo = UltimateRule.RunRound(players, winnerNo);
// 선수들이 가진 돈을 출력한다.
UltimateRule.PrintMoney(players);
Console.WriteLine();
}
}
}
public RuleTypeAttribute(string id, RuleType ruleType) {
_id = id;
_ruleType = ruleType;
}
public async Task AddPolicyRule(Store store, string username, Guid storeId, PolicyRuleRelation policyRuleRelation, RuleContext ruleContext, RuleType ruleType, string category = "", Guid productId = new Guid(),
double valueLessThan = int.MaxValue, double valueGreaterEQThan = 0, DateTime d1 = new DateTime(), DateTime d2 = new DateTime())
{
if (store == null)
{
return;
}
var r = CreateRule(ruleContext, ruleType, category, productId, valueLessThan, valueGreaterEQThan, d1, d2);
switch (policyRuleRelation)
{
case PolicyRuleRelation.Simple:
await CreateRuleToStoreAsync(store, username, storeId, r);
break;
case PolicyRuleRelation.And:
await GeneratePolicyAndRuleAsync(store, username, storeId, r);
break;
case PolicyRuleRelation.Or:
await GeneratePolicyOrRuleAsync(store, username, storeId, r);
break;
default:
await GeneratePolicyConditionRuleAsync(store, username, storeId, r);
break;
}
}
