/// <summary> /// Called from ArtifactScholar when he receives a whisper /// </summary> /// <param name="source"></param> /// <param name="target"></param> /// <param name="text"></param> /// <returns></returns> public override bool WhisperReceive(GameLiving source, GameLiving target, string text) { if (!(source is GamePlayer player) || !(target is ArtifactScholar scholar)) { return(false); } // Did they send a valid string? if (CurrentTypes.Contains(text)) { // Apend their choice to the chosen types ChosenTypes = $"{ChosenTypes}{text};"; // Lets get the next set of options // Get the versions of this art Dictionary <string, ItemTemplate> versions = ArtifactMgr.GetArtifactVersions(ArtifactId, (eCharacterClass)player.CharacterClass.ID, player.Realm); // If we still have more options, give it to them if (GetNextOptions(versions) && _virtualStep < MaxNumOfSteps) { SaveProperties(); scholar.TurnTo(player); scholar.SayTo(player, $"Would you prefer {GetOptions()} of {ArtifactId}?"); Step++; } // Else lets hand them their finished artifact! else { scholar.TurnTo(player); // Attempt to get the right version of the artifact ChosenTypes = ChosenTypes.Replace(";;", ";"); if (!versions.ContainsKey(ChosenTypes)) { Log.Warn($"Artifact version {ChosenTypes} not found"); scholar.SayTo(player, eChatLoc.CL_PopupWindow, "I can't find your chosen replacement, it may not be available for your class. Please try again."); ReturnArtifact(player); return(true); } ItemTemplate template = versions[ChosenTypes]; if (GiveItem(player, template)) { FinishQuest(); scholar.SayTo(player, eChatLoc.CL_PopupWindow, $"Here is your {ArtifactId}, {player.CharacterClass.Name}. May it serve you well!"); return(true); } return(false); } } return(base.WhisperReceive(source, target, text)); }
private void SetCurrentTypes() { Dictionary <string, List <string> > dictionatyTypes = new Files.FileParametersTypes().IninializeDictionatyTypeName(); foreach (string item in CurrentTypes.Replace(" ", "").Split(',')) { bool findSeparator = item.FirstOrDefault(f => f == '.') != char.MinValue; string nameParent = ""; string nameChildren; if (findSeparator) { string[] itemSubstring = item.Split('.'); nameParent = itemSubstring[0]; nameChildren = itemSubstring[1]; } else { nameChildren = item; foreach (KeyValuePair <string, List <string> > keyNames in dictionatyTypes) { foreach (string elementNames in keyNames.Value) { if (elementNames == nameChildren) { nameParent = keyNames.Key; break; } } } } if (!string.IsNullOrEmpty(nameParent)) { var children = _treeType.Tree.FirstOrDefault(f => f.Text == nameParent)?.Children; if (children != null) { for (int i = 0; i < children.Count; i++) { if (children[i].Text == nameChildren) { children[i].IsChecked = true; } } } } } }
public Compiler TypePush(Type type, int popCount = 0) { for (int i = 0; i < popCount; i++) { CurrentTypes.Pop(); } if (type != null) { CurrentTypes.Push(type); } return(this); }
private bool GetNextOptions(Dictionary <string, ItemTemplate> versions) { // Clear the current types since we are going to be offering more CurrentTypes.Clear(); // Loop until we find the next set of options while (CurrentTypes.Count <= 1 && _virtualStep < MaxNumOfSteps) { // Go through each set of options in our list foreach (string str in versions.Keys) { // Used as the key to store the option in the database string[] splitVersion = str.Split(';'); // multiple versions may not available if (splitVersion.Length <= _virtualStep) { return(false); } // Get the current option using our virtual step. This gets the right option in the DT;WT;STAT; list string type = splitVersion[_virtualStep]; // If we got a valid type and we don't already have it, put/save it if (type != string.Empty && !CurrentTypes.Contains(type)) { CurrentTypes.Add(type); } } // If there was only one option added, obviously that is the only thing they can pick if (CurrentTypes.Count == 1) { ChosenTypes = $"{ChosenTypes}{CurrentTypes[0]};"; CurrentTypes.Clear(); } else if (CurrentTypes.Count == 0) { // We need to add the end semi-colon even if we don't get an option! ChosenTypes = $"{ChosenTypes};"; } // Increment our virtual step, if this loops again it will proceed to the next set of options _virtualStep++; } return(true); }
public Compiler EmitSource(string source, string label = null, bool isMethod = false, Node owner = null) { Compilation.ExecutableLines[CurrentAddrIdx] = new SourceData { Source = source, Stack = CurrentTypes.Any() ? CurrentTypes.Select(t => t.FullName).ToArray() : null, IsMethod = isMethod }; if (!string.IsNullOrEmpty(label)) { EmitLabelDef(label, owner, isMethod); } CurrentTypesDebug.Add($"{source} = {string.Join(",", CurrentTypes)}"); return(this); }
public Compiler TypePop() { CurrentTypes.Pop(); return(this); }
public Type TypePeek(int skip = 0) => Correct(CurrentTypes.Skip(skip).First());
public static IEnumerable <String> ToText(this CurrentTypes CurrentTypesEnum) => CurrentTypesEnum.ToEnumeration().Select(item => item.ToString());
public static IEnumerable <CurrentTypes> ToEnumeration(this CurrentTypes CurrentTypesEnum) => Enum.GetValues(typeof(CurrentTypes)). Cast <CurrentTypes>(). Where(flag => CurrentTypesEnum.HasFlag(flag) && flag != CurrentTypes.Unspecified);
/// <summary> /// Inherited from <see cref="IEntityGenerator"/>. /// Provides the content for a single object file. /// </summary> /// <param name="targetType">An <see cref="EdmType"/> representing the type to generate output for.</param> /// <param name="container">An <see cref="IEnumerable{EdmType}"/> list containing all types defined for reference.</param> /// <param name="writer">The <see cref="TextWriter"/> object to write too.</param> public void WriteObject(EdmType targetType, IEnumerable<EdmType> container, TextWriter writer) { if (targetType == null) throw new ArgumentNullException("targetType must not be null."); if (writer == null) throw new ArgumentNullException("writer must not be null."); if (targetType is EntityType) Type = CurrentTypes.Entity; else if (targetType is ComplexType) Type = CurrentTypes.ComplexType; else throw new ArgumentException("targetType must be of type EntityType or ComplexType"); ParentType = targetType.BaseType; ChildTypes = container.Where(a => a.BaseType != null && a.BaseType.FullName == targetType.FullName); NamespaceName = targetType.NamespaceName; IEnumerable<EdmProperty> usableProperties = null; IEnumerable<NavigationProperty> usableNavProperties = null; if (Type == CurrentTypes.Entity) { EntityType entity = targetType as EntityType; usableProperties = (targetType as EntityType).Properties; usableNavProperties = (targetType as EntityType).NavigationProperties; usableProperties = entity.BaseType == null ? entity.Properties : entity.Properties.Where(a => !(entity.BaseType as EntityType).Properties.Any(b => b.Name == a.Name)); usableNavProperties = ParentType == null ? entity.NavigationProperties : entity.NavigationProperties.Where(a => !(entity.BaseType as EntityType).NavigationProperties.Any(b => b.Name == a.Name)); } else if (Type == CurrentTypes.ComplexType) { ComplexType complex = targetType as ComplexType; usableProperties = (targetType as ComplexType).Properties; usableNavProperties = Enumerable.Empty<NavigationProperty>(); usableProperties = complex.BaseType == null ? complex.Properties : complex.Properties.Where(a => !(complex.BaseType as ComplexType).Properties.Any(b => b.Name == a.Name)); } string result = null; if (!string.IsNullOrEmpty(result = WriteDocumentation(targetType))) writer.Write(result); if (!string.IsNullOrEmpty(result = WriteTypeUsingStatements(targetType))) writer.Write(result); if (!string.IsNullOrEmpty(result = WriteTypeBeginNamespace(targetType))) writer.Write(result); if (!string.IsNullOrEmpty(result = WriteDocumentationType(targetType))) writer.Write(result); if (!string.IsNullOrEmpty(result = WriteTypeClassAttributes(targetType))) writer.Write(result); if (!string.IsNullOrEmpty(result = WriteTypeBeginClass(targetType))) writer.Write(result); foreach (EdmProperty property in usableProperties) { if (!string.IsNullOrEmpty(result = WriteTypeFieldAttributes(property))) writer.Write(result); if (!string.IsNullOrEmpty(result = WriteTypeField(property))) writer.Write(result); } foreach (NavigationProperty navProperty in usableNavProperties) { if (!string.IsNullOrEmpty(result = WriteTypeFieldAttributes(navProperty))) writer.Write(result); if (!string.IsNullOrEmpty(result = WriteTypeField(navProperty))) writer.Write(result); } writer.WriteLine(); foreach (EdmProperty property in usableProperties) { if (!string.IsNullOrEmpty(result = WriteTypePropertyAttributes(property))) writer.Write(result); if (!string.IsNullOrEmpty(result = WriteTypeProperty(property))) writer.Write(result); } foreach (NavigationProperty navProperty in usableNavProperties) { if (!string.IsNullOrEmpty(result = WriteTypePropertyAttributes(navProperty))) writer.Write(result); if (!string.IsNullOrEmpty(result = WriteTypeProperty(navProperty))) writer.Write(result); } if (!string.IsNullOrEmpty(result = WriteTypeEndClass(targetType))) writer.Write(result); if (!string.IsNullOrEmpty(result = WriteTypeEndNamespace(targetType))) writer.Write(result); }