public void ExtractOperandFromInvalidInput()
{
string input = "kekew";
InputToken tok = new InputToken(input, InputTokenType.Operand);
Assert.ThrowsException <ArgumentException>(() => InputUtils.CreateOperandFromInputToken(tok));
}
public PS4AndroidProfile()
{
this.RegisterAxis(XboxInputId.LStickX, SPInputId.Axis1);
this.RegisterAxis(XboxInputId.LStickY, SPInputId.Axis2, true);
this.RegisterAxis(XboxInputId.RStickX, SPInputId.Axis14);
this.RegisterAxis(XboxInputId.RStickY, SPInputId.Axis15, true);
this.RegisterAxis(XboxInputId.DPadX, SPInputId.Axis5);
this.RegisterAxis(XboxInputId.DPadY, SPInputId.Axis6, true);
this.RegisterTrigger(XboxInputId.LTrigger, InputToken.CreateLongTrigger(SPInputId.Axis3));
this.RegisterTrigger(XboxInputId.RTrigger, InputToken.CreateLongTrigger(SPInputId.Axis4));
this.RegisterButton(XboxInputId.A, SPInputId.Button1); //X
this.RegisterButton(XboxInputId.B, SPInputId.Button13); //O
this.RegisterButton(XboxInputId.X, SPInputId.Button0); //Sqr
this.RegisterButton(XboxInputId.Y, SPInputId.Button2); //Tri
this.RegisterButton(XboxInputId.LB, SPInputId.Button3); //L1
this.RegisterButton(XboxInputId.RB, SPInputId.Button14); //R1
this.RegisterButton(XboxInputId.Back, SPInputId.Button7); //Share
this.RegisterButton(XboxInputId.Start, SPInputId.Button6); //Options
this.RegisterButton(XboxInputId.LStickPress, SPInputId.Button11);
this.RegisterButton(XboxInputId.RStickPress, SPInputId.Button10);
this.RegisterAxleButton(XboxInputId.DPadRight, SPInputId.Axis5, AxleValueConsideration.Positive);
this.RegisterAxleButton(XboxInputId.DPadLeft, SPInputId.Axis5, AxleValueConsideration.Negative);
this.RegisterAxleButton(XboxInputId.DPadUp, SPInputId.Axis6, AxleValueConsideration.Negative);
this.RegisterAxleButton(XboxInputId.DPadDown, SPInputId.Axis6, AxleValueConsideration.Positive);
}
// Update is called once per frame
new protected void FixedUpdate()
{
if (InputToken == null)
{
base.FixedUpdate();
return;
}
if (Disabled)
{
base.FixedUpdate();
HMomentum *= .8f;
return;
}
InputSnapshot input = InputToken.GetSnapshot();
var data = SimulateFrame(input, cyoteTime);
cyoteTime = data.cyoteTime;
if (data.jumpConsumed)
{
InputToken.ConsumeJump();
}
foreach (var tech in GetComponents <IPlatformingTechnique>())
{
if (tech.Enabled)
{
data = tech.SimulateFrame(InputToken.GetSnapshot(), cyoteTime);
if (data.jumpConsumed)
{
InputToken.ConsumeJump();
}
cyoteTime = data.cyoteTime;
}
}
}
public PS4MacOSUSBProfile()
{
this.RegisterAxis(XboxInputId.LStickX, SPInputId.Axis1);
this.RegisterAxis(XboxInputId.LStickY, SPInputId.Axis2, true);
this.RegisterAxis(XboxInputId.RStickX, SPInputId.Axis3);
this.RegisterAxis(XboxInputId.RStickY, SPInputId.Axis4, true);
this.RegisterAxis(XboxInputId.DPadX, SPInputId.Axis7);
this.RegisterAxis(XboxInputId.DPadY, SPInputId.Axis8, true);
this.RegisterTrigger(XboxInputId.LTrigger, InputToken.CreateLongTrigger(SPInputId.Axis5));
this.RegisterTrigger(XboxInputId.RTrigger, InputToken.CreateLongTrigger(SPInputId.Axis6));
//this.RegisterAxis(XboxInputId.LTrigger, SPInputId.Button6, SPInputId.Unknown);
//this.RegisterAxis(XboxInputId.RTrigger, SPInputId.Button7, SPInputId.Unknown);
this.RegisterButton(XboxInputId.A, SPInputId.Button1); //X
this.RegisterButton(XboxInputId.B, SPInputId.Button2); //O
this.RegisterButton(XboxInputId.X, SPInputId.Button0); //Sqr
this.RegisterButton(XboxInputId.Y, SPInputId.Button3); //Tri
this.RegisterButton(XboxInputId.LB, SPInputId.Button4); //L1
this.RegisterButton(XboxInputId.RB, SPInputId.Button5); //R1
this.RegisterButton(XboxInputId.Back, SPInputId.Button8); //Share
this.RegisterButton(XboxInputId.Start, SPInputId.Button9); //Options
this.RegisterButton(XboxInputId.LStickPress, SPInputId.Button10);
this.RegisterButton(XboxInputId.RStickPress, SPInputId.Button11);
this.RegisterAxleButton(XboxInputId.DPadRight, SPInputId.Axis7, AxleValueConsideration.Positive);
this.RegisterAxleButton(XboxInputId.DPadLeft, SPInputId.Axis7, AxleValueConsideration.Negative);
this.RegisterAxleButton(XboxInputId.DPadUp, SPInputId.Axis8, AxleValueConsideration.Negative);
this.RegisterAxleButton(XboxInputId.DPadDown, SPInputId.Axis8, AxleValueConsideration.Positive);
}
public void ExtractOperandFromInputOnlyMinusSign()
{
string input = "-";
InputToken tok = new InputToken(input, InputTokenType.Operand);
Assert.ThrowsException <ArgumentException>(() => InputUtils.CreateOperandFromInputToken(tok));
}
/// <summary>
/// Diese Funktion erstellt aus einem InputToken einen Operator
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
public static Operator CreateOperatorFromInputToken(InputToken token)
{
//passiert nicht
if (token.Type == InputTokenType.Operand)
{
throw new ArgumentException("Expected Operator, got Operand");
}
//entsprechend dem inhalt des tokens muss der operator richtig bestimmt werden
//Precedence ist notwendig für Punkt-vor-Strich Rechnung
switch (token.Token)
{
case "*":
return(new Operator(OperatorType.Multiply, OperatorPrecedence.High));
case "/":
return(new Operator(OperatorType.Divide, OperatorPrecedence.High));
case "+":
return(new Operator(OperatorType.Add, OperatorPrecedence.Low));
case "-":
return(new Operator(OperatorType.Subtract, OperatorPrecedence.Low));
case "(":
return(new Operator(OperatorType.OpeningBracket, OperatorPrecedence.Ignore));
case ")":
return(new Operator(OperatorType.ClosingBracket, OperatorPrecedence.Ignore));
default:
throw new ArgumentException("Invalid Operator!");
}
}
public void ExtractOperandFromDoublePrefixInput()
{
string input = "h_b_FFFW";
InputToken tok = new InputToken(input, InputTokenType.Operand);
Assert.ThrowsException <ArgumentException>(() => InputUtils.CreateOperandFromInputToken(tok));
}
public void CreateOperandFromInputTest()
{
string input = "b_101010";
InputToken tok = new InputToken(input, InputTokenType.Operand);
Operand op = InputUtils.CreateOperandFromInputToken(tok);
Assert.AreEqual(42, op.DecimalValue);
}
public override void Apply(MobileLifetimeObject mlo, InputToken inputToken, Action <string> eventDelegate)
{
if (inputToken.JumpPressed && mlo.grounded)
{
Debug.Log("Jump");
mlo.mobile.VVelocity = JumpForce;
}
}
// Start is called before the first frame update
void Start()
{
InputToken = new InputToken();
foreach (var ir in GetComponents <IInputReader>())
{
ir.InputToken = InputToken;
}
}
private void Start()
{
Token = new InputToken();
foreach (var item in GetComponents <IControllable>())
{
item.InputToken = Token;
}
}
private void Start()
{
InputToken = new InputToken();
foreach (var controllable in GetComponents <IControllable>())
{
controllable.InputToken = InputToken;
}
}
public void ExtractOperandFromNegativeInputTest()
{
string input = "-h_AFFE";
InputToken tok = new InputToken(input, InputTokenType.Operand);
Operand op = InputUtils.CreateOperandFromInputToken(tok);
Assert.AreEqual(-45054, op.DecimalValue);
}
// Start is called before the first frame update
void Start()
{
InputToken = new InputToken();
var pc = GetComponent <PlatformingCharacter>();
if (pc)
{
pc.InputToken = InputToken;
}
}
void SaveSnapshot()
{
snapshothead++;
snapshothead %= 60;
history[snapshothead] = new PlatformingCharacterSnapshot()
{
input = InputToken.GetSnapshot(),
momentum = new Vector2(HMomentum, VMomentum),
cyoteTime = cyoteTime,
position = transform.position,
};
}
// Update is called once per frame
new void FixedUpdate()
{
if (Disable) // dirty hack, dont do it like this
{
HMomentum = 0f;
base.FixedUpdate();
return;
}
cyoteTime--;
if (Grounded)
{
if (Mathf.Abs(HMomentum) < 1f && InputToken.AbsHor == 0f)
{
HMomentum = 0f;
}
else
{
HMomentum = HMomentum * (1f - groundControl) + InputToken.Horizontal * speed * groundControl;
}
airJump = airJumps;
UpdateFacing();
cyoteTime = 5;
}
else
{
HMomentum = HMomentum * (1f - airControl) + InputToken.Horizontal * speed * airControl;
}
if (cyoteTime >= 0 && InputToken.Jump)
{
VMomentum = jumpForce;
InputToken.ClearJump();
OnJump?.Invoke();
}
else if (airJump > 0 && InputToken.Jump && (VMomentum <= 0f || VMomentum > 1f))
{
// the snippet works together with the input buffer to help you nail the air jump at the top of your arc
VMomentum = jumpForce * .8f;
InputToken.ClearJump();
OnJump?.Invoke();
HMomentum = InputToken.Horizontal * speed;
airJump--;
UpdateFacing();
}
base.FixedUpdate();
Gravity = InputToken.HoldJump && VMomentum > 0f ? 16f : 30f;
if (Grounded == false && VMomentum > 0f & !InputToken.HoldJump)
{
VMomentum *= .8f;
}
}
// Start is called before the first frame update
void Start()
{
PlayerInput = GetComponent <PlayerInput>();
PlatformingCharacter = GetComponent <PlatformingCharacter>();
OutputToken = new InputToken();
if (isLocalPlayer)
{
InputToken = PlayerInput.InputToken;
PlatformingCharacter.OnJump += () => jumped = true;
FindObjectOfType <CameraFollow>().Follow = new Mobile[] { PlatformingCharacter };
PlatformingCharacter.OnStomp += PlatformingCharacter_OnStomp;
}
else
{
PlatformingCharacter.InputToken = OutputToken;
PlayerInput.enabled = false;
interpolation.enabled = true;
}
}
// Start is called before the first frame update
void Start()
{
InputToken = new InputToken();
var pc = GetComponent <PlatformingCharacter>();
if (pc)
{
pc.InputToken = InputToken;
}
var rep = GetComponent <Repair>();
if (rep)
{
rep.InputToken = InputToken;
}
var mob = GetComponent <Mobile2D>();
if (mob)
{
mob.InputToken = InputToken;
}
}
IEnumerator DaLoop()
{
Controls = GetComponent <PlatformingCharacter>();
InputToken = new InputToken();
Controls.InputToken = InputToken;
int direction = Controls.Forward;
InputToken.Direction = new Vector2(direction, 0f);
yield return(new WaitForSeconds(.1f));
GetComponent <SpriteRenderer>().enabled = true;
Controls.enabled = true;
Controls.HMomentum = 0f;
Controls.VMomentum = 0f;
GetComponentsInChildren <Collider2D>().ForEach(c => c.enabled = true);
MoveForward:
for (; ;)
{
InputToken.Direction = new Vector2(direction, 0f);
if (Controls.TouchingWall && Controls.TouchingWallDirection == direction)
{
goto Turn;
}
if (turnAtLedges && Controls.Grounded && Controls.OnEdge)
{
goto Turn;
}
yield return(new WaitForFixedUpdate());
}
Turn:
direction = -direction;
InputToken.Direction = new Vector2(direction, 0f);
yield return(new WaitForSeconds(.1f));
goto MoveForward;
}
private static void ParseNode(ScriptProgram program, Node root, InputToken currentToken, TokenStream stream)
{
// Special Id handling
if (currentToken.TokenType == SemanticTokenType.Identifier)
{
// Skip the identifier and assume it will be correctly read later.
currentToken = stream.Pop();
}
if (currentToken.TokenValue == "say")
{
ParseNodeSay(root, stream);
}
else if (currentToken.TokenValue == "option")
{
ParseNodeOption(program, root, stream);
}
else if (currentToken.TokenValue == "call-page")
{
ParseNodeCallPage(root, stream);
}
else if (currentToken.TokenValue == "return")
{
root.AddChildNode(new ReturnNode());
}
else if (currentToken.TokenValue == "once-only")
{
ParseNodeOnceOnly(program, root, stream);
}
else if (currentToken.TokenValue == "case-true")
{
ParseNodeCaseTrue(program, root, stream);
}
else if (currentToken.TokenValue == "case-false")
{
ParseCaseFalseNode(program, root, stream);
}
else if (currentToken.TokenValue == "show-options")
{
ParseShowOptions(program, root, stream);
}
else if (currentToken.TokenValue == "wait")
{
ParseWait(root, stream);
}
else if (currentToken.TokenValue == "print")
{
ParseNodePrint(root, stream);
}
else if (currentToken.TokenValue == "parallel")
{
ParseNodeParallel(program, root, stream);
}
else if (currentToken.TokenValue == "block")
{
ParseNodeBlock(program, root, stream);
}
else if (currentToken.TokenValue == "set-var")
{
ParseNodeSetVariable(program, root, stream);
}
else if (currentToken.TokenValue == "if")
{
ParseNodeIf(program, root, stream);
}
else
{
throw new NotImplementedException("Cannot parse Unknown Node:" + currentToken.TokenValue);
}
}
public TokenStreamSet AssignIdentifiers(TokenStreamSet tokenStreamSet)
{
var existingIdentifiers = new HashSet <uint>();
foreach (var tokenStream in tokenStreamSet.TokenStreams)
{
foreach (var token in tokenStream.ToList())
{
if (token.TokenType == SemanticTokenType.Identifier)
{
var substring = token.TokenValue.Substring(1, 8);
var value = UInt32.Parse(substring, System.Globalization.NumberStyles.HexNumber);
if (existingIdentifiers.Contains(value))
{
throw new Exception("Duplicate identifier found in scripts!");
}
else
{
existingIdentifiers.Add(value);
}
}
}
}
var r = new Random();
// Assume we got here, let's check if we need to add new identifiers
var previousToken = new InputToken();
var previousPreviousToken = new InputToken();
// Lets copy
var newTokenStreamSet = new TokenStreamSet();
foreach (var tokenStream in tokenStreamSet.TokenStreams)
{
var newTokenStream = new List <InputToken>();
var tokenList = tokenStream.ToList();
for (int i = 0; i < tokenList.Count; i++)
{
var token = tokenList[i];
bool shouldGenerateId = false;
if (token.IdPolicy == IdPolicy.IdPreceedsCurrentToken)
{
{
if (previousToken.TokenType == SemanticTokenType.Identifier)
{
// No need
}
else
{
shouldGenerateId = true;
}
}
}
if (token.IdPolicy == IdPolicy.IdPostCurrentToken)
{
if (i + 1 < tokenList.Count)
{
var nextToken = tokenList[i + 1];
if (nextToken.TokenType == SemanticTokenType.Identifier)
{
// No need
}
else
{
shouldGenerateId = true;
}
}
else
{
throw new Exception("Unexpected end of tokenstream");
}
}
// Add current token
if (shouldGenerateId)
{
// Generate id
uint partA = (uint)r.Next(1 << 16);
uint PartB = (uint)r.Next(1 << 16);
uint newId = (partA << 16) | PartB;
// Try again if id already exists
// Note: This would infinite loop if the hashset is full, but that's a lot of identifiers!
int tryCount = 0;
const int MaxRetries = 12;
while (existingIdentifiers.Contains(newId))
{
partA = (uint)r.Next(1 << 16);
PartB = (uint)r.Next(1 << 16);
newId = (partA << 16) | PartB;
tryCount++;
if (tryCount > MaxRetries)
{
throw new Exception("Cannot Generated Valid Identifier: Exceeded max number of retries");
}
}
var generatedToken = new InputToken(new Regex("\\[[0-9A-Fa-f]{8}\\]"), IdPolicy.None, SemanticTokenType.Identifier, OperationType.Operand);
generatedToken.TokenValue = String.Format("[{0}]", newId.ToString("x8"));
// todo add whitespace?
if (token.IdPolicy == IdPolicy.IdPreceedsCurrentToken)
{
newTokenStream.Add(generatedToken);
newTokenStream.Add(token);
previousPreviousToken = generatedToken;
previousToken = token;
}
else if (token.IdPolicy == IdPolicy.IdPostCurrentToken)
{
newTokenStream.Add(token);
newTokenStream.Add(generatedToken);
previousPreviousToken = token;
previousToken = generatedToken;
}
else
{
throw new Exception("Unhanded Token IdPolicy");
}
}
else
{
newTokenStream.Add(token);
previousPreviousToken = previousToken;
previousToken = token;
}
}
newTokenStreamSet.TokenStreams.Add(new TokenStream(newTokenStream));
}
return(newTokenStreamSet);
}
public override void Apply(MobileLifetimeObject mlo, InputToken inputToken, System.Action <string> eventDelegate)
{
mlo.mobile.HVelocity = inputToken.Direction.x * speed;
}
// Update is called once per frame
void FixedUpdate()
{
if (InputToken.Use)
{
if (held)
{
var hits = Physics2D.BoxCastAll((Vector2)transform.position + Moveable.Direction.normalized, Vector2.one, 0f, Vector2.zero, 0f, CarryMask);
if (hits.Length > 0)
{
var hit = hits[0];
Vector2 controlPoint = (Vector2)transform.position + Moveable.Direction.normalized * .5f;
float distance = ((Vector2)hit.transform.position - controlPoint).sqrMagnitude;
for (int i = 1; i < hits.Length; i++)
{
float d2 = ((Vector2)hits[i].transform.position - controlPoint).sqrMagnitude;
if (d2 < distance)
{
hit = hits[i];
distance = d2;
}
}
var Counter = hit.transform.GetComponent <Counter>();
if (Counter)
{
if (Counter.IsEmpty)
{
Counter.Place(held);
held = null;
DropSound.Play();
}
else // swap
{
var tmp = Counter.Grab();
Counter.Place(held);
PickUp(tmp);
}
InputToken.ConsumeUse();
return;
}
}
Drop();
InputToken.ConsumeUse();
}
else
{
var hit = Physics2D.BoxCast((Vector2)transform.position + Moveable.Direction.normalized, Vector2.one, 0f, Vector2.zero, 0f, CarryMask);
if (hit)
{
var carry = hit.transform.GetComponent <Food>();
if (carry)
{
PickUp(carry);
InputToken.ConsumeUse();
return;
}
var crate = hit.transform.GetComponent <Crate>();
if (crate)
{
var food = Instantiate(crate.GetFood());
PickUp(food);
InputToken.ConsumeUse();
return;
}
var counter = hit.transform.GetComponent <Counter>();
if (counter && !counter.IsEmpty)
{
var food = counter.Grab();
PickUp(food);
InputToken.ConsumeUse();
return;
}
}
}
}
}
/// <summary>
/// Diese Funktion nimmt den vom User eingegebenen Term, welcher vorher zu einem Array von InputToken zerlegt wurde und berechnet
/// diesen unter beachtung von Klammersetzung und Punkt-vor-Strich-Rechnung
/// </summary>
/// <param name="tokens">Array mit der Usereingabe die zu InputToken zerlegt wurde.</param>
/// <returns></returns>
public static Operand CalculateTerm(InputToken[] tokens)
{
//die Stacks halten operanden und operatoren für die auswertung des Terms
Stack <Operand> operandStack = new Stack <Operand>();
Stack <Operator> operatorStack = new Stack <Operator>();
//iteriere über den term
for (int i = 0; i < tokens.Length; i++)
{
InputToken currentToken = tokens[i];
switch (currentToken.Type)
{
//wenn der token ein operand ist, konvertiere ihn zu einem Operand und pushe ihn auf den Operanden Stack
case InputTokenType.Operand:
operandStack.Push(InputUtils.CreateOperandFromInputToken(currentToken));
break;
//wenn der token ein operator ist, konvertiere den InputToken zu einem Operator
case InputTokenType.Operator:
Operator op = InputUtils.CreateOperatorFromInputToken(currentToken);
//überprüfe ob der Operator eine schließende Klammer ist
if (op.Type == OperatorType.ClosingBracket)
{
//schließende klammer zeigt an, dass ein subterm vorher von einer öffnenden Klammer eingeleitet wurde
//berechne nun den subterm, da die Klammerrechnung Vorrang hat.
CalculationUtils.CalculateInsideBrackets(operandStack, operatorStack);
}
else
{
//Bei allen anderen Operatoren schau dir an was auf dem Operator Stack oben drauf liegt
Operator top;
if (operatorStack.TryPeek(out top))
{
//Ignoriere Klammern, diese haben als OperatorPrecedence den wert Ignore
if (op.Precedence != OperatorPrecedence.Ignore && top.Precedence != OperatorPrecedence.Ignore)
{
// Vergleiche den aktuellen operator und den auf dem stack
// hat der Operator auf dem stack Vorrang? * und / haben Vorrang vor + und -
if (top.Precedence > op.Precedence)
{
CalculationUtils.PopCalculateAndPushOperand(operandStack, operatorStack);
}
}
}
operatorStack.Push(op);
}
break;
}
}
// alle terme in klammern sind evaluiert, Operatoren und Operanden sind in der richtigen Reihenfolge auf dem Stack
// Evaluiere nun die Stacks
while (operatorStack.Count > 0)
{
// falls wir noch eine öffnende Klammer auf dem Stack haben, bedeutet dies das es keine schließende klammer in der eingabe gab
// somit ist dies ein Syntax Fehler
if (operatorStack.Peek().Type == OperatorType.OpeningBracket)
{
throw new ArgumentException("Syntax Fehler: Schließende Klammer fehlt.");
}
//rufe die auswertungsfunktion auf
CalculationUtils.PopCalculateAndPushOperand(operandStack, operatorStack);
}
//nach dem evaluieren der stacks befindet sich nur noch ein operand auf dem Operanden Stack
//dieser entspricht dem Ergebnis des Terms
//gib dieses zurück
return(operandStack.Pop());
}
public override void Apply(MobileLifetimeObject mlo, InputToken inputToken, System.Action <string> eventDelegate)
{
mlo.gravityMultipler *= multiplier;
}
abstract public void Apply(MobileLifetimeObject mlo, InputToken inputToken, System.Action <string> eventDelegate);
public void RegisterButton(XboxInputId button, SPInputId spbtn)
{
_buttonTable[button] = InputToken.CreateButton(spbtn);
_axisTable.Remove(button);
}
public void RegisterAxleButton(XboxInputId button, SPInputId axis, AxleValueConsideration consideration, float axleButtonDeadZone = InputUtil.DEFAULT_AXLEBTNDEADZONE)
{
_buttonTable[button] = InputToken.CreateAxleButton(axis, consideration, axleButtonDeadZone);
_axisTable.Remove(button);
}
public void RegisterTrigger(XboxInputId trigger, SPInputId axis, AxleValueConsideration consideration = AxleValueConsideration.Positive)
{
_axisTable[trigger] = InputToken.CreateTrigger(axis, consideration);
_buttonTable.Remove(trigger);
}
public void RegisterTrigger(XboxInputId trigger, InputToken token)
{
_axisTable[trigger] = token;
_buttonTable.Remove(trigger);
}
