private void OneOf(IElementContainer subContainer, params Expression <Action <IRule> >[] actions)
{
IAlternatives alternatives = new Alternatives();
SaveCurrentContainer();
SetContainer(subContainer ?? alternatives);
// If there is more than one action, then
// we need to "alternate" between them
if (actions.Length > 1 && subContainer != null)
{
subContainer.AddElement(alternatives);
SetContainer(alternatives);
}
SaveCurrentSequence();
foreach (var action in actions)
{
ResetSequence();
action.Compile()(this);
}
RestoreSequence();
RestoreContainer();
AddElementToContainer(subContainer ?? alternatives);
}
public ItemSet Copy()
{
string newName = ParentPage.ParentTest.GetFreeName(Name);
var tmp = new ItemSet(newName, ParentPage, GridPosition, Size, false);
tmp.Border = Border;
tmp.ItemsNaming = ItemsNaming;
foreach (Item it in Items)
{
tmp.AddItem(it.Copy());
}
tmp.AlternativesNaming = AlternativesNaming;
string[] altNames = new string[NumberOfAlternatives];
Alternatives.CopyTo(altNames, 0);
tmp.SetAlternatives(altNames.ToList());
tmp.NumberOfCheckedAlternativesAllowed = NumberOfCheckedAlternativesAllowed;
tmp.ApplyScoreTooManyAlternatives = ApplyScoreTooManyAlternatives;
tmp.ScoreIfTooManyAlternativesAreChecked = ScoreIfTooManyAlternativesAreChecked;
tmp.Description = Description;
tmp.Columns = Columns;
return(tmp);
}
public void delete_Update_View_BoatFromList(Alternatives action)
{
List <Model.Member> memberList = this._database.LoadMemberList();
memberList = delete_Update_View_BoatDetails(memberList, action);
this._database.saveAllToFile(memberList);
}
//Function to Get Alternative Flight Data From DocumentDb
public async Task CallAlternateFlights(IDialogContext context)
{
try
{
IEnumerable <Alternatives> alternativesdata = null;
this.alternatives = null;
using (var httpClient = new HttpClient())
{
var response = await httpClient.GetAsync(ConfigurationManager.AppSettings[Constants.KeyApi] + "/alternatives/" + this.PNRCode);
object DeserializeResult = JsonConvert.DeserializeObject(await response.Content.ReadAsStringAsync());
alternativesdata = JsonConvert.DeserializeObject <IEnumerable <Alternatives> >(DeserializeResult.ToString());
}
foreach (Alternatives alternateFlights in alternativesdata)
{
this.alternatives = alternateFlights;
}
if (this.alternatives != null)
{
await this.DisplayAlternateFlights(context);
}
else
{
await context.PostAsync(Locale.AlternativeFlightErrorMsg);
context.Wait(OnComplete);
}
}
catch (Exception ex)
{
await context.PostAsync($"Failed with message: {ex.Message}");
}
}
public UnionAlternative AddAlternative(DataType dt)
{
var alt = new UnionAlternative(dt, Alternatives.Count);
Alternatives.Add(alt);
return(alt);
}
public UnionType(string name, DataType preferredType, params DataType [] alternatives) : base(name)
{
this.PreferredType = preferredType;
foreach (DataType dt in alternatives)
{
Alternatives.Add(new UnionAlternative(dt));
}
}
public void SelectBest() // Select the best fragment with the highest relevance which is not disabled (that is, compatible with other selections)
{
var relevantAlternatives = Alternatives.Where(f => f.IsRelevant == true);
double bestRelevance = relevantAlternatives.Max(f => f.Relevance);
RecommendedFragment <T> bestFragment = relevantAlternatives.First(f => f.Relevance == bestRelevance);
SelectedFragment = bestFragment; // Can be null which means reset selection
}
public Experiment(string testName, params string[] alternatives)
: this(testName)
{
foreach (string alt in alternatives)
{
Alternatives.Add(new ABAlternative(alt));
}
}
public UnionType(string name, DataType preferredType, ICollection <DataType> alternatives) : base(name)
{
this.Name = name; this.PreferredType = preferredType;
foreach (DataType dt in alternatives)
{
Alternatives.Add(new UnionAlternative(dt));
}
}
private void UpdateAlternatives(List <string> alternatives)
{
for (int index = 0; index < alternatives.Count; index++)
{
var label = _drawHelper.DrawLabel(index, alternatives[index]);
Alternatives.Add(label);
}
}
public ReferenceRankingTabViewModel(ReferenceRanking referenceRanking, Alternatives alternatives)
{
Name = "Reference Ranking";
ReferenceRanking = referenceRanking;
Alternatives = alternatives;
AlternativesWithoutRanksCollectionView = new ListCollectionView(Alternatives.AlternativesCollection)
{
Filter = o => ((Alternative)o).ReferenceRank == null
};
ReferenceRanking.PropertyChanged += (sender, args) =>
{
if (args.PropertyName != nameof(ReferenceRanking.RankingsCollection))
{
return;
}
RefreshFilter();
InitializeReferenceRankFilterWatchers();
};
Alternatives.PropertyChanged += (sender, args) =>
{
if (args.PropertyName != nameof(Alternatives.AlternativesCollection))
{
return;
}
AlternativesWithoutRanksCollectionView = new ListCollectionView(Alternatives.AlternativesCollection)
{
Filter = o => ((Alternative)o).ReferenceRank == null
};
};
InitializeReferenceRankFilterWatchers();
NewRank = new ObservableCollection <Alternative>();
NewRank.CollectionChanged += (sender, args) =>
{
if (args.Action != NotifyCollectionChangedAction.Add)
{
return;
}
// NewRank is cleared by AlternativeDroppedOnNewRank event handler, so we always have only one item in this collection
ReferenceRanking.AddAlternativeToRank(NewRank[0], ReferenceRanking.RankingsCollection.Count);
};
RemoveRankCommand = new RelayCommand(rank => ReferenceRanking.RemoveRank((int)rank));
RemoveAlternativeFromRankCommand = new RelayCommand(alternative =>
{
var alternativeToRemove = (Alternative)alternative;
if (alternativeToRemove.ReferenceRank != null)
{
ReferenceRanking.RemoveAlternativeFromRank(alternativeToRemove, (int)alternativeToRemove.ReferenceRank);
}
});
}
public IActionableRule SayOneOf(IEnumerable <String> words)
{
var alternatives = new Alternatives();
alternatives.AddElements(words.Select(w => new WordElement(w)));
AddElementToContainer(alternatives);
return((ActionableRule)this);
}
private void CleanAlternatives()
{
for (int i = 0; i < Alternatives.Count; i++)
{
if (String.IsNullOrWhiteSpace(Alternatives[i].Name))
{
Alternatives.Remove(Alternatives[i]);
}
}
}
public MainViewModel(IDialogCoordinator dialogCoordinator)
{
Criteria = new Criteria();
Alternatives = new Alternatives(Criteria);
Results = new Results();
_dialogCoordinator = dialogCoordinator;
_saveData = new SaveData(null, null);
Tabs = new ObservableCollection <ITab>();
Tabs.CollectionChanged += TabsCollectionChanged;
ShowTabCommand = new RelayCommand(tabViewModel => ShowTab((ITab)tabViewModel));
ShowKeeneyRaiffaFunctionDialog =
new RelayCommand(_ => new KeeneyRaiffaFunctionDialogView(Results.Formula).ShowDialog(),
formula => formula != null);
CriteriaTabViewModel = new CriteriaTabViewModel(Criteria);
AlternativesTabViewModel = new AlternativesTabViewModel(Criteria, Alternatives);
WelcomeTabViewModel = new WelcomeTabViewModel();
SettingsTabViewModel = new SettingsTabViewModel();
PartialUtilityTabViewModels = new ObservableCollection <PartialUtilityTabViewModel>();
Criteria.CriteriaCollection.CollectionChanged += InstancePropertyChanged;
Alternatives.AlternativesCollection.CollectionChanged += InstancePropertyChanged;
Results.FinalRanking.FinalRankingCollection.CollectionChanged += InstancePropertyChanged;
Criteria.PropertyChanged += (sender, args) =>
{
if (args.PropertyName != nameof(Criteria.CriteriaCollection))
{
return;
}
InstancePropertyChanged();
Criteria.CriteriaCollection.CollectionChanged += InstancePropertyChanged;
};
Alternatives.PropertyChanged += (sender, args) =>
{
if (args.PropertyName != nameof(Alternatives.AlternativesCollection))
{
return;
}
InstancePropertyChanged();
Alternatives.AlternativesCollection.CollectionChanged += InstancePropertyChanged;
};
Results.FinalRanking.PropertyChanged += (sender, args) =>
{
if (args.PropertyName != nameof(Results.FinalRanking.FinalRankingCollection))
{
return;
}
InstancePropertyChanged();
Results.FinalRanking.FinalRankingCollection.CollectionChanged += InstancePropertyChanged;
};
}
private void LoadAlternatives(IEAElement element)
{
Alternatives.Clear();
IEnumerable <IDecisionRelation> alternatives =
element.FindConnectors(EAConstants.RelationMetaType, EAConstants.RelationAlternativeFor)
.Select(a => (IDecisionRelation) new DecisionRelation(this, a));
foreach (IDecisionRelation alternative in alternatives)
{
Alternatives.Add(alternative);
}
}
public override int GetHashCode()
{
unchecked
{
int result = (_name != null ? _name.GetHashCode() : 0);
result = (result * 397) ^ (_description != null ? _description.GetHashCode() : 0);
result = (result * 397) ^ _sequence.GetHashCode();
result = (result * 397) ^ Alternatives.GetHashCodeDeep();
result = (result * 397) ^ IsDecoy.GetHashCode();
return(result);
}
}
public NonterminalSymbol(string name, string[][] alts)
{
Name = name;
for (int i = 0; i < alts.Length; ++i)
{
var newAlt = new Alternative()
{
NonterminalSymbolName = name
};
for (int j = 0; j < alts[i].Length; ++j)
{
newAlt.Add(alts[i][j]);
}
Alternatives.Add(newAlt);
}
}
private static string Prioritise(MetadataType priority, Alternatives alternatives)
{
switch (priority)
{
case MetadataType.OpenGraph:
return(alternatives.OpenGraph
.Or(alternatives.Twitter)
.Or(alternatives.Generic));
case MetadataType.Twitter:
return(alternatives.Twitter
.Or(alternatives.OpenGraph)
.Or(alternatives.Generic));
default:
return(alternatives.Generic
.Or(alternatives.OpenGraph)
.Or(alternatives.Twitter));
}
}
public AlternativesTabViewModel(Criteria criteria, Alternatives alternatives)
{
Name = "Alternatives";
Criteria = criteria;
Alternatives = alternatives;
Criteria.PropertyChanged += (sender, args) =>
{
if (args.PropertyName != nameof(Criteria.CriteriaCollection))
{
return;
}
InitializeNewAlternative();
InitializeNewAlternativeCriterionValuesUpdaterWatcher();
};
Alternatives.PropertyChanged += (sender, args) =>
{
if (args.PropertyName != nameof(Alternatives.AlternativesCollection))
{
return;
}
InitializeAlternativeIndexToShowWatcher();
};
InitializeNewAlternative();
InitializeNewAlternativeCriterionValuesUpdaterWatcher();
InitializeAlternativeIndexToShowWatcher();
RemoveAlternativeCommand =
new RelayCommand(alternative => Alternatives.AlternativesCollection.Remove((Alternative)alternative));
AddAlternativeCommand = new RelayCommand(_ =>
{
NewAlternative.Name = NewAlternative.Name.Trim(' ');
Alternatives.AlternativesCollection.Add(NewAlternative);
InitializeNewAlternative();
}, bindingGroup => !((BindingGroup)bindingGroup).HasValidationError && NewAlternative.Name != "" &&
NewAlternative.CriteriaValuesList.All(criterionValue => criterionValue.Value != null));
}
private void SaveAlternatives(IEAElement element)
{
IEARepository repository = EAMain.Repository;
IEnumerable <string> deleted =
element.FindConnectors(EAConstants.RelationMetaType, EAConstants.RelationAlternativeFor)
.Select(c => c.GUID)
.Except(Alternatives.Select(a => a.RelationGUID));
foreach (string connector in deleted)
{
element.RemoveConnector(repository.GetConnectorByGUID(connector));
}
foreach (IDecisionRelation connector in Alternatives)
{
if ("".Equals(connector.RelationGUID) || null == connector.RelationGUID)
{
IEAElement client = repository.GetElementByGUID(connector.Decision.GUID);
IEAElement supplier = repository.GetElementByGUID(connector.RelatedDecision.GUID);
client.ConnectTo(supplier, EAConstants.RelationMetaType, connector.Type);
}
}
}
public async Task RulesTest()
{
var saveObjects = await _index.SaveObjectsAsync(new List <MobilePhone>
{
new MobilePhone {
ObjectID = "iphone_7", Brand = "Apple", Model = "7"
},
new MobilePhone {
ObjectID = "iphone_8", Brand = "Apple", Model = "8"
},
new MobilePhone {
ObjectID = "iphone_x", Brand = "Apple", Model = "X"
},
new MobilePhone {
ObjectID = "one_plus_one", Brand = "OnePlus", Model = "One"
},
new MobilePhone {
ObjectID = "one_plus_two", Brand = "OnePlus", Model = "Two"
}
});
// Set attributesForFaceting to [“brand”] using setSettings and collect the taskID
IndexSettings settings =
new IndexSettings {
AttributesForFaceting = new List <string> {
"brand", "model"
}
};
var setSettingsResponse = await _index.SetSettingsAsync(settings);
saveObjects.Wait();
setSettingsResponse.Wait();
Rule ruleToSave = new Rule
{
ObjectID = "brand_automatic_faceting",
Enabled = false,
#pragma warning disable 612, 618
Condition = new Condition {
Anchoring = "is", Pattern = "{facet:brand}"
},
#pragma warning restore 612, 618
Consequence = new Consequence
{
FilterPromotes = false,
Params = new ConsequenceParams
{
AutomaticFacetFilters = new List <AutomaticFacetFilter>
{
new AutomaticFacetFilter {
Facet = "brand", Disjunctive = true, Score = 42
}
}
}
},
Validity = new List <TimeRange>
{
new TimeRange
{
From = DateTimeHelper.UnixTimeToDateTime(1532439300), // 07/24/2018 13:35:00 UTC
Until = DateTimeHelper.UnixTimeToDateTime(1532525700) // 07/25/2018 13:35:00 UTC
},
new TimeRange
{
From = DateTimeHelper.UnixTimeToDateTime(1532612100), // 07/26/2018 13:35:00 UTC
Until = DateTimeHelper.UnixTimeToDateTime(1532698500) // 07/27/2018 13:35:00 UTC
}
},
Description = "Automatic apply the faceting on `brand` if a brand value is found in the query"
};
var saveRuleResponse = await _index.SaveRuleAsync(ruleToSave);
Rule ruleToSave2 = new Rule
{
ObjectID = "query_edits",
Conditions = new List <Condition>
{
new Condition
{
Anchoring = "is",
Pattern = "mobile phone",
Alternatives = Alternatives.Of(true)
},
},
Consequence = new Consequence
{
Params = new ConsequenceParams
{
Query = new ConsequenceQuery
{
Edits = new List <Edit>
{
new Edit {
Type = EditType.Remove, Delete = "mobile"
},
new Edit
{
Type = EditType.Replace, Delete = "phone", Insert = "ihpone"
},
}
}
}
}
};
Rule ruleToSave3 = new Rule
{
ObjectID = "query_promo",
Consequence = new Consequence {
Params = new ConsequenceParams {
Filters = "brand:OnePlus"
}
}
};
Rule ruleToSave4 = new Rule
{
ObjectID = "query_promo_only_summer",
#pragma warning disable 612, 618
Condition = new Condition {
Context = "summer"
},
#pragma warning restore 612, 618
Consequence = new Consequence {
Params = new ConsequenceParams {
Filters = "model:One"
}
}
};
var batchRulesResponse =
await _index.SaveRulesAsync(new List <Rule> {
ruleToSave2, ruleToSave3, ruleToSave4
});
saveRuleResponse.Wait();
batchRulesResponse.Wait();
// Retrieve all the rules using getRule and check that they were correctly saved
var getRuleToSave = _index.GetRuleAsync(ruleToSave.ObjectID);
var getRuleToSave2 = _index.GetRuleAsync(ruleToSave2.ObjectID);
var getRuleToSave3 = _index.GetRuleAsync(ruleToSave3.ObjectID);
var getRuleToSave4 = _index.GetRuleAsync(ruleToSave4.ObjectID);
Rule[] tasks = await Task.WhenAll(getRuleToSave, getRuleToSave2, getRuleToSave3, getRuleToSave4);
Assert.True(TestHelper.AreObjectsEqual(ruleToSave, tasks[0]));
Assert.True(TestHelper.AreObjectsEqual(ruleToSave2, tasks[1]));
Assert.True(TestHelper.AreObjectsEqual(ruleToSave3, tasks[2]));
Assert.True(TestHelper.AreObjectsEqual(ruleToSave4, tasks[3]));
var searchWithContext =
await _index.SearchAsync <MobilePhone>(new Query { RuleContexts = new List <string> {
"summer"
} });
Assert.That(searchWithContext.Hits, Has.Exactly(1).Items);
SearchResponse <Rule> searchRules = await _index.SearchRuleAsync(new RuleQuery());
Assert.That(searchRules.Hits, Has.Exactly(4).Items);
Assert.True(TestHelper.AreObjectsEqual(ruleToSave,
searchRules.Hits.Find(r => r.ObjectID.Equals(ruleToSave.ObjectID))));
Assert.True(TestHelper.AreObjectsEqual(ruleToSave2,
searchRules.Hits.Find(r => r.ObjectID.Equals(ruleToSave2.ObjectID))));
// Iterate over all the rules using ruleIterator and check that they were correctly saved
List <Rule> rulesFromIterator = new RulesIterator(_index).ToList();
Assert.True(TestHelper.AreObjectsEqual(ruleToSave,
rulesFromIterator.Find(r => r.ObjectID.Equals(ruleToSave.ObjectID))));
Assert.True(TestHelper.AreObjectsEqual(ruleToSave2,
rulesFromIterator.Find(r => r.ObjectID.Equals(ruleToSave2.ObjectID))));
Assert.True(TestHelper.AreObjectsEqual(ruleToSave3,
rulesFromIterator.Find(r => r.ObjectID.Equals(ruleToSave3.ObjectID))));
Assert.True(TestHelper.AreObjectsEqual(ruleToSave4,
rulesFromIterator.Find(r => r.ObjectID.Equals(ruleToSave4.ObjectID))));
// Delete the first rule using deleteRule and check that it was correctly deleted
var deleteRule = await _index.DeleteRuleAsync(ruleToSave.ObjectID);
deleteRule.Wait();
SearchResponse <Rule> searchRulesAfterDelete = await _index.SearchRuleAsync(new RuleQuery());
Assert.That(searchRulesAfterDelete.Hits, Has.Exactly(3).Items);
Assert.IsFalse(searchRulesAfterDelete.Hits.Exists(r => r.ObjectID.Equals(ruleToSave.ObjectID)));
// Clear all the remaining rules using clearRules and check that all rules have been correctly removed
var clearRule = await _index.ClearRulesAsync();
clearRule.Wait();
SearchResponse <Rule> searchRulesAfterClear = await _index.SearchRuleAsync(new RuleQuery());
Assert.That(searchRulesAfterClear.Hits, Is.Empty);
}
public ulong FactorialWhileWithoutArrayAndCountingArrayLength()
{
return(Alternatives.FactorialWhileLoopWithoutArrayAndCountingArrayLength(FactorialNumber));
}
private List <Model.Member> delete_Update_View_BoatDetails(List <Model.Member> viewMemberList, Alternatives action)
{
string id = this._boatView.getIDInput("The boat owner's 6-character ID: ");
for (int i = 0; i < viewMemberList.Count; i++)
{
if (viewMemberList[i].MemberID == id)
{
this._boatView.messageForSuccess("Member " + viewMemberList[i].Name + " successfully retrieved!");
if (action == Alternatives.Delete)
{
this.deleteBoat(viewMemberList[i]);
}
if (action == Alternatives.Update)
{
this.updateBoatOnList(viewMemberList[i]);
}
if (action == Alternatives.View)
{
this._boatView.viewMemberBoats(viewMemberList[i]);
}
return(viewMemberList);
}
}
this._boatView.messageForError("No matching member!");
return(viewMemberList);
}
public ulong FactorialOnly21()
{
return(Alternatives.FactorialWithDirectArrayAccess(FactorialNumber));
}
public override string ToString()
{
Dictionary <string, string> parameters = new Dictionary <string, string>();
//adding required parrameters
if (Origin != null)
{
parameters.Add("origin", Origin.ToString());
}
if (Destination != null)
{
parameters.Add("destination", value: Destination.ToString());
}
if (!string.IsNullOrEmpty(Key))
{
parameters.Add("key", Key);
}
//adding optional parametres
if (TravelMode != null)
{
parameters.Add("mode", TravelMode.Value.ToString());
}
if (WayPoints != null && WayPoints.Count > 0)
{
parameters.Add("waypoints", string.Join("|", WayPoints.Distinct().Select(d => d.ToString())));
}
if (Alternatives)
{
parameters.Add("alternatives", Alternatives.ToString());
}
if (Avoid != null)
{
parameters.Add("avoid", string.Join("|", Avoid.Distinct().Select(d => d.ToString())));
}
if (!string.IsNullOrEmpty(Language))
{
parameters.Add("language", Language);
}
if (Units is UnitSystem.imperial)
{
parameters.Add("units", Units.ToString());
}
if (!string.IsNullOrEmpty(Region))
{
parameters.Add("region", Region);
}
if (!string.IsNullOrEmpty(ArrivalTime))
{
parameters.Add("arrival_time",
_ArrivalTime - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc) != null
? Math.Floor((_ArrivalTime.Value.ToUniversalTime() - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds).ToString(CultureInfo.InvariantCulture)
: null);
}
if (!string.IsNullOrEmpty(DepartureTime))
{
parameters.Add("departure_time",
_DepartureTime != null
?Math.Floor((_DepartureTime.Value.ToUniversalTime() - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc))
.TotalSeconds).ToString(CultureInfo.InvariantCulture)
: null);
}
if (TrafficModel != null)
{
parameters.Add("traffic_model", TrafficModel.ToString());
}
if (TransitMode != null)
{
parameters.Add("transit_mode", string.Join("|", TransitMode.Distinct().Select(d => d.ToString())));
}
if (TransitRoutingPreferences != null)
{
parameters.Add("transit_routing_preference", TransitRoutingPreferences.ToString());
}
return(string.Join("&", parameters.Select(d => d.Key + "=" + d.Value)));
}
public ulong FactorialWhileWithoutArray()
{
return(Alternatives.FactorialWhileLoopWithoutArray(FactorialNumber));
}
public void Add(Alternative alt)
{
Alternatives.Add(alt);
}
public List <Alternative> .Enumerator GetEnumerator()
{
return(Alternatives.GetEnumerator());
}
void main()
{
println("starting connection...");
TcpClient tcp = null;
try
{
tcp = new TcpClient(hostTextBox.Text, Int32.Parse(portTextBox.Text));
tcp.NoDelay = true;
}
catch (SocketException e)
{
println("failed to connect.");
println(e.Message);
enableConnectButton();
return;
}
println("connected.");
using (var reader = new StreamReader(tcp.GetStream()))
using (var writer = new StreamWriter(tcp.GetStream()))
{
while (true)
{
string line = reader.ReadLine();
if (line == null)
{
continue;
}
println(string.Format("<-\t{0}", line));
var json = DynamicJson.Parse(line);
object response = null;
int pai;
int actor;
switch ((string)json.type)
{
case "hello":
response = Protocol.join(nameTextBox.Text, roomTextBox.Text);
break;
case "start_game":
id = (int)json.id;
names = ((string[])json.names).ToList <string>();
scores = new List <int>();
for (int i = 0; i < 4; i++)
{
scores.Add(25000);
}
response = Protocol.none();
break;
case "end_game":
goto endwhile;
case "start_kyoku":
kyoku = (int)json.kyoku;
honba = (int)json.honba;
kyotaku = (int)json.kyotaku;
tehais = (((string[][])json.tehais).Select <string[], List <int> >(tehai => (tehai.Select <string, int>(parsePai)).ToList <int>())).ToList <List <int> >();
kawas = new List <List <int> >();
for (int i = 0; i < 4; i++)
{
kawas.Add(new List <int>());
}
reaches = new List <int>();
for (int i = 0; i < 4; i++)
{
reaches.Add(-1);
}
fuross = new List <List <Furo> >();
for (int i = 0; i < 4; i++)
{
fuross.Add(new List <Furo>());
}
kawaNakares = new List <List <int> >();
for (int i = 0; i < 4; i++)
{
kawaNakares.Add(new List <int>());
}
doras = new List <int>();
doras.Add(parsePai((string)json.dora_marker));
response = Protocol.none();
break;
case "tsumo":
if ((int)json.actor == id)
{
pai = parsePai((string)json.pai);
tehais[id].Add(pai);
int shanten = Algorithm.shanten(tehais[id]);
println(shanten.ToString());
alternatives = new List <Alternatives>();
if (shanten == -1)
{
alternatives.Add(Alternatives.Tsumo);
}
if (fuross[id].Count == 0 && shanten <= 0 && reaches[id] == -1)
{
alternatives.Add(Alternatives.Reach);
}
if (reaches[id] != -1)
{
availablePai = Enumerable.Repeat(false, 14).ToList();
availablePai[tehais[id].Count - 1] = true;
}
else
{
availablePai = Enumerable.Repeat(true, 14).ToList();
}
if (alternatives.Any(_ => _ == Alternatives.Tsumo) && autoHora.Checked)
{
response = Protocol.hora(id, id, pai);
}
else if (reaches[id] != -1)
{
response = Protocol.dahai(id, pai, true);
tehais[id].RemoveAt(tehais[id].Count - 1);
kawas[id].Add(pai);
}
else
{
state = State.Dahai;
selection = Selection.Yet;
selected = -1;
BeginInvoke(new MethodInvoker(draw));
while (true)
{
if (selection != Selection.Yet)
{
break;
}
Thread.Sleep(1);
}
state = State.Idle;
if (selection == Selection.PaiClick)
{
var sute = tehais[id][selected];
response = Protocol.dahai(id, sute, selected == tehais[id].Count - 1);
tehais[id].Remove(sute);
tehais[id].Sort(new Comparison <int>(comparePai));
kawas[id].Add(sute);
}
else if (selection == Selection.ButtonClick)
{
Alternatives alt = alternatives[selected];
if (alt == Alternatives.Tsumo)
{
response = Protocol.hora(id, id, pai);
}
else if (alt == Alternatives.Reach)
{
response = Protocol.reach(id);
}
}
}
}
else
{
tehais[(int)json.actor].Add(parsePai((string)json.pai));
response = Protocol.none();
}
availablePai = Enumerable.Repeat(reaches[id] == -1, 14).ToList();
break;
case "reach":
actor = (int)json.actor;
if (actor != id)
{
response = Protocol.none();
}
else
{
alternatives = new List <Alternatives>();
state = State.Dahai;
selection = Selection.Yet;
selected = -1;
for (int i = 0; i < tehais[id].Count; i++)
{
availablePai[i] = Algorithm.shanten(tehais[id].Take(i).Concat(tehais[id].Skip(i + 1))) == 0;
}
while (true)
{
if (selection != Selection.Yet)
{
break;
}
Thread.Sleep(1);
}
state = State.Idle;
var sute = tehais[id][selected];
response = Protocol.dahai(id, sute, selected == tehais[id].Count - 1);
tehais[id].Remove(sute);
tehais[id].Sort(new Comparison <int>(comparePai));
kawas[id].Add(sute);
}
availablePai = Enumerable.Repeat(reaches[id] == -1, 14).ToList();
break;
case "reach_accepted":
actor = (int)json.actor;
reaches[actor] = kawas[actor].Count - 1;
scores = (List <int>)json.scores;
response = Protocol.none();
break;
case "dahai":
actor = (int)json.actor;
pai = parsePai((string)json.pai);
if (actor != id)
{
if ((bool)json.tsumogiri)
{
tehais[actor].RemoveAt(tehais[actor].Count - 1);
kawas[actor].Add(pai);
}
else
{
int index = new Random().Next(tehais[actor].Count);
tehais[actor].RemoveAt(index);
kawas[actor].Add(pai);
}
alternatives = new List <Alternatives>()
{
Alternatives.Pass
};
if (Algorithm.shanten(tehais[id].Concat(new[] { pai })) == -1)
{
alternatives.Add(Alternatives.Ron);
}
if (reaches[id] == -1 && (actor - id + 4) % 4 == 3 && Algorithm.canChi(tehais[id], pai))
{
alternatives.Add(Alternatives.Chi);
}
if (reaches[id] == -1 && Algorithm.canPon(tehais[id], pai))
{
alternatives.Add(Alternatives.Pon);
}
if (reaches[id] == -1 && Algorithm.canKan(tehais[id], pai))
{
alternatives.Add(Alternatives.Kan);
}
if (alternatives.Any(_ => _ == Alternatives.Ron && autoHora.Checked))
{
response = response = Protocol.hora(id, actor, pai);
}
else if (alternatives.Count == 1 || nakiNashi.Checked)
{
response = Protocol.none();
}
else
{
selection = Selection.Yet;
selected = -1;
state = State.Naki;
availablePai = Enumerable.Repeat(false, 14).ToList();
BeginInvoke(new MethodInvoker(draw));
while (true)
{
if (selection != Selection.Yet)
{
break;
}
Thread.Sleep(1);
}
state = State.Idle;
Alternatives alt = alternatives[selected];
if (alt == Alternatives.Pass)
{
response = Protocol.none();
}
else if (alt == Alternatives.Ron)
{
response = Protocol.hora(id, actor, pai);
}
else if (alt == Alternatives.Pon)
{
List <int> consumed = new List <int>();
for (int i = 0; i < 2; i++)
{
int ix = tehais[id].FindIndex(p => comparePai(p, pai) == 0);
consumed.Add(tehais[id][ix]);
tehais[id].RemoveAt(ix);
}
response = Protocol.pon(id, actor, pai, consumed);
}
else if (alt == Alternatives.Kan)
{
response = Protocol.pon(id, actor, pai, Enumerable.Repeat(pai, 3).ToList());
for (int i = 0; i < 3; i++)
{
tehais[id].Remove(pai);
}
}
else if (alt == Alternatives.Chi)
{
alternatives = new List <Alternatives>();
selection = Selection.Yet;
selecteds = new List <int>();
state = State.NakiSelect;
availablePai = Enumerable.Repeat(true, 14).ToList();
BeginInvoke(new MethodInvoker(draw));
while (true)
{
if (selection != Selection.Yet)
{
break;
}
Thread.Sleep(1);
}
state = State.Idle;
selecteds.Sort();
selecteds.Reverse();
response = Protocol.chi(id, actor, pai, selecteds.Select(_ => tehais[id][_]).ToList());
for (int i = 0; i < selecteds.Count; i++)
{
tehais[id].RemoveAt(selecteds[i]);
}
selecteds = new List <int>();
}
}
}
else /* 自分の打牌。tsumoのところで画面は更新してしまっているので、ここでは何もする必要がない */
{
response = Protocol.none();
}
break;
case "pon":
response = onNaki(json);
break;
case "chi":
response = onNaki(json);
break;
case "kan":
response = onNaki(json);
break;
case "hora":
scores = (List <int>)json.scores;
response = Protocol.none();
break;
case "ryukyoku":
scores = (List <int>)json.scores;
response = Protocol.none();
break;
case "error":
println("!!! ERROR OCCURRED !!!");
goto endwhile;
default:
response = Protocol.none();
break;
}
BeginInvoke(new MethodInvoker(draw));
string rawResponse = DynamicJson.Serialize(response);
println(string.Format("->\t{0}", rawResponse));
writer.WriteLine(rawResponse);
writer.Flush();
}
endwhile :;
}
enableConnectButton();
}
public ulong FactorialOf19()
{
return(Alternatives.FactorialOf19());
}
