private void UpdateThreatFromHealer(Transform healer, float healingValue)
{
if (CharacterUtilities.GetFaction(healer) != _faction)
{
UpdateThreat(healer, healingValue * PcHealingThreatModifier);
}
}
private void AddSymbolsToProduction(Production prod, List <string> list)
{
// Version 1.3.1 sends even empty lists to this method.
// Furthermore, version 1.3.1 no longer explicitly calls
// FixInternalReduction(). It is easier to adopt a consistent
// approach and let AddXxxToProd check for a trailing action
// prior to adding symbols or a new action.
//
if (list != null)
{
if (prod.semanticAction != null || prod.precSpan != null)
{
FixInternalReduction(prod);
}
foreach (string str in list)
{
Symbol symbol = null;
switch (TokenOf(str))
{
case Token.litchar: // This is a character literal symbol
if (GPCG.ImportedTokens && Terminal.BumpsMax(str))
{
handler.ListError(this.CurrentLocationSpan, 82, str, '\0');
}
symbol = grammar.LookupTerminal(Token.litchar, str);
break;
case Token.litstring: // This is a uned occurrence of a terminal alias.
String s = CharacterUtilities.CanonicalizeAlias(str);
if (!grammar.aliasTerms.ContainsKey(s))
{
handler.ListError(this.CurrentLocationSpan, 83, str, '\0');
}
else
{
symbol = grammar.aliasTerms[s];
if (symbol == Terminal.Ambiguous) // Use of an ambiguous alias.
{
handler.ListError(this.CurrentLocationSpan, 84, str, '\0');
}
}
break;
case Token.ident: // This is a used occurrence of a terminal name.
if (grammar.terminals.ContainsKey(str))
{
symbol = grammar.terminals[str];
}
else
{
symbol = grammar.LookupNonTerminal(str);
}
break;
}
prod.rhs.Add(symbol);
}
}
}
private void SpawnedGridsSuccessful(HashSet <MyCubeGrid> Grids)
{
GridUtilities.BiggestGrid(Grids, out MyCubeGrid BiggestGrid);
if (BiggestGrid != null && IdentityID != 0)
{
CharacterUtilities.SendGps(BiggestGrid.PositionComp.GetPosition(), BiggestGrid.DisplayName, IdentityID);
}
}
private void HandleOtherSelectionWhenActive(Transform selection)
{
if ((!CharacterUtilities.CharacterTargetsAllies(Transform)) && (!CharacterUtilities.CharactersAreAllies(Transform, selection)))
{
Debug.Log(Transform.name + ": targets HOSTILES - setting target to " + selection.name);
_statusEventDispatcher.FireStatusEvent(selection, StatusMessage.EnemyActionTargetSelected);
_statusEventDispatcher.FireStatusEvent(selection, StatusMessage.CharacterDeactivated);
}
}
internal static string GetVerbatimString(LexSpan span)
{
string text = span.ToString();
if (text[0] != '@' || text[1] != '\"' || text[text.Length - 1] != '\"')
{
throw new GppgInternalException("Internal error: invalid litstring");
}
text = text.Substring(2, text.Length - 3);
return(CharacterUtilities.InterpretEscapesInVerbatimString(text));
}
private void AttemptTargetAssignment(Transform requestingNpc)
{
List <Transform> targetList = CharacterUtilities.CharacterTargetsAllies(requestingNpc) ? _allies : _enemies;
Transform actionTarget = SelectTarget(targetList, requestingNpc);
if ((actionTarget != null) && (TargetAssignmentHandler != null))
{
Debug.Log("Assigning target " + actionTarget.name + " to " + requestingNpc.name);
TargetAssignmentHandler(requestingNpc, actionTarget);
}
}
private void HandleButtonEvent(string buttonName, bool isPressed)
{
if (SceneMovementButton.Movement_Buttons.Contains(buttonName))
{
_blockAction = isPressed;
_fieldMovementController.IgnoreFieldClickEvents = isPressed;
if (!CharacterUtilities.CharacterTargetsAllies(_transform))
{
_autoActionController.AutoActionDisabled = true;
}
}
}
private bool HasKeyword()
{
return(Grammar.Keywords.Keys.Any(k =>
{
if (k == null)
{
throw new ArgumentNullException(nameof(k));
}
var p1 = _source.ElementAtOrDefault(_currentCharOffset + k.Length);
return !CharacterUtilities.IsDigitLetterOrUnderscore(p1) &&
string.Equals(PeekMany(k.Length), k, StringComparison.InvariantCultureIgnoreCase);
}));
}
private void HandleSelfSelection()
{
if (CharacterUtilities.CharacterTargetsAllies(_currentActiveCharacter))
{
Debug.Log(_currentActiveCharacter.name + ": targets FRIENDLIES - setting target to " + Transform.name);
_statusEventDispatcher.FireStatusEvent(_currentActiveCharacter, StatusMessage.AlliedActionTargetSelected);
_statusEventDispatcher.FireStatusEvent(_currentActiveCharacter, StatusMessage.CharacterDeactivated);
}
else
{
Debug.Log(Transform.name + " was set to active");
_currentActiveCharacter = Transform;
_statusEventDispatcher.FireStatusEvent(StatusMessage.CharacterActivated);
}
}
internal string GetLitString(LexSpan span)
{
string text = span.ToString();
if (text[0] != '\"' || text[text.Length - 1] != '\"')
{
throw new GppgInternalException("Internal error: invalid litstring");
}
text = text.Substring(1, text.Length - 2);
try
{
text = CharacterUtilities.InterpretCharacterEscapes(text);
}
catch (StringInterpretException e)
{
handler.ListError(span, 70, e.Message, '\'');
}
return(text);
}
private bool CheckDistanceToLoadPoint(Vector3D LoadPoint)
{
if (!Config.RequireLoadRadius)
{
return(true);
}
double Distance = Vector3D.Distance(PlayerPosition, LoadPoint);
if (Distance < Config.LoadRadius)
{
return(true);
}
CharacterUtilities.SendGps(LoadPoint, "Load Point", IdentityID);
Chat.Respond("Cannot load! You are " + Math.Round(Distance, 0) + "m away from the load point! Check your GPS points!");
return(false);
}
private SyntaxNode Scan()
{
_state = (SafePeekChar(), SafePeekCharP1()) switch
{
var(c1, _) when c1.HasValue&& CharacterUtilities.IsWhitespace(c1.Value) => ScannerState.Whitespace,
('<', _) => ScannerState.Html,
('/', '/') => ScannerState.LineComment,
('/', '*') => ScannerState.BlockComment,
('#', _) => ScannerState.Preprocessor,
var(c1, c2) when c1.HasValue &&
c2.HasValue &&
Grammar.Punctuation.ContainsKey($"{c1.Value}{c2.Value}") =>
ScannerState.Punctuation2,
var(c1, _) when c1.HasValue&& Grammar.Punctuation.ContainsKey($"{c1.Value}") => ScannerState
.Punctuation1,
('"', _) => ScannerState.String,
var(c1, _) when c1.HasValue&& char.IsDigit(c1.Value) => ScannerState.Number,
('.', var c2)when c2.HasValue && char.IsDigit(c2.Value) => ScannerState.Number,
('-', var c2)when c2.HasValue && (char.IsDigit(c2.Value) || c2.Value == '.') => ScannerState.Number,
var(c1, _) when c1.HasValue&& char.IsLetter(c1.Value) => HasKeyword()
? ScannerState.Keyword
: ScannerState.Id,
var(c1, _) when c1.HasValue&& CharacterUtilities.IsDigitLetterOrUnderscore(c1.Value) => ScannerState
.Id,
_ => ScannerState.Nothing
};
if (_state == ScannerState.Nothing)
{
return(null);
}
NextNode();
return(_currentNode);
}
private SyntaxTrivia ScanWhitespace()
{
var start = _currentCharOffset;
_scratch.Clear();
while (true)
{
if (Empty())
{
break;
}
var c = CurrentChar;
if (!CharacterUtilities.IsWhitespace(c))
{
break;
}
_scratch.Append(c);
NextChar();
}
return(new SyntaxTrivia(SyntaxKind.WhitespaceTrivia, start, _currentCharOffset - start, _scratch.ToString()));
}
private SyntaxToken ScanId()
{
_scratch.Clear();
var start = _currentCharOffset;
if (!char.IsLetter(CurrentChar) && CurrentChar != '_')
{
throw GetException($"Expecting letter or _, found {CurrentChar}.");
}
_scratch.Append(CurrentChar);
NextChar();
while (true)
{
if (Empty())
{
break;
}
var c = CurrentChar;
if (CharacterUtilities.IsDigitLetterOrUnderscore(c))
{
_scratch.Append(c);
}
else
{
break;
}
NextChar();
}
return(new StringSyntax(SyntaxKind.IdToken, start, _currentCharOffset - start, _scratch.ToString()));
}
private static int Main(string[] args)
{
args = new[] { "/report", "/verbose", "/conflicts", "/babel", "SpecFiles\\BrightScript.y" };
Stream inputFile = null;
Grammar grammar = null;
ErrorHandler handler = new ErrorHandler();
string inputFileInfo = null; // Filename plus revision time.
Scanner scanner = null;
Parser parser = null;
Assembly assm = Assembly.GetExecutingAssembly();
object info = Attribute.GetCustomAttribute(assm, typeof(AssemblyFileVersionAttribute));
versionInfo = ((AssemblyFileVersionAttribute)info).Version;
try {
string filename = ProcessOptions(args);
if (filename == null)
{
return(MC_OK);
}
try {
inputFile = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
inputFileInfo = filename + " - " + File.GetLastWriteTime(filename).ToString();
}
catch (IOException x) {
string message;
inputFile = null;
if (x is FileNotFoundException)
{
message = String.Format(CultureInfo.InvariantCulture,
"Source file <{0}> not found{1}",
filename, Environment.NewLine);
}
else
{
message = String.Format(CultureInfo.InvariantCulture,
"Source file <{0}> could not be opened{1}",
filename, Environment.NewLine);
}
handler.AddError(4, message, null); // aast.AtStart;
return(MC_FILEERROR);
}
scanner = new Scanner(inputFile);
scanner.SetHandler(handler);
parser = new Parser(filename, inputFileInfo, scanner, handler);
//
// If the parse is successful, then process the grammar.
// Otherwise just report the errors that have been listed.
//
if (parser.Parse() && !handler.Errors)
{
grammar = parser.Grammar;
if (Terminal.Max > 255)
{
// No ambiguating context possible since result appears in delimited error message
handler.ListError(null, 103, CharacterUtilities.MapCodepointToDisplayForm(Terminal.Max), '\'');
}
LALRGenerator generator = new LALRGenerator(grammar);
List <AutomatonState> states = generator.BuildStates();
generator.ComputeLookAhead();
generator.BuildParseTable();
if (!grammar.CheckGrammar())
{
throw new ArgumentException("Non-terminating grammar");
}
//
// If the grammar has non-terminating non-terms we cannot
// create a diagnostic report as the grammar is incomplete.
//
if (!handler.Errors)
{
CodeGenerator emitter = new CodeGenerator(grammar);
emitter.Generate(states);
}
bool DoDiagnose = Diagnose && !grammar.HasNonTerminatingNonTerms;
if (Report || DoDiagnose)
{
string htmlName = System.IO.Path.ChangeExtension(filename, ".report.html");
try {
System.IO.FileStream htmlFile = new System.IO.FileStream(htmlName, System.IO.FileMode.Create);
System.IO.StreamWriter htmlWriter = new System.IO.StreamWriter(htmlFile);
Grammar.HtmlHeader(htmlWriter, filename);
if (Report && DoDiagnose)
{
grammar.GenerateCompoundReport(htmlWriter, inputFileInfo, states);
}
else if (Report)
{
grammar.GenerateReport(htmlWriter, inputFileInfo, states);
}
Grammar.HtmlTrailer(htmlWriter);
if (htmlFile != null)
{
htmlWriter.Flush();
htmlFile.Close();
}
}
catch (System.IO.IOException) {
Console.Error.WriteLine("Cannot create html output file {0}", htmlName);
}
}
}
}
catch (System.Exception e) {
if (e is TooManyErrorsException)
{
return(MC_TOOMANYERRORS);
}
Console.Error.WriteLine("Unexpected Error {0}", e.Message);
if (NoThrowOnError)
{
// report the error, do not let it go into the void
Console.Error.WriteLine(e);
return(MC_EXCEPTION);
}
}
finally {
if (handler.Errors || handler.Warnings)
{
handler.DumpAll((scanner == null ? null : scanner.Buffer), Console.Error);
}
if ((Listing || handler.Errors || handler.Warnings) && parser != null)
{
string listName = parser.ListfileName;
StreamWriter listStream = ListingFile(listName);
if (listStream != null)
{
handler.MakeListing(scanner.Buffer, listStream, parser.SourceFileInfo, versionInfo);
}
}
Console.WriteLine("Press any enter to close");
Console.ReadLine();
}
return(MC_OK);
}
private bool CheckEnemyDistance(LoadType LoadingAtSavePoint, Vector3D Position = new Vector3D())
{
if (LoadingAtSavePoint == LoadType.ForceLoadMearPlayer)
{
Position = PlayerPosition;
}
MyFaction PlayersFaction = MySession.Static.Factions.GetPlayerFaction(IdentityID);
bool EnemyFoundFlag = false;
if (Config.DistanceCheck > 0)
{
//Check enemy location! If under limit return!
foreach (MyCharacter OnlinePlayer in MyEntities.GetEntities().OfType <MyCharacter>())
{
if (OnlinePlayer == null || OnlinePlayer.MarkedForClose)
{
continue;
}
long PlayerID = OnlinePlayer.GetPlayerIdentityId();
if (PlayerID == 0L)
{
continue;
}
if (PlayerID == IdentityID)
{
continue;
}
MyFaction TargetPlayerFaction = MySession.Static.Factions.GetPlayerFaction(PlayerID);
if (PlayersFaction != null && TargetPlayerFaction != null)
{
if (PlayersFaction.FactionId == TargetPlayerFaction.FactionId)
{
continue;
}
//Neutrals count as allies not friends for some reason
MyRelationsBetweenFactions Relation = MySession.Static.Factions.GetRelationBetweenFactions(PlayersFaction.FactionId, TargetPlayerFaction.FactionId).Item1;
if (Relation == MyRelationsBetweenFactions.Neutral || Relation == MyRelationsBetweenFactions.Friends)
{
continue;
}
}
if (Vector3D.Distance(Position, OnlinePlayer.PositionComp.GetPosition()) == 0)
{
continue;
}
if (Vector3D.Distance(Position, OnlinePlayer.PositionComp.GetPosition()) <= Config.DistanceCheck)
{
Chat?.Respond("Unable to load grid! Enemy within " + Config.DistanceCheck + "m!");
CharacterUtilities.SendGps(Position, "Failed Hangar Load! (Enemy nearby)", IdentityID);
EnemyFoundFlag = true;
break;
}
}
}
if (Config.GridDistanceCheck > 0 && Config.GridCheckMinBlock > 0 && EnemyFoundFlag == false)
{
BoundingSphereD SpawnSphere = new BoundingSphereD(Position, Config.GridDistanceCheck);
List <MyEntity> entities = new List <MyEntity>();
MyGamePruningStructure.GetAllTopMostEntitiesInSphere(ref SpawnSphere, entities);
//This is looping through all grids in the specified range. If we find an enemy, we need to break and return/deny spawning
foreach (MyCubeGrid Grid in entities.OfType <MyCubeGrid>())
{
if (Grid == null || Grid.MarkedForClose)
{
continue;
}
if (Grid.BigOwners.Count <= 0 || Grid.CubeBlocks.Count < Config.GridCheckMinBlock)
{
continue;
}
if (Grid.BigOwners.Contains(IdentityID))
{
continue;
}
//if the player isnt big owner, we need to scan for faction mates
bool FoundAlly = true;
foreach (long Owner in Grid.BigOwners)
{
MyFaction TargetPlayerFaction = MySession.Static.Factions.GetPlayerFaction(Owner);
if (PlayersFaction != null && TargetPlayerFaction != null)
{
if (PlayersFaction.FactionId == TargetPlayerFaction.FactionId)
{
continue;
}
MyRelationsBetweenFactions Relation = MySession.Static.Factions.GetRelationBetweenFactions(PlayersFaction.FactionId, TargetPlayerFaction.FactionId).Item1;
if (Relation == MyRelationsBetweenFactions.Enemies)
{
FoundAlly = false;
break;
}
}
else
{
FoundAlly = false;
break;
}
}
if (!FoundAlly)
{
//Stop loop
Chat?.Respond("Unable to load grid! Enemy within " + Config.GridDistanceCheck + "m!");
CharacterUtilities.SendGps(Position, "Failed Hangar Load! (Enemy nearby)", IdentityID);
EnemyFoundFlag = true;
break;
}
}
}
return(!EnemyFoundFlag);
}
/// <summary>
/// Create a transition path in the NFSA from the given
/// start state to the given end state, corresponding to the
/// RegEx tree value. The method may (almost always does)
/// create new NFSA states and recurses to make paths for
/// the subtrees of the given tree.
/// </summary>
/// <param name="tree">The tree to encode</param>
/// <param name="start">The start state for the pattern</param>
/// <param name="end">The end state for the pattern</param>
internal void MakePath(RegExTree tree, NState startState, NState endState)
{
NState tmp1 = null;
switch (tree.op)
{
case RegOp.eof:
break;
// Binary nodes ===================================
case RegOp.context:
case RegOp.concat:
case RegOp.alt:
// Binary nodes ===================================
Binary binNode = tree as Binary;
switch (tree.op)
{
case RegOp.context:
int rLen = binNode.rKid.contextLength();
int lLen = binNode.lKid.contextLength();
if (rLen <= 0 && lLen <= 0)
{
throw new StringInterpretException("variable right context '/' not implemented");
}
else
{
endState.rhCntx = rLen;
endState.lhCntx = lLen;
tmp1 = MkState();
MakePath(binNode.lKid, startState, tmp1);
MakePath(binNode.rKid, tmp1, endState);
}
break;
case RegOp.concat:
tmp1 = MkState();
MakePath(binNode.lKid, startState, tmp1);
MakePath(binNode.rKid, tmp1, endState);
break;
case RegOp.alt:
tmp1 = MkState();
MakePath(binNode.lKid, startState, tmp1);
tmp1.AddEpsTrns(endState);
tmp1 = MkState();
MakePath(binNode.rKid, startState, tmp1);
tmp1.AddEpsTrns(endState);
break;
}
break;
// Unary nodes ===================================
case RegOp.closure:
case RegOp.finiteRep:
// Unary nodes ===================================
Unary unaryNode = tree as Unary;
switch (tree.op)
{
case RegOp.closure:
NState tmp2 = MkState();
if (unaryNode.minRep == 0)
{
tmp1 = MkState();
startState.AddEpsTrns(tmp1);
}
else
{
NState dummy = startState;
for (int i = 0; i < unaryNode.minRep; i++)
{
tmp1 = MkState();
MakePath(unaryNode.kid, dummy, tmp1);
dummy = tmp1;
}
}
MakePath(unaryNode.kid, tmp1, tmp2);
tmp2.AddEpsTrns(tmp1);
tmp1.AddEpsTrns(endState);
break;
case RegOp.finiteRep:
{
NState dummy = tmp1 = startState;
for (int i = 0; i < unaryNode.minRep; i++)
{
tmp1 = MkState();
MakePath(unaryNode.kid, dummy, tmp1);
dummy = tmp1;
}
tmp1.AddEpsTrns(endState);
for (int i = unaryNode.minRep; i < unaryNode.maxRep; i++)
{
tmp1 = MkState();
MakePath(unaryNode.kid, dummy, tmp1);
dummy = tmp1;
dummy.AddEpsTrns(endState);
}
}
break;
}
break;
// Leaf nodes ===================================
case RegOp.litStr:
case RegOp.primitive:
case RegOp.charClass:
// Leaf nodes ===================================
Leaf leafNode = tree as Leaf;
switch (tree.op)
{
case RegOp.litStr:
{
// Make a linear sequence of states with successive
// transitions on successive string characters.
//
string text = leafNode.str;
NState dummy = startState;
// Need to deal with special case of empty string
if (text.Length == 0)
{
dummy.AddEpsTrns(endState);
}
else
{
// This code is complicated by the fact that unicode
// escape substitution may have inserted surrogate
// pairs of characters in the string. We need
// one transition for every unicode codepoint,
// not one for every char value in this string.
//
int index = 0;
int code = CharacterUtilities.CodePoint(text, ref index); // First character
int next = CharacterUtilities.CodePoint(text, ref index); // Next, possibly -1
while (next >= 0)
{
tmp1 = MkState();
dummy.AddChrTrns(code, tmp1);
dummy = tmp1;
code = next;
next = CharacterUtilities.CodePoint(text, ref index);
}
// Postcondition ==> "code" is the last char.
dummy.AddChrTrns(code, endState);
}
}
break;
case RegOp.primitive:
startState.AddChrTrns(leafNode.chVal, endState);
break;
case RegOp.charClass:
startState.AddClsTrans(leafNode, endState);
break;
}
break;
default: throw new GplexInternalException("unknown tree op");
}
}
private bool CheckZoneRestrictions(bool IsSave)
{
if (Config.ZoneRestrictions.Count != 0)
{
//Get save point
int ClosestPoint = -1;
double Distance = -1;
for (int i = 0; i < Config.ZoneRestrictions.Count(); i++)
{
Vector3D ZoneCenter = new Vector3D(Config.ZoneRestrictions[i].X, Config.ZoneRestrictions[i].Y, Config.ZoneRestrictions[i].Z);
double PlayerDistance = Vector3D.Distance(ZoneCenter, PlayerPosition);
if (PlayerDistance <= Config.ZoneRestrictions[i].Radius)
{
//if player is within range
if (IsSave && !Config.ZoneRestrictions[i].AllowSaving)
{
Chat?.Respond("You are not permitted to save grids in this zone");
return(false);
}
if (!IsSave && !Config.ZoneRestrictions[i].AllowLoading)
{
Chat?.Respond("You are not permitted to load grids in this zone");
return(false);
}
return(true);
}
if (IsSave && Config.ZoneRestrictions[i].AllowSaving)
{
if (ClosestPoint == -1 || PlayerDistance <= Distance)
{
ClosestPoint = i;
Distance = PlayerDistance;
}
}
if (!IsSave && Config.ZoneRestrictions[i].AllowLoading)
{
if (ClosestPoint == -1 || PlayerDistance <= Distance)
{
ClosestPoint = i;
Distance = PlayerDistance;
}
}
}
Vector3D ClosestZone = new Vector3D();
try
{
ClosestZone = new Vector3D(Config.ZoneRestrictions[ClosestPoint].X, Config.ZoneRestrictions[ClosestPoint].Y, Config.ZoneRestrictions[ClosestPoint].Z);
}
catch (Exception e)
{
Chat?.Respond("No areas found!");
//Log.Warn(e, "No suitable zones found! (Possible Error)");
return(false);
}
if (IsSave)
{
CharacterUtilities.SendGps(ClosestZone, Config.ZoneRestrictions[ClosestPoint].Name + " (within " + Config.ZoneRestrictions[ClosestPoint].Radius + "m)", IdentityID);
Chat?.Respond("Nearest save area has been added to your HUD");
return(false);
}
else
{
CharacterUtilities.SendGps(ClosestZone, Config.ZoneRestrictions[ClosestPoint].Name + " (within " + Config.ZoneRestrictions[ClosestPoint].Radius + "m)", IdentityID);
//Chat chat = new Chat(Context);
Chat?.Respond("Nearest load area has been added to your HUD");
return(false);
}
}
return(true);
}
