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;
}
public CharacterClassCharGrouping(CharClass value)
{
_value = value;
}
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);
}
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;
}
