public static SpellFamily GetSpellFamilyFromCharClass(CharClass family) { switch (family) { case CharClass.DK: return SpellFamily.DK; case CharClass.DRUID: return SpellFamily.DRUID; case CharClass.HUNTER: return SpellFamily.HUNTER; case CharClass.MAGE: return SpellFamily.MAGE; case CharClass.PALADIN: return SpellFamily.PALADIN; case CharClass.PRIEST: return SpellFamily.PRIEST; case CharClass.ROGUE: return SpellFamily.ROGUE; case CharClass.SHAMAN: return SpellFamily.SHAMAN; case CharClass.WARLOCK: return SpellFamily.WARLOCK; case CharClass.WARRIOR: return SpellFamily.WARRIOR; default: return SpellFamily.GENERIC; } }
/// <summary> /// Default constructor. /// </summary> public RepopulationPoint() { _roomIndexNumber = 0; _raceString = String.Empty; _classString = String.Empty; _race = null; _class = null; }
protected Character(Position position, MapMarkers mapMarker, string name, Race race, CharClass charClass, bool isPlayer) : base(position, mapMarker, name) { this.isPlayer = isPlayer; this.Race = race; this.CharClass = charClass; this.SetInitialStats(this.Race, this.CharClass, this.isPlayer); this.PassiveSkills = new List<PassiveSkill>(); this.Inventory = new List<Item>(); }
public Player(string name, Race race, CharClass charClass) : base(new Position(0, 0), MapMarkers.P, name, race, charClass, true) { this.Level = 1; this.LevelBoundary = 250; this.ActiveSkills = new List<ActiveSkill>(); this.Experience = 0; this.skills = new Dictionary<int, Skill>(); this.InitSkills(); this.AddSkill(); }
public void AddMember(CharClass member) { members.Add(member); }
public void AwardXP(int xp, string user, IrcClient whisperClient) { //int value = 0; if (Exists(xpList, user)) { int prevLevel = determineLevel(user); if (xpList == null) { return; } int value = 0; if (xpList.ContainsKey(user) && int.TryParse(xp.ToString(), out value)) { try { int prevXP = xpList[user]; checked { xpList[user] += value; } if (xpList[user] < 0) { xpList[user] = 0; } } catch (Exception e) { Console.WriteLine("Error adding xp."); Console.WriteLine(e); } int newLevel = determineLevel(user); if (newLevel > MAX_LEVEL) { newLevel = 3; classList[user].prestige++; //prestige code xpList[user] = 200; whisperClient.sendChatMessage(".w " + user + " You have earned a Prestige level! You are now Prestige " + classList[user].prestige + " and your level has been set to 3. XP to next level: " + XpToNextLevel(user) + "."); return; } int myPrestige = classList[user].prestige; //prestige code if (newLevel > prevLevel && newLevel != 3 && newLevel > 1) { //prestige code if (myPrestige > 0) { whisperClient.sendChatMessage(".w " + user + " DING! You just reached Level " + newLevel + "! You are Prestige " + myPrestige + ". XP to next level: " + XpToNextLevel(user) + "."); } //prestige code else { whisperClient.sendChatMessage(".w " + user + " DING! You just reached Level " + newLevel + "! XP to next level: " + XpToNextLevel(user) + "."); } if (newLevel > 5) { classList[user].level = newLevel; } } if (!(classList.ContainsKey(user)) && newLevel > prevLevel && newLevel == 3) { CharClass newClass = new CharClass(); newClass.classType = -1; classList.Add(user.ToLower(), newClass); whisperClient.sendChatMessage(".w " + user + " You've reached LEVEL 3! You get to choose a class for your character! Choose by whispering me one of the following: "); whisperClient.sendChatMessage(".w " + user + " 'C1' (Warrior), 'C2' (Mage), 'C3' (Rogue), 'C4' (Ranger), or 'C5' (Cleric)"); } } } }
private void ParseCharClass(Token bracket) { CharClass _charclass; NodeParent _parent = _concatenate; Token next = PeekToken(); if (next.Type == TokenType.Negative) { _charclass = new CharClass(_parent, true); _charclass.Tokens.Add(bracket); // negative _charclass.Tokens.Add(GetToken()); } else { _charclass = new CharClass(_parent, false); _charclass.Tokens.Add(bracket); } _parent = _charclass; while (_parent.Type == NodeType.CharClass) { Token token = GetToken(); switch (token.Type) { case TokenType.Char: if (PeekToken().Type == TokenType.Hyphen) { // error has been handled in lexer, so just get token!LOL new Range(_parent, token, GetToken(), GetToken()); } else { new One(_parent, token); } break; case TokenType.Set: new Set(_parent, token); break; case TokenType.Subtract: _parent.Tokens.Add(token); CharClass _sub; // check token after bracket L if (PeekToken(1).Type == TokenType.Negative) { _sub = new CharClass(_parent, true); // bracket L _sub.Tokens.Add(GetToken()); // negative _sub.Tokens.Add(GetToken()); } else { _sub = new CharClass(_parent, false); // bracket L _sub.Tokens.Add(GetToken()); } (_parent as CharClass).Subtract(_sub); _parent = _sub; break; case TokenType.BracketR: _parent.Tokens.Add(token); // finish this level charclass _parent = _parent.Parent; break; default: throw MakeException("InternalError"); } } _unit = _charclass; }
internal static string/*!*/ PatternToRegex(string/*!*/ pattern, bool pathName, bool noEscape) { StringBuilder result = new StringBuilder(pattern.Length); result.Append("\\G"); bool inEscape = false; CharClass charClass = null; foreach (char c in pattern) { if (inEscape) { if (charClass != null) { charClass.Add(c); } else { AppendExplicitRegexChar(result, c); } inEscape = false; continue; } else if (c == '\\' && !noEscape) { inEscape = true; continue; } if (charClass != null) { if (c == ']') { string set = charClass.MakeString(); if (set == null) { // Ruby regex "[]" matches nothing // CLR regex "[]" throws exception return String.Empty; } result.Append(set); charClass = null; } else { charClass.Add(c); } continue; } switch (c) { case '*': result.Append(pathName ? "[^/]*" : ".*"); break; case '?': result.Append('.'); break; case '[': charClass = new CharClass(); break; default: AppendExplicitRegexChar(result, c); break; } } return (charClass == null) ? result.ToString() : String.Empty; }
internal static CharGrouping Character(CharClass value) { return new CharGrouping.CharacterClassCharGrouping(value); }
// Token: 0x06001A0C RID: 6668 RVA: 0x000CE58C File Offset: 0x000CC78C public TextTokenId Parse() { if (this.tokenBuilder.Valid) { this.input.ReportProcessed(this.parseCurrent - this.parseStart); this.parseStart = this.parseCurrent; this.tokenBuilder.Reset(); } ConverterDecodingInput converterDecodingInput; for (;;) { bool flag = false; if (this.parseCurrent + this.parseThreshold > this.parseEnd) { if (!this.endOfFile) { if (!this.input.ReadMore(ref this.parseBuffer, ref this.parseStart, ref this.parseCurrent, ref this.parseEnd)) { break; } this.tokenBuilder.BufferChanged(this.parseBuffer, this.parseStart); converterDecodingInput = (this.input as ConverterDecodingInput); if (converterDecodingInput != null && converterDecodingInput.EncodingChanged) { goto Block_6; } if (this.input.EndOfFile) { this.endOfFile = true; } if (!this.endOfFile && this.parseEnd - this.parseStart < this.input.MaxTokenSize) { continue; } } flag = true; } char c = this.parseBuffer[this.parseCurrent]; CharClass charClass = ParseSupport.GetCharClass(c); if (!ParseSupport.InvalidUnicodeCharacter(charClass)) { if (this.parseThreshold <= 1) { goto IL_2D2; } } while (ParseSupport.InvalidUnicodeCharacter(charClass) && this.parseCurrent < this.parseEnd) { c = this.parseBuffer[++this.parseCurrent]; charClass = ParseSupport.GetCharClass(c); } if (this.parseThreshold > 1 && this.parseCurrent + 1 < this.parseEnd) { int num = this.parseCurrent + 1; int num2 = this.parseCurrent + 1; while (num < this.parseEnd && num2 < this.parseCurrent + this.parseThreshold) { char c2 = this.parseBuffer[num]; CharClass charClass2 = ParseSupport.GetCharClass(c2); if (!ParseSupport.InvalidUnicodeCharacter(charClass2)) { if (num != num2) { this.parseBuffer[num2] = c2; this.parseBuffer[num] = '\0'; } num2++; } num++; } if (num == this.parseEnd && this.parseCurrent + this.parseThreshold > num2) { Array.Copy(this.parseBuffer, this.parseCurrent, this.parseBuffer, this.parseEnd - (num2 - this.parseCurrent), num2 - this.parseCurrent); this.parseCurrent = this.parseEnd - (num2 - this.parseCurrent); this.input.ReportProcessed(this.parseCurrent - this.parseStart); this.parseStart = this.parseCurrent; } } if (this.parseCurrent + this.parseThreshold > this.parseEnd) { if (!flag) { continue; } if (this.parseCurrent == this.parseEnd && !this.tokenBuilder.IsStarted && this.endOfFile) { goto IL_589; } } this.parseThreshold = 1; IL_2D2: int num3 = this.parseCurrent; this.tokenBuilder.StartText(num3); while (this.tokenBuilder.PrepareToAddMoreRuns(9, num3, RunKind.Text)) { while (ParseSupport.TextUriCharacter(charClass)) { c = this.parseBuffer[++this.parseCurrent]; charClass = ParseSupport.GetCharClass(c); } if (ParseSupport.TextNonUriCharacter(charClass)) { if (this.parseCurrent != num3) { this.AddTextRun(RunTextType.NonSpace, num3, this.parseCurrent); } num3 = this.parseCurrent; do { c = this.parseBuffer[++this.parseCurrent]; charClass = ParseSupport.GetCharClass(c); }while (ParseSupport.NbspCharacter(charClass)); this.AddTextRun(RunTextType.NonSpace, num3, this.parseCurrent); } else if (ParseSupport.WhitespaceCharacter(charClass)) { if (this.parseCurrent != num3) { this.AddTextRun(RunTextType.NonSpace, num3, this.parseCurrent); } num3 = this.parseCurrent; if (c == ' ') { char c2 = this.parseBuffer[this.parseCurrent + 1]; CharClass charClass2 = ParseSupport.GetCharClass(c2); if (!ParseSupport.WhitespaceCharacter(charClass2)) { c = c2; charClass = charClass2; this.parseCurrent++; this.AddTextRun(RunTextType.Space, num3, this.parseCurrent); num3 = this.parseCurrent; continue; } } this.ParseWhitespace(c, charClass); if (this.parseThreshold > 1) { break; } num3 = this.parseCurrent; c = this.parseBuffer[this.parseCurrent]; charClass = ParseSupport.GetCharClass(c); } else if (ParseSupport.NbspCharacter(charClass)) { if (this.parseCurrent != num3) { this.AddTextRun(RunTextType.NonSpace, num3, this.parseCurrent); } num3 = this.parseCurrent; do { c = this.parseBuffer[++this.parseCurrent]; charClass = ParseSupport.GetCharClass(c); }while (ParseSupport.NbspCharacter(charClass)); this.AddTextRun(RunTextType.Nbsp, num3, this.parseCurrent); } else { if (this.parseCurrent != num3) { this.AddTextRun(RunTextType.NonSpace, num3, this.parseCurrent); } if (this.parseCurrent >= this.parseEnd) { break; } do { c = this.parseBuffer[++this.parseCurrent]; charClass = ParseSupport.GetCharClass(c); }while (ParseSupport.InvalidUnicodeCharacter(charClass) && this.parseCurrent < this.parseEnd); } num3 = this.parseCurrent; } if (!this.token.IsEmpty) { goto IL_572; } this.tokenBuilder.Reset(); this.input.ReportProcessed(this.parseCurrent - this.parseStart); this.parseStart = this.parseCurrent; } return(TextTokenId.None); Block_6: converterDecodingInput.EncodingChanged = false; return(this.tokenBuilder.MakeEmptyToken(TextTokenId.EncodingChange, converterDecodingInput.Encoding)); IL_572: this.tokenBuilder.EndText(); return((TextTokenId)this.token.TokenId); IL_589: return(this.tokenBuilder.MakeEmptyToken(TextTokenId.EndOfFile)); }
private static string PatternToRegex(string pattern, bool pathName, bool noEscape) { var result = new StringBuilder(pattern.Length); result.Append("\\G"); var inEscape = false; CharClass charClass = null; foreach (char c in pattern) { if (inEscape) { if (charClass != null) { charClass.Add(c); } else { AppendExplicitRegexChar(result, c); } inEscape = false; continue; } if (c == '\\' && !noEscape) { inEscape = true; continue; } if (charClass != null) { if (c == ']') { var set = charClass.MakeString(); if (set == null) { return String.Empty; } result.Append(set); charClass = null; } else { charClass.Add(c); } continue; } switch (c) { case '*': result.Append(pathName ? "[^/]*" : ".*"); break; case '?': result.Append('.'); break; case '[': charClass = new CharClass(); break; default: AppendExplicitRegexChar(result, c); break; } } return (charClass == null) ? result.ToString() : String.Empty; }
/// <summary> /// Gets color pair for a character-class. /// </summary> /// <param name="klass">The color-pair associated with this character-class will be got.</param> /// <param name="fore">Foreground color used to draw characters marked as the character-class.</param> /// <param name="back">Background color used to draw characters marked as the character-class.</param> /// <remarks> /// <para> /// This method gets a pair of colors which is associated with /// CharClass specified by parameter '<paramref name="klass"/>.' /// </para> /// <para> /// Note that, although Azuki does not use actually set background color value /// if it was Color.Transparent, /// this method returns the actually set value (Color.Transparent) in the case. /// </para> /// </remarks> /// <seealso cref="Sgry.Azuki.ColorScheme.SetColor">ColorScheme.SetColor method</seealso> public void GetColor(CharClass klass, out Color fore, out Color back) { fore = _ForeColors[(byte)klass]; back = _BackColors[(byte)klass]; }
// Token: 0x06001A0E RID: 6670 RVA: 0x000CEB68 File Offset: 0x000CCD68 private void ParseWhitespace(char ch, CharClass charClass) { int num = this.parseCurrent; do { char c = ch; switch (c) { case '\t': do { ch = this.parseBuffer[++this.parseCurrent]; }while (ch == '\t'); this.AddTextRun(RunTextType.Tabulation, num, this.parseCurrent); goto IL_196; case '\n': ch = this.parseBuffer[++this.parseCurrent]; this.AddTextRun(RunTextType.NewLine, num, this.parseCurrent); goto IL_196; case '\v': case '\f': break; case '\r': if (this.parseBuffer[this.parseCurrent + 1] != '\n') { CharClass charClass2 = ParseSupport.GetCharClass(this.parseBuffer[this.parseCurrent + 1]); if (ParseSupport.InvalidUnicodeCharacter(charClass2) && (!this.endOfFile || this.parseCurrent + 1 < this.parseEnd)) { this.parseThreshold = 2; goto IL_196; } } else { this.parseCurrent++; } ch = this.parseBuffer[++this.parseCurrent]; this.AddTextRun(RunTextType.NewLine, num, this.parseCurrent); goto IL_196; default: if (c == ' ') { do { ch = this.parseBuffer[++this.parseCurrent]; }while (ch == ' '); this.AddTextRun(RunTextType.Space, num, this.parseCurrent); goto IL_196; } break; } do { ch = this.parseBuffer[++this.parseCurrent]; }while (ch == '\v' || ch == '\f'); this.AddTextRun(RunTextType.UnusualWhitespace, num, this.parseCurrent); IL_196: charClass = ParseSupport.GetCharClass(ch); num = this.parseCurrent; }while (ParseSupport.WhitespaceCharacter(charClass) && this.tokenBuilder.PrepareToAddMoreRuns(4, num, RunKind.Text) && this.parseThreshold == 1); }
public CharClassCharGroup(CharClass value) { _value = value; }
/// <summary> /// Convert each part to Regex /// </summary> /// <param name="globPart">Part of glob that does not contain '/'</param> /// <returns></returns> private GlobRegexItem ConvertSingleGlobPart(string globPart) { // Return GlobStar for ** if (Options.HasFlag(GlobMatcherOptions.AllowGlobStar) && GlobStarRegex.IsMatch(globPart)) { return IsFolderPath(globPart) ? GlobRegexItem.GlobStar : GlobRegexItem.GlobStarForFileOnly; } StringBuilder builder = new StringBuilder(); bool escaping = false; bool disableEscape = !Options.HasFlag(GlobMatcherOptions.AllowEscape); bool hasMagic = false; CharClass currentCharClass = null; string patternStart = string.Empty; // .abc will not be matched unless . is explictly specified if (globPart.Length > 0 && globPart[0] != '.') { patternStart = Options.HasFlag(GlobMatcherOptions.AllowDotMatch) ? PatternStartWithDotAllowed : PatternStartWithoutDotAllowed; } for (int i = 0; i < globPart.Length; i++) { var c = globPart[i]; switch (c) { case '\\': if (!disableEscape) { i++; if (i == globPart.Length) { // \ at the end of path part, invalid, not possible for file path, invalid return GlobRegexItem.Empty; } else { c = globPart[i]; if (NeedEscapeCharactersInRegex.Contains(c)) { builder.Append('\\'); } builder.Append(c); } } else { builder.Append("\\\\"); } break; case '?': builder.Append(QuestionMarkToRegex); hasMagic = true; break; case '*': builder.Append(SingleStarToRegex); hasMagic = true; break; case '[': escaping = false; currentCharClass = new CharClass(); int cur = i + 1; while (cur < globPart.Length) { c = globPart[cur]; if (c == '\\') escaping = true; else if (c == ']' && !escaping) { // current char class ends when meeting the first non-escaping ] builder.Append(currentCharClass.ToString()); currentCharClass = null; break; } // simply keeps what it is inside char class currentCharClass.Add(c); if (c != '\\') escaping = false; cur++; } if (currentCharClass != null) { // no closing ] is found, fallback to no char class builder.Append("\\["); } else { i = cur; hasMagic = true; } break; default: if (NeedEscapeCharactersInRegex.Contains(c)) { builder.Append('\\'); } builder.Append(c); break; } } if (hasMagic) { var regexContent = builder.ToString(); if (!string.IsNullOrEmpty(regexContent)) { // when regex is not empty, make sure it does not match against empty path, e.g. a/* should not match a/ // regex: if followed by anything regexContent = "(?=.)" + regexContent; } else { return GlobRegexItem.Empty; } if (RegexCharactersWithDotPossible.Contains(regexContent[0])) { regexContent = patternStart + regexContent; } return new GlobRegexItem(regexContent, null, GlobRegexItemType.Regex, _ignoreCase); } else { // If does not contain any regex character, use the original string for regex // use escaped string as the string to be matched string plainText = UnescapeGlob(globPart); return new GlobRegexItem(globPart, plainText, GlobRegexItemType.PlainText, _ignoreCase); } }
public bool IsClass(CharClass.Names name) { if (CharacterClass.ClassNumber == name) { return true; } return false; }
static string /*!*/ PatternToRegex(string /*!*/ pattern, bool pathName, bool noEscape) { StringBuilder result = new StringBuilder(pattern.Length); result.Append("\\G"); bool inEscape = false; CharClass charClass = null; foreach (char c in pattern) { if (inEscape) { if (charClass != null) { charClass.Add(c); } else { AppendExplicitRegexChar(result, c); } inEscape = false; continue; } else if (c == '\\' && !noEscape) { inEscape = true; continue; } if (charClass != null) { if (c == ']') { string set = charClass.MakeString(); if (set == null) { // PHP regex "[]" matches nothing // CLR regex "[]" throws exception return(String.Empty); } result.Append(set); charClass = null; } else { charClass.Add(c); } continue; } switch (c) { case '*': result.Append(pathName ? "[^/]*" : ".*"); break; case '?': result.Append('.'); break; case '[': charClass = new CharClass(); break; default: AppendExplicitRegexChar(result, c); break; } } return((charClass == null) ? result.ToString() : string.Empty); }
// Returns true is the specified char is whitespace. private static bool IsWhiteSpace(char ch, CharClass charClass) { return (charClass & CharClass.WBF_CLASS) == CharClass.Blank && ch != ObjectReplacementChar; }
/// <summary> /// Convert each part to Regex /// </summary> /// <param name="globPart">Part of glob that does not contain '/'</param> /// <returns></returns> private GlobRegexItem ConvertSingleGlobPart(string globPart) { // Return GlobStar for ** if (Options.HasFlag(GlobMatcherOptions.AllowGlobStar) && GlobStarRegex.IsMatch(globPart)) { return(IsFolderPath(globPart) ? GlobRegexItem.GlobStar : GlobRegexItem.GlobStarForFileOnly); } StringBuilder builder = new StringBuilder(); bool escaping = false; bool disableEscape = !Options.HasFlag(GlobMatcherOptions.AllowEscape); bool hasMagic = false; CharClass currentCharClass = null; string patternStart = string.Empty; // .abc will not be matched unless . is explictly specified if (globPart.Length > 0 && globPart[0] != '.') { patternStart = Options.HasFlag(GlobMatcherOptions.AllowDotMatch) ? PatternStartWithDotAllowed : PatternStartWithoutDotAllowed; } for (int i = 0; i < globPart.Length; i++) { var c = globPart[i]; switch (c) { case '\\': if (!disableEscape) { i++; if (i == globPart.Length) { // \ at the end of path part, invalid, not possible for file path, invalid return(GlobRegexItem.Empty); } else { c = globPart[i]; if (NeedEscapeCharactersInRegex.Contains(c)) { builder.Append('\\'); } builder.Append(c); } } else { builder.Append("\\\\"); } break; case '?': builder.Append(QuestionMarkToRegex); hasMagic = true; break; case '*': builder.Append(SingleStarToRegex); hasMagic = true; break; case '[': escaping = false; currentCharClass = new CharClass(); int cur = i + 1; while (cur < globPart.Length) { c = globPart[cur]; if (c == '\\') { escaping = true; } else if (c == ']' && !escaping) { // current char class ends when meeting the first non-escaping ] builder.Append(currentCharClass.ToString()); currentCharClass = null; break; } // simply keeps what it is inside char class currentCharClass.Add(c); if (c != '\\') { escaping = false; } cur++; } if (currentCharClass != null) { // no closing ] is found, fallback to no char class builder.Append("\\["); } else { i = cur; hasMagic = true; } break; default: if (NeedEscapeCharactersInRegex.Contains(c)) { builder.Append('\\'); } builder.Append(c); break; } } if (hasMagic) { var regexContent = builder.ToString(); if (!string.IsNullOrEmpty(regexContent)) { // when regex is not empty, make sure it does not match against empty path, e.g. a/* should not match a/ // regex: if followed by anything regexContent = "(?=.)" + regexContent; } else { return(GlobRegexItem.Empty); } if (RegexCharactersWithDotPossible.Contains(regexContent[0])) { regexContent = patternStart + regexContent; } return(new GlobRegexItem(regexContent, null, GlobRegexItemType.Regex, _ignoreCase)); } else { // If does not contain any regex character, use the original string for regex // use escaped string as the string to be matched string plainText = UnescapeGlob(globPart); return(new GlobRegexItem(globPart, plainText, GlobRegexItemType.PlainText, _ignoreCase)); } }
internal ComplementCharClass(CharClass original) { _original = original ?? throw new ArgumentNullException(nameof(original)); }
// Returns true if the char specified by index is a MidLetter as defined // by the Unicode Standard Annex #29. (Actually we use a subset of all // possible MidLetter values.) // // MidLetters are exceptions to the rule that consequative characters // with different classes are word breaks. private static bool IsMidLetter(char []text, int index, CharClass []classes) { Invariant.Assert(text.Length == classes.Length); return (text[index] == ApostropheChar || text[index] == RightSingleQuotationChar || text[index] == SoftHyphenChar) && (index > 0 && index + 1 < classes.Length) && ((classes[index - 1] == CharClass.Alphanumeric && classes[index + 1] == CharClass.Alphanumeric) || (text[index] == QuotationMarkChar && IsHebrew(text[index - 1]) && IsHebrew(text[index + 1]))); }
/// <summary> /// Sets race and class on a repop by looking up the race and class. /// </summary> public void Setup() { _race = Race.RaceList[Race.RaceLookup(_raceString)]; _class = CharClass.ClassList[(int)CharClass.ClassLookup(_classString)]; }
private static CharClass[] makeCharClassArray() { CharClass[] a = new CharClass[65536]; foreach (char c in stringOfBackslashChars) { a[c] = CharClass.Backslash; } foreach (char c in stringOfQuoteChars) { a[c] = CharClass.Quote; } return a; }
private static string PatternToRegex(string pattern, bool pathName, bool noEscape) { var result = new StringBuilder(pattern.Length); result.Append("\\G"); var inEscape = false; CharClass charClass = null; foreach (char c in pattern) { if (inEscape) { if (charClass != null) { charClass.Add(c); } else { AppendExplicitRegexChar(result, c); } inEscape = false; continue; } if (c == '\\' && !noEscape) { inEscape = true; continue; } if (charClass != null) { if (c == ']') { var set = charClass.MakeString(); if (set == null) { return(String.Empty); } result.Append(set); charClass = null; } else { charClass.Add(c); } continue; } switch (c) { case '*': result.Append(pathName ? "[^/]*" : ".*"); break; case '?': result.Append('.'); break; case '[': charClass = new CharClass(); break; default: AppendExplicitRegexChar(result, c); break; } } return((charClass == null) ? result.ToString() : String.Empty); }
protected internal void StripLeadingWhitespace(ref Fragment fragment) { int num = fragment.head; if (num != fragment.tail) { int num2 = fragment.headOffset; if (runList[num].Type < (RunType)2147483648u) { SkipNonTextRuns(ref num, ref num2, fragment.tail); } if (num == fragment.tail) { return; } int i; do { if (runList[num].Type == (RunType)3221225472u) { if (runList[num].Value > 65535) { break; } CharClass charClass = ParseSupport.GetCharClass((char)runList[num].Value); if (!ParseSupport.WhitespaceCharacter(charClass)) { break; } } else { for (i = num2; i < num2 + runList[num].Length; i++) { CharClass charClass = ParseSupport.GetCharClass(buffer[i]); if (!ParseSupport.WhitespaceCharacter(charClass)) { break; } } if (i < num2 + runList[num].Length) { goto Block_8; } } num2 += runList[num].Length; num++; if (num != fragment.tail && runList[num].Type < (RunType)2147483648u) { SkipNonTextRuns(ref num, ref num2, fragment.tail); } }while (num != fragment.tail); goto IL_162; Block_8: RunEntry[] expr_FA_cp_0 = runList; int expr_FA_cp_1 = num; expr_FA_cp_0[expr_FA_cp_1].Length = expr_FA_cp_0[expr_FA_cp_1].Length - (i - num2); num2 = i; IL_162: fragment.head = num; fragment.headOffset = num2; } }
private void SetInitialStats(Race race, CharClass charClass, bool player) { if (player) { this.AttackRating = Ar; this.DefenseRating = Dr; this.CritChance = Cc; this.BlockChance = Bc; this.MaxHealth = Mh; this.MaxMana = Mm; } else { this.AttackRating -= Ar / 8; this.DefenseRating -= Dr / 8; this.CritChance -= Cc / 8; this.BlockChance -= Bc / 8; this.MaxHealth += Mh * 3; this.MaxMana -= Mm / 8; } switch (race) { case Race.Elf: this.AttackRating += Ar / 2; break; case Race.Orc: this.MaxHealth += Mh / 2; break; case Race.Human: this.CritChance *= 2; break; case Race.Undead: this.MaxMana += Mm / 2; break; case Race.Goblin: this.DefenseRating += Dr / 2; break; } switch (charClass) { case CharClass.Mage: this.MaxMana += Mm / 2; this.CritChance *= 2; break; case CharClass.Priest: this.MaxMana += Mm / 2; this.MaxHealth += Mh / 2; break; case CharClass.Rogue: this.CritChance *= 2; this.AttackRating += Ar / 2; break; case CharClass.Warrior: this.DefenseRating += Dr / 2; this.BlockChance *= 2; break; } this.CurrentHealth = this.MaxHealth; this.CurrentMana = this.MaxMana; }
protected Character(Position position, MapMarkers mapMarker, string name, Race race, CharClass charClass, bool isPlayer) : base(position, mapMarker, name) { this.isPlayer = isPlayer; this.Race = race; this.CharClass = charClass; this.SetInitialStats(this.Race, this.CharClass, this.isPlayer); this.PassiveSkills = new List <PassiveSkill>(); this.Inventory = new List <Item>(); }
public void CreateClass(CharClass charClass) { _appDbContext.CharClasses.Add(charClass); _appDbContext.SaveChanges(); }
public void LoadBuiltinClasses() { classes["Int"] = new IntClass(); classes["Float"] = new FloatClass(); classes["Boolean"] = new BooleanClass(); classes["String"] = new StringClass(); classes["Char"] = new CharClass(); classes["Byte"] = new ByteClass(); classes["Message"] = new MessageClass(); classes["Unassigned"] = new UnassignedClass(); classes["Tuple"] = new TupleClass(); classes["NameValue"] = new NameValueClass(); classes["Lambda"] = new LambdaClass(); classes["Void"] = new VoidClass(); classes["Some"] = new SomeClass(); classes["None"] = new NoneClass(); classes["Array"] = new ArrayClass(); classes["Iterator"] = new IteratorClass(); classes["LazyIterator"] = new LazyIteratorClass(); classes["StreamIterator"] = new StreamIteratorClass(); classes["Any"] = new AnyClass(); classes["Placeholder"] = new PlaceholderClass(); classes["Range"] = new RangeClass(); classes["Dictionary"] = new DictionaryClass(); classes["Container"] = new ContainerClass(); classes["Unmatched"] = new UnmatchedClass(); classes["Complex"] = new ComplexClass(); classes["Rational"] = new RationalClass(); classes["Long"] = new LongClass(); classes["Lazy"] = new LazyClass(); classes["YieldingInvokable"] = new YieldingInvokableClass(); classes["Del"] = new DelClass(); classes["Slice"] = new SliceClass(); classes["End"] = new EndClass(); classes["List"] = new ListClass(); classes["Arguments"] = new ArgumentsClass(); classes["Symbol"] = new SymbolClass(); classes["Infinity"] = new InfinityClass(); classes["OpenRange"] = new OpenRangeClass(); classes["KeyValue"] = new KeyValueClass(); classes["Regex"] = new RegexClass(); classes["Pattern"] = new PatternClass(); classes["PackageFunction"] = new PackageFunctionClass(); classes["Sys"] = new SysClass(); classes["Math"] = new MathClass(); classes["RuntimeFunction"] = new RuntimeFunctionClass(); classes["Reference"] = new ReferenceClass(); classes["Group"] = new RegexGroupClass(); classes["Match"] = new RegexMatchClass(); classes["Date"] = new DateClass(); classes["Interval"] = new IntervalClass(); classes["TypeConstraint"] = new TypeConstraintClass(); classes["ByteArray"] = new ByteArrayClass(); classes["Selector"] = new SelectorClass(); classes["Number"] = new NumberClass(); classes["Collection"] = new CollectionClass(); classes["TextFinding"] = new TextFindingClass(); classes["SkipTake"] = new SkipTakeClass(); classes["Constructor"] = new ConstructorClass(); classes["MutString"] = new MutStringClass(); classes["Error"] = new ErrorClass(); classes["Success"] = new SuccessClass(); classes["Failure"] = new FailureClass(); classes["Optional"] = new OptionalClass(); classes["Result"] = new ResultClass(); classes["Monad"] = new MonadClass(); classes["Unit"] = new UnitClass(); classes["YieldReturn"] = new YieldReturnClass(); classes["Index"] = new IndexClass(); classes["Cycle"] = new CycleClass(); classes["Set"] = new SetClass(); }
public Unit(int c) { //between 0 and 5, depending on the class's order in line 5. health = 100; charClass = (CharClass)c; Debug.Log (charClass); }
public CharacterClassCharGrouping(CharClass value) { _value = value; }
// Returns true is the specified char is whitespace. private static bool IsWhiteSpace(char ch, CharClass charClass) { return((charClass & CharClass.WBF_CLASS) == CharClass.Blank && ch != ObjectReplacementChar); }
public int SetXP(int xp, string user, IrcClient whisperClient) { if (xpList != null) { if (xp > MAX_XP) { xp = MAX_XP - 1; } if (xp < 0) { xp = 0; } if (xpList.Keys.Contains(user)) { int prevLevel = determineLevel(user); xpList[user] = xp; int newLevel = determineLevel(user); if (newLevel > MAX_LEVEL) { newLevel = MAX_LEVEL; } if (newLevel > prevLevel && newLevel != 3 && Exists(classList, user)) { whisperClient.sendChatMessage(".w " + user + " DING! You just reached Level " + newLevel + "! XP to next level: " + XpToNextLevel(user) + "."); if (newLevel > 3) { if (Exists(classList, user)) { classList[user].level = newLevel; SaveClassData(); } } } if (newLevel > prevLevel && newLevel > 3 && classList != null & !classList.ContainsKey(user)) { CharClass newChar = new CharClass(); newChar.classType = -1; newChar.level = newLevel; classList.Add(user.ToLower(), newChar); whisperClient.sendChatMessage(".w " + user + " You've reached LEVEL " + newLevel + "! You get to choose a class for your character! Choose by whispering me one of the following: "); whisperClient.sendChatMessage(".w " + user + " 'C1' (Warrior), 'C2' (Mage), 'C3' (Rogue), 'C4' (Ranger), or 'C5' (Cleric)"); SaveClassData(); } if (newLevel < prevLevel) { whisperClient.sendChatMessage(".w " + user + " You lost a level! :( You're now level: " + newLevel); if (Exists(classList, user)) { classList[user].level = newLevel; SaveClassData(); } } } else { xpList.Add(user, xp); Console.WriteLine("Added user " + user + " and set their XP to " + xp + "."); } SaveXP(); return(xp); } return(-1); }
internal static bool AttemptUnescape(char[] parseBuffer, int parseEnd, ref char ch, ref int parseCurrent) { if (ch != '\\' || parseCurrent == parseEnd) { return(false); } ch = parseBuffer[++parseCurrent]; CharClass charClass = ParseSupport.GetCharClass(ch); int end = parseCurrent + 6; end = end < parseEnd ? end : parseEnd; if (ParseSupport.HexCharacter(charClass)) { int result = 0; while (true) { result <<= 4; result |= ParseSupport.CharToHex(ch); if (parseCurrent == end) { break; } ch = parseBuffer[++parseCurrent]; charClass = ParseSupport.GetCharClass(ch); if (!ParseSupport.HexCharacter(charClass)) { if (ch == '\r' && parseCurrent != parseEnd) { ch = parseBuffer[++parseCurrent]; if (ch == '\n') { charClass = ParseSupport.GetCharClass(ch); } else { --parseCurrent; } } if (ch != ' ' && ch != '\t' && ch != '\r' && ch != '\n' && ch != '\f') { --parseCurrent; } break; } } ch = (char)result; return(true); } if (ch >= ' ' && ch != (char)0x7F) { return(true); } --parseCurrent; ch = '\\'; return(false); }
public CharacterClass(CharClass charClass) : base(charClass) { this.charClass = charClass; }
private string GetExpText(CharClass node) { return(node.GenerateContent(null)); }
private bool Test(CharClass val, CharClass comparand) { return (val & comparand) == comparand; }
/// <summary> /// Appends a pattern that matches a character from a specified character class. /// </summary> /// <param name="value">An enumerated constant that identifies character class.</param> internal void AppendCharGroup(CharClass value) { AppendCharGroupStart(); AppendCharClass(value); AppendCharGroupEnd(); }
public Enemies(string _name, CharClass cc, int _health, int _defense, int _offense, int magicpoints) : base(_name, cc, _health, _defense, _offense, magicpoints) { }
/// <summary> /// Appends a pattern that matches a character from a specified character class. /// </summary> /// <param name="value">An enumerated constant that identifies character class.</param> internal void AppendCharClass(CharClass value) { switch (value) { case CharClass.Digit: AppendDigit(); break; case CharClass.WordChar: AppendWordChar(); break; case CharClass.WhiteSpace: AppendWhiteSpace(); break; case CharClass.NotDigit: AppendNotDigit(); break; case CharClass.NotWordChar: AppendNotWordChar(); break; case CharClass.NotWhiteSpace: AppendNotWhiteSpace(); break; } }
public CharClassTokenExpr(CharClass ch) => this.cc = ch;
internal CharClassParser(CharClass clazz) : base("CharClass") { _clazz = clazz ?? throw new ArgumentNullException(nameof(clazz)); }
// Return true if two chars are in the same class. // Ideographic chars are a special case -- each is considered to be // unique except for several exceptions in japanese. private static bool IsSameClass(UInt16 preceedingType3, CharClass preceedingClass, UInt16 followingType3, CharClass followingClass) { const UInt16 IdeographicKanaTypes = SafeNativeMethods.C3_HALFWIDTH | SafeNativeMethods.C3_FULLWIDTH | SafeNativeMethods.C3_KATAKANA | SafeNativeMethods.C3_HIRAGANA; const UInt16 IdeographicTypes = IdeographicKanaTypes | SafeNativeMethods.C3_IDEOGRAPH; bool isSameClass; // Assume just one of the two chars is ideographic, in which case // the chars are not in the same class. isSameClass = false; if (IsIdeographicCharType(preceedingType3) && IsIdeographicCharType(followingType3)) { // Both chars are ideographic. UInt16 typeDelta = (UInt16)((preceedingType3 & IdeographicTypes) ^ (followingType3 & IdeographicTypes)); // Only a few japanese ideographic chars are considered the same class. isSameClass = (preceedingType3 & IdeographicKanaTypes) != 0 && (typeDelta == 0 || typeDelta == SafeNativeMethods.C3_FULLWIDTH || typeDelta == SafeNativeMethods.C3_HIRAGANA || typeDelta == (SafeNativeMethods.C3_FULLWIDTH | SafeNativeMethods.C3_HIRAGANA)); } else if (!IsIdeographicCharType(preceedingType3) && !IsIdeographicCharType(followingType3)) { // Neither char is ideographic. isSameClass = (preceedingClass & CharClass.WBF_CLASS) == (followingClass & CharClass.WBF_CLASS); } return isSameClass; }
public static int NextWord(string text, int cursor, bool gtkMode) { int i, lf, cr; cr = LineEnd(text, cursor); if (cr < text.Length && text[cr] == '\r' && text[cr + 1] == '\n') { lf = cr + 1; } else { lf = cr; } // if the cursor is at the end of the line, return the starting offset of the next line if (cursor == cr || cursor == lf) { if (lf < text.Length) { return(lf + 1); } return(cursor); } if (gtkMode) { CharClass cc = GetCharClass(text[cursor]); i = cursor; // skip over the word, punctuation, or run of whitespace while (i < cr && GetCharClass(text[i]) == cc) { i++; } // skip any whitespace after the word/punct while (i < cr && char.IsWhiteSpace(text[i])) { i++; } } else { i = cursor; // skip to the end of the current word while (i < cr && !char.IsWhiteSpace(text[i])) { i++; } // skip any whitespace after the word while (i < cr && char.IsWhiteSpace(text[i])) { i++; } // find the start of the next word while (i < cr && !IsStartOfWord(text, i)) { i++; } } return(i); }
// Computes the character classes for each char of an array of text. private static CharClass[] GetClasses(char[] text) { CharClass[] classes = new CharClass[text.Length]; for (int i = 0; i < text.Length; i++) { CharClass classification; char ch = text[i]; if (ch < 0x0100) { classification = (CharClass)_latinClasses[ch]; } else if (IsKorean(ch)) { classification = CharClass.Alphanumeric; } else if (IsThai(ch)) { classification = CharClass.Alphanumeric; } else if (ch == ObjectReplacementChar) { classification = CharClass.Blank | CharClass.WBF_BREAKAFTER; } else { UInt16[] charType1 = new UInt16[1]; SafeNativeMethods.GetStringTypeEx(0 /* ignored */, SafeNativeMethods.CT_CTYPE1, new char[] { ch }, 1, charType1); if ((charType1[0] & SafeNativeMethods.C1_SPACE) != 0) { if ((charType1[0] & SafeNativeMethods.C1_BLANK) != 0) { classification = CharClass.Blank | CharClass.WBF_ISWHITE; } else { classification = CharClass.WhiteSpace | CharClass.WBF_ISWHITE; } } else if ((charType1[0] & SafeNativeMethods.C1_PUNCT) != 0 && !IsDiacriticOrKashida(ch)) { classification = CharClass.Punctuation; } else { classification = CharClass.Alphanumeric; } } classes[i] = classification; } return classes; }
public static int PreviousWord(string text, int cursor, bool gtkMode) { int begin; int i; int cr; int lf; lf = LineBegin(text, cursor) - 1; if (lf > 0 && text[lf] == '\n' && text[lf - 1] == '\r') { cr = lf - 1; } else { cr = lf; } // if the cursor is at the beginning of the line, return the end of the prev line if (cursor - 1 == lf) { return((cr > 0) ? cr : 0); } if (gtkMode) { CharClass cc = GetCharClass(text[cursor - 1]); begin = lf + 1; i = cursor; // skip over the word, punctuation, or run of whitespace while (i > begin && GetCharClass(text[i - 1]) == cc) { i--; } // if the cursor was at whitespace, skip back a word too if (cc == CharClass.CharClassWhitespace && i > begin) { cc = GetCharClass(text[i - 1]); while (i > begin && GetCharClass(text[i - 1]) == cc) { i--; } } } else { begin = lf + 1; i = cursor; if (cursor < text.Length) { // skip to the beginning of this word while (i > begin && !char.IsWhiteSpace(text[i - 1])) { i--; } if (i < cursor && IsStartOfWord(text, i)) { return(i); } } // skip to the start of the lwsp while (i > begin && char.IsWhiteSpace(text[i - 1])) { i--; } if (i > begin) { i--; } // skip to the beginning of the word while (i > begin && !IsStartOfWord(text, i)) { i--; } } return(i); }
/// <summary> /// Sets class of the character at specified index. /// </summary> public void SetCharClassAt(int index, CharClass klass) { _Classes[index] = klass; }
internal static CharGroup Create(CharClass value) { return(new CharClassCharGroup(value)); }
public CharClassCharPattern(CharClass value) { _value = value; }
public static bool IsCharClassOneOf(CharClass charClass, CharClass charClassSet) { return((charClass & charClassSet) != CharClass.Invalid); }
internal static CharGrouping Character(CharClass value) { return(new CharGrouping.CharacterClassCharGrouping(value)); }
public Npc(Position position, string name, Race race, CharClass charClass, Random rand) : base(position, MapMarkers.E, name, race, charClass, false) { this.FillInventory(); this.SetPassiveSkills(rand); }