private static XElement TryToGradeWordProblem(XElement xmlPda, XElement xmlWordsInLanguage, XElement xmlWordsNotInLanguage, XElement xmlMaxGrade, CancellationToken token)
{
var pda = PDA <char, char> .FromXml(xmlPda);
pda.CreateRunner(token);
var alphabet = PDAXmlParser.ParseAlphabetFromXmlPDA(xmlPda);
var maxGrade = int.Parse(xmlMaxGrade.Value);
var wordsIn = xmlWordsInLanguage.Elements().Select(xmlWord => string.Concat(xmlWord.Value)).ToList(); //.Take(maximumWordLength)
var wordsNotIn = xmlWordsNotInLanguage.Elements().Select(xmlWord => string.Concat(xmlWord.Value)).ToList(); //.Take(maximumWordLength)
var feedback = new List <string>();
int numberOfCorrectWords;
try
{
numberOfCorrectWords = CheckWordsInLanguage(wordsIn, alphabet, pda, feedback) + CheckWordsNotInLanguage(wordsNotIn, alphabet, pda, feedback);
}
catch (InconsistentPDAException)
{
return(Grader.CreateXmlFeedback(maxGrade, new List <string>()
{
"Oops! Seems like your tutor created an inconsistent pda...therefore, you get the full grade ;)"
}));
}
int totalNumberOfWords = wordsIn.Count() + wordsNotIn.Count();
int grade = (int)((double)numberOfCorrectWords * maxGrade / totalNumberOfWords);
if (grade == maxGrade)
{
feedback.Add("Correct!");
}
return(Grader.CreateXmlFeedback(grade, feedback));
}
public void SimulationRunnerComparisonTest()
{
var pda = new PDA <char, char>(new AcceptanceCondition.EmptyStack(), false, 'Z', false, "Z");
pda.AddState(1, false);
pda.AddTransition().From(0).To(0).Read().Pop('Z').Push("ZZZZZZZZZZZZZZZZZZ");
pda.AddTransition().From(0).To(1).Read().Pop('Z').Push();
pda.AddTransition().From(1).To(1).Read('a').Pop('Z').Push();
var word = "aaaaaaaaaaaaaaaaa".ToCharArray();
var s = new Stopwatch();
s.Start();
var path1 = CFGSimulationRunner <char> .RunSimulation(pda, word);
s.Stop();
Console.WriteLine(s.ElapsedMilliseconds);
s.Restart();
pda.CreateRunner();
var path2 = DirectSimulationRunner <char, char> .RunSimulation(pda, word);
s.Stop();
Console.WriteLine(s.ElapsedMilliseconds);
}
private static void AddStatesToPDA(PDA <A, S> origin, PDA <A, StackSymbolSequence <S> > target)
{
foreach (var state in origin.States.Where(s => s.Key != origin.InitialState.Id))
{
target.AddState(state.Key, state.Value.Final);
}
}
private static XElement TryToRunSimulation(XElement xmlPda, XElement xmlWord, CancellationToken token)
{
var pda = PDA <char, char> .FromXml(xmlPda);
var word = xmlWord.Value;
try
{
SimulationPath <char, char> path;
if (pda.Deterministic)
{
path = DPDASimulationRunner <char, char> .RunSimulation(pda, word.ToArray(), pda.AcceptanceCondition, token);
}
else
{
path = CFGSimulationRunner <char> .RunSimulation(pda, word.ToArray(), token);
}
XNamespace xNamespace = @ns;
return(new XElement(xNamespace + "div", path.ToXml()));
}
catch (InconsistentPDAException ex)
{
return(Error(ex.Message));
}
catch (NoAcceptanceException ex)
{
return(Error(ex.Message));
}
}
private static void UpdateLocalPlayerPda(INitroxPlayer player, PingInstance ping)
{
PDA localPlayerPda = Player.main.GetPDA();
GameObject pdaScreenGameObject = localPlayerPda.ui.gameObject;
GameObject pingTabGameObject = pdaScreenGameObject.transform.Find("Content/PingManagerTab").gameObject;
uGUI_PingTab pingTab = pingTabGameObject.GetComponent <uGUI_PingTab>();
MethodInfo updateEntities = typeof(uGUI_PingTab).GetMethod("UpdateEntries", BindingFlags.NonPublic | BindingFlags.Instance);
updateEntities.Invoke(pingTab, new object[] { });
FieldInfo pingTabEntriesField = typeof(uGUI_PingTab).GetField("entries", BindingFlags.NonPublic | BindingFlags.Instance);
Dictionary <int, uGUI_PingEntry> pingEntries = (Dictionary <int, uGUI_PingEntry>)pingTabEntriesField.GetValue(pingTab);
uGUI_PingEntry pingEntry = pingEntries[ping.GetInstanceID()];
pingEntry.icon.color = player.PlayerSettings.PlayerColor;
GameObject pingEntryGameObject = pingEntry.gameObject;
pingEntryGameObject.transform.Find("ColorToggle").gameObject.SetActive(false);
if (!localPlayerPda.isInUse)
{
pdaScreenGameObject.gameObject.SetActive(false);
}
}
static void Main(string[] args)
{
var inputAlphabet = new List <char> {
'(', ')'
};
var stackAlphabet = new List <char> {
'('
};
var states = new HashSet <int> {
0
};
var transitions = new List <PDATransition>
{
new PDATransition('(', '_', 0, 0, "("),
new PDATransition('(', '(', 0, 0, "(("),
new PDATransition(')', '(', 0, 0, "")
};
var pda = new PDA(inputAlphabet, stackAlphabet, states, 0, transitions);
Console.WriteLine(pda.DoesMatch("")); // True
Console.WriteLine(pda.DoesMatch("(())")); // True
Console.WriteLine(pda.DoesMatch("(()")); // False
Console.WriteLine(pda.DoesMatch("((())()(()))")); // True
}
public void RunSimulationCFGTest3()
{
var pda = new PDA <char, char>(new AcceptanceCondition.FinalState(), false, 'Z', false, "ZXY", 'V');
pda.AddState(1, false);
pda.AddState(2, true);
pda.AddTransition().From(0).To(0).Read('a').Pop('Z').Push("XZ");
pda.AddTransition().From(0).To(0).Read('a').Pop('X').Push("XX");
pda.AddTransition().From(0).To(0).Read('a').Pop('Y').Push("XY");
pda.AddTransition().From(0).To(0).Read('b').Pop('Z').Push("YZ");
pda.AddTransition().From(0).To(0).Read('b').Pop('Y').Push("YY");
pda.AddTransition().From(0).To(0).Read('b').Pop('X').Push("YX");
pda.AddTransition().From(0).To(1).Read().Pop('X').Push("X");
pda.AddTransition().From(0).To(1).Read().Pop('Y').Push("Y");
pda.AddTransition().From(0).To(1).Read().Pop('Z').Push("Z");
pda.AddTransition().From(1).To(1).Read('a').Pop('X').Push();
pda.AddTransition().From(1).To(1).Read('b').Pop('Y').Push();
pda.AddTransition().From(1).To(2).Read().Pop('Z').Push("ZZ");
pda.CreateRunner();
var path = CFGSimulationRunner <char> .RunSimulation(pda, "abaabbaaba".ToCharArray());
var act = path.ToXml();
var reader = new StreamReader(@"..\..\..\TestPDL\PDATest\XmlPathCFG3.xml");
XmlDocument expXmlDoc = new XmlDocument();
expXmlDoc.Load(reader);
XDocument xDoc = XDocument.Load(new XmlNodeReader(expXmlDoc));
var exp = xDoc.Root;
Assert.IsTrue(XNode.DeepEquals(exp, act));
}
private void OpenPDA()
{
bool isStorageTypeExists = TechTypeHandler.TryGetModdedTechType(storageModuleString, out TechType techType);
if (!isStorageTypeExists)
{
return;
}
ItemsContainer storageInSlot = helper.GetSeamothStorageInSlot(slotID, techType);
if (storageInSlot != null)
{
PDA pda = Player.main.GetPDA();
Inventory.main.SetUsedStorage(storageInSlot, false);
if (!pda.Open(PDATab.Inventory, tr, new PDA.OnClose(OnClosePDA)))
{
OnClosePDA(pda);
}
}
else
{
OnClosePDA(null);
}
}
private void OnFridgeClose(PDA pda)
{
foreach (InventoryItem item in _dumpContainer)
{
GameObject.Destroy(item.item.gameObject);
}
}
public void TestRealDPDAToNormalForm()
{
var dpda = new PDA <char, char>(new AcceptanceCondition.EmptyStack(), true, 'Z', false, "ZYX", 'A');
dpda.AddState(1, false);
dpda.AddTransition().From(0).To(0).Read('a').Pop('Z').Push("XZ");
dpda.AddTransition().From(0).To(0).Read('a').Pop('X').Push("XX");
dpda.AddTransition().From(0).To(0).Read('a').Pop('Y').Push("XY");
dpda.AddTransition().From(0).To(0).Read('b').Pop('Z').Push("YZ");
dpda.AddTransition().From(0).To(0).Read('b').Pop('X').Push("YX");
dpda.AddTransition().From(0).To(0).Read('b').Pop('Y').Push("YY");
dpda.AddTransition().From(0).To(1).Read('x').Pop('Z').Push("Z");
dpda.AddTransition().From(0).To(1).Read('x').Pop('X').Push("X");
dpda.AddTransition().From(0).To(1).Read('x').Pop('Y').Push("Y");
dpda.AddTransition().From(1).To(1).Read('a').Pop('X').Push();
dpda.AddTransition().From(1).To(1).Read('b').Pop('Y').Push();
dpda.AddTransition().From(1).To(1).Read().Pop('Z').Push();
var dpdaInNormalForm = DPDAToNormalFormConverter <char, char> .ToNormalForm(dpda);
dpda.CreateRunner();
dpdaInNormalForm.CreateRunner();
var equalityResult = new PDAEqualityResult <char, StackSymbolSequence <char> >(dpda, dpdaInNormalForm, "abx", 10, 600000, 3000);
Assert.IsTrue(equalityResult.AreEqual);
}
public static SimulationPath <A, S> RunSimulation(PDA <A, S> pda, A[] word)
{
var acceptanceResult = pda.AcceptsWord(word);
if (!acceptanceResult.Accepts())
{
throw new NoAcceptanceException("the pda does not accept the word, therefore, a simulation is not possible");
}
var initialNode = SimulationNode <A, S> .InitialNode(
new Configuration <A, S>(pda.InitialState, new Word <A>(word), CurrentStack <S> .WithSingleSymbol(pda.FirstStackSymbol)),
pda.AcceptanceCondition);
var frontChain = new List <SimulationNode <A, S> > {
initialNode
};
while (frontChain.Count() > 0)
{
var nodesAcceptedWord = frontChain.Where(node => node.HasAcceptedWord).ToList();
if (nodesAcceptedWord.Count() > 0)
{
return(SimulationPathFromFinalNode(nodesAcceptedWord.First()));
}
foreach (var node in frontChain)
{
node.DoStep();
}
frontChain = frontChain.SelectMany(node => node.Children).ToList();
}
throw new InvalidOperationException("the given pda does not accept the word, therefore a simulation is not possible");
}
public static bool Prefix(ref uGUI_DepthCompass __instance, ref bool __result)
{
if (__instance == null)
{
__result = false;
return(false);
}
if (!__instance._initialized)
{
__result = false;
return(false);
}
if (!uGUI.isMainLevel)
{
__result = false;
return(false);
}
if (LaunchRocket.isLaunching)
{
__result = false;
return(false);
}
if (uGUI.isIntro)
{
__result = false;
return(false);
}
Player main = Player.main;
if (main == null)
{
__result = false;
return(false);
}
PDA pda = main.GetPDA();
if (pda != null && pda.isInUse)
{
__result = false;
return(false);
}
Player.Mode mode = main.GetMode();
if (mode == Player.Mode.Piloting)
{
__result = false;
return(false);
}
Inventory main2 = Inventory.main;
if (main2 != null && main2.equipment != null && TechTypeCheck(main2))
{
__result = true;
return(false);
}
uGUI_CameraDrone main3 = uGUI_CameraDrone.main;
__result = main3 != null && main3.GetCamera() != null;
return(false);
}
public void OpenStorage()
{
Player main = Player.main;
PDA pda = main.GetPDA();
Inventory.main.SetUsedStorage(_dumpContainer, false);
pda.Open(PDATab.Inventory, null, OnDumpClose, 4f);
}
public static void PDA_getui_Postfix(PDA __instance)
{
uGUI_CanvasScaler component = Traverse.Create(__instance).Field("screen").GetValue <GameObject>().GetComponent <uGUI_CanvasScaler>();
__instance.transform.localScale = new Vector3(MainPatcher.pdaScale, MainPatcher.pdaScale, 1f);
component.transform.localScale = Vector3.one * MainPatcher.screenScale;
component.SetAnchor(__instance.screenAnchor);
}
public void MergeDPDAsWithEmptyStackTest()
{
var dpda1 = new PDA <char, char>(new AcceptanceCondition.EmptyStack(), true, 'A', false, "ABC", 'Z');
dpda1.AddState(1, false);
dpda1.AddState(2, false);
dpda1.AddState(3, false);
dpda1.AddState(4, false);
dpda1.AddState(5, false);
dpda1.AddState(6, false);
dpda1.AddState(7, false);
dpda1.AddTransition().From(0).To(1).Read().Pop('A').Push("AAA");
dpda1.AddTransition().From(1).To(2).Read('a').Pop('A').Push();
dpda1.AddTransition().From(2).To(3).Read('a').Pop('A').Push();
dpda1.AddTransition().From(3).To(4).Read().Pop('A').Push("BBCC");
dpda1.AddTransition().From(4).To(4).Read('b').Pop('B').Push();
dpda1.AddTransition().From(4).To(4).Read('c').Pop('C').Push();
dpda1.AddTransition().From(1).To(5).Read().Pop('B').Push();
dpda1.AddTransition().From(2).To(6).Read().Pop('B').Push("B");
dpda1.AddTransition().From(6).To(7).Read().Pop('B').Push("B");
dpda1.AddTransition().From(7).To(6).Read().Pop('B').Push("B");
var dpda2 = new PDA <char, char>(new AcceptanceCondition.EmptyStack(), true, 'A', false, "ABC", 'Z');
dpda2.AddState(1, false);
dpda2.AddState(2, false);
dpda2.AddState(3, false);
dpda2.AddState(4, false);
dpda2.AddTransition().From(0).To(1).Read().Pop('A').Push("AAA");
dpda2.AddTransition().From(1).To(2).Read('a').Pop('A').Push();
dpda2.AddTransition().From(2).To(3).Read('a').Pop('A').Push();
dpda2.AddTransition().From(3).To(4).Read().Pop('A').Push("BBCC");
dpda2.AddTransition().From(4).To(4).Read('b').Pop('B').Push();
dpda2.AddTransition().From(4).To(4).Read('c').Pop('C').Push();
var mergedDPDAForSimulationOf1 = PDATransformer <char, char> .MergeDPDAsWithEmptyStack(dpda1, dpda2, 'X', 'Y');
dpda1.CreateRunner();
mergedDPDAForSimulationOf1.CreateRunner();
var equalityResult1 = new PDAEqualityResult <char, char>(dpda1, mergedDPDAForSimulationOf1, "abc", 10, 400000, 3000);
Assert.IsTrue(equalityResult1.AreEqual);
var mergedDPDAForSimulationOf2 = PDATransformer <char, char> .MergeDPDAsWithEmptyStack(dpda2, dpda1, 'X', 'Y');
dpda2.CreateRunner();
mergedDPDAForSimulationOf2.CreateRunner();
var equalityResult2 = new PDAEqualityResult <char, char>(dpda2, mergedDPDAForSimulationOf2, "abc", 10, 400000, 3000);
Assert.IsTrue(equalityResult2.AreEqual);
}
// Completely replaces the original OnUse method in the BaseBioReactor
internal void OnPdaOpen(BaseBioReactorGeometry model)
{
pdaIsOpen = true;
PDA pda = Player.main.GetPDA();
Inventory.main.SetUsedStorage(this.BioReactor.container, false);
pda.Open(PDATab.Inventory, model.storagePivot, new PDA.OnClose(OnPdaClose), 4f);
}
public ActionResult TOEdit(PDA p)
{
PDA pp = PDA.GetEntityByID(p.ID);
pp.SupplierId = p.SupplierId;
int rtn = pp.UpdateByID();
return(Content(rtn > 0 ? "ok" : "修改出错了！！"));
}
public static PDA <A, S> ToDPDAWithNormalEpsilonTransitions(PDA <A, S> dpda)
{
Assertion.Assert(dpda.Deterministic, "the epsilon transitions can only be normalized for a deterministic PDA, but the given is not");
var res = dpda.Clone();
CorrectEpsilonTransitions(res);
return(res);
}
private void Awake()
{
objectHelper = Main.objectHelper;
Instance = gameObject.GetComponent <LaserCannonControl>();
thisSeamoth = Instance.GetComponent <SeaMoth>();
energyMixin = thisSeamoth.GetComponent <EnergyMixin>();
playerMain = Player.main;
PdaMain = playerMain.GetPDA();
isPlayerInThisVehicle = playerMain.GetVehicle() == thisSeamoth ? true : false;
GameObject repulsionCannonPrefab = Instantiate(Resources.Load <GameObject>("WorldEntities/Tools/RepulsionCannon"));
shootSound = objectHelper.GetObjectClone(repulsionCannonPrefab.GetComponent <RepulsionCannon>().shootSound);
DestroyImmediate(repulsionCannonPrefab);
loopingEmitter = gameObject.AddComponent <FMOD_CustomLoopingEmitter>();
loopingEmitter.asset = shootSound;
GameObject powerTransmitterPrefab = Instantiate(Resources.Load <GameObject>("Submarine/Build/PowerTransmitter"));
GameObject laserBeam = objectHelper.GetGameObjectClone(powerTransmitterPrefab.GetComponent <PowerFX>().vfxPrefab, null, false);
LineRenderer lineRenderer = laserBeam.GetComponent <LineRenderer>();
lineRenderer.startWidth = 0.2f;
lineRenderer.endWidth = 0.2f;
lineRenderer.positionCount = 2;
lineRenderer.receiveShadows = false;
lineRenderer.loop = false;
laserRight = objectHelper.GetGameObjectClone(laserBeam, thisSeamoth.torpedoTubeRight, false);
laserRight.name = "laserRight";
laserRight.transform.localPosition = Vector3.zero;
laserRight.transform.localRotation = Quaternion.identity;
rightBeam = laserRight.GetComponent <LineRenderer>();
laserLeft = objectHelper.GetGameObjectClone(laserBeam, thisSeamoth.torpedoTubeLeft, false);
laserLeft.name = "laserLeft";
laserLeft.transform.localPosition = Vector3.zero;
laserLeft.transform.localRotation = Quaternion.identity;
leftBeam = laserLeft.GetComponent <LineRenderer>();
DestroyImmediate(laserBeam);
DestroyImmediate(powerTransmitterPrefab);
OnConfigChanged(true);
thisSeamoth.onToggle += OnToggle;
thisSeamoth.modules.onAddItem += OnAddItem;
thisSeamoth.modules.onRemoveItem += OnRemoveItem;
playerMain.playerModeChanged.AddHandler(this, new Event <Player.Mode> .HandleFunction(OnPlayerModeChanged));
Main.OnConfigChanged.AddHandler(this, new Event <bool> .HandleFunction(OnConfigChanged));
}
public static void openPDA()
{
PDA pda = Player.main.GetPDA();
if (!pda.Open())
{
return;
}
}
private static void AddTransitions(SDA <A, TripleStackSymbol <S> > sda, PDA <A, S> dpda, Dictionary <string, TripleStackSymbol <S> > stackSymbols)
{
var transitions = dpda.States.SelectMany(s => s.Value.Transitions).ToList();
foreach (var t in transitions.Where(t => !t.SymbolIn.IsEmpty()))
{
AddTransition(t, sda, dpda, stackSymbols);
}
}
public static Node <A, S> NodeInEmptyStackPathBackToFinalStatePath(PDA <A, S> pdaWithFinalState, Node <A, S> node, bool firstNode)
{
var oldStackLength = node.Config.Stack.StackSymbols.Count();
var config = new Configuration <A, S>(
pdaWithFinalState.States[node.Config.State.Id - 1],
node.Config.RemainingWord,
new CurrentStack <S>(node.Config.Stack.StackSymbols.Take(oldStackLength - 1)));
return(new Node <A, S>(config, firstNode ? null : node.TransitionToHere));
}
private static bool CheckIfStackIsEmpty <U, V>(PDA <U, V> pda, Transition <U, V> epsilonTransition, VirtualConfiguration <U, V> currentConfig) where U : IEquatable <U> where V : IEquatable <V>
{
if (currentConfig.stack.Count() == 0)
{
pda.RemoveTransition(epsilonTransition);
pda.AddTransition().From(epsilonTransition.Origin.Id).To(currentConfig.state.Id).Read().Pop(epsilonTransition.StackSymbolIn).Push();
return(true);
}
return(false);
}
public void OnHandClick(HandTargetEventData data)
{
PDA pda = Player.main.GetPDA();
if (!pda.isInUse)
{
Inventory.main.SetUsedStorage(equipment, false);
pda.Open(PDATab.Inventory, transform, null);
}
}
private static SimulationPath <A, char> RunSimulationWithCFGForFinalState(PDA <A, char> pda, A[] word, CancellationToken token)
{
Assertion.Assert(pda.AcceptanceCondition.IsFinalState(), "the pda has not final state as acceptance condition");
var pdaWithEmptyStack = PDATransformer <A, char> .ToPDAWithEmptyStack(pda);
var path = RunSimulationWithCFGForEmptyStack(pdaWithEmptyStack, word, token);
return(ConvertEmptyStackSimulationPathBackToFinalState(path, pda));
}
public void TestDPDARunnerForEmptyLanguage()
{
var dpda = new PDA <char, char>(new AcceptanceCondition.EmptyStack(), true, 'Z', false, "Z");
dpda.AddTransition().From(0).To(0).Read().Pop('Z').Push("Z");
dpda.CreateRunner();
Assert.IsFalse(dpda.AcceptsWord("").Accepts());
}
public static bool IsWordAccepted(PDA <A, S> pda, A[] word)
{
if (pda.AcceptanceCondition.IsEmptyStack() && pda.AcceptanceCondition.IsFinalState())
{
var acceptedByFinalState = IsWordAccepted(pda, word, new AcceptanceCondition.FinalState());
var acceptedByEmptyStack = IsWordAccepted(pda, word, new AcceptanceCondition.EmptyStack());
Assertion.Assert(acceptedByFinalState == acceptedByEmptyStack, () => new InconsistentPDAException(String.Format("the acceptance conditions of the pda are final-state and empty-stack, but the acceptance of \"{0}\" is inconsistent: for final-state is {1}, for empty stack is {2}", word, acceptedByFinalState, acceptedByEmptyStack)));
return(acceptedByFinalState);
}
return(IsWordAccepted(pda, word, pda.AcceptanceCondition));
}
public void TestOwnRunner()
{
var pda = new PDA <char, char>(new AcceptanceCondition.EmptyStack(), false, 'Z', false, "Z");
pda.AddTransition().From(0).To(0).Read('a').Pop('Z').Push("Z");
pda.AddTransition().From(0).To(0).Read().Pop('Z').Push("Z");
var res = PDARunner <char, char> .IsWordAccepted(pda, "a".ToCharArray());
Assert.IsFalse(res);
}
private static void AddProductionsFromTransitions(PDA <A, S> pda, Dictionary <string, Nonterminal> nonTerminals, Dictionary <A, Exprinal <A> > terminals, List <Production> productions, CancellationToken token)
{
foreach (var state in pda.States)
{
foreach (var transition in state.Value.Transitions)
{
token.ThrowIfCancellationRequested();
AddProductionsOfTransition(state.Value, transition, pda, nonTerminals, terminals, productions, token);
}
}
}
private static List <Production> GetInitialProductions(PDA <A, S> pda, Dictionary <string, Nonterminal> nonTerminals, Nonterminal start, CancellationToken token)
{
var productions = new List <Production>();
foreach (var state in pda.States)
{
token.ThrowIfCancellationRequested();
productions.Add(new Production(start, GetNonTerminal(nonTerminals, pda.InitialState, pda.FirstStackSymbol, state.Value)));
}
return(productions);
}
