public override void Execute(IList <Token> tokens, ref int i)
{
if (tokens[i].TokenType == TokenType.Identifier)
{
}
StateStack.Push(new ConstructionBodyState(StateStack, DefinedTypes, AsmBuilder, TypeBuilder, Method));
}
static void Main(string[] args)
{
Terminal.Open();
Terminal.Set(string.Format("window.title='{0}'", "SharpSnake"));
Terminal.Refresh();
var consoleScreen = new ConsoleScreen(36, 28);
var context = new StateContext(consoleScreen, new Settings());
var stateStack = new StateStack(context);
stateStack.RegisterState <MenuState>(StateId.Menu);
stateStack.RegisterState <OptionsState>(StateId.Options);
stateStack.RegisterState <PlayState>(StateId.Play);
stateStack.RegisterState <GameOverState>(StateId.GameOver);
stateStack.RegisterState <PauseState>(StateId.Pause);
// Initial state
stateStack.PushState(StateId.Menu);
while (!stateStack.Empty)
{
stateStack.HandleInput();
stateStack.Update();
consoleScreen.Clear();
stateStack.Draw();
consoleScreen.Display();
System.Threading.Thread.Sleep(16);
}
Terminal.Close();
}
public ParsingObject ToStack(State newState, bool important = true)
{
logger.Debug($"Push {newState.ToString()}");
if (important)
{
CurrentToken += '{' + TokenParameters.Count.ToString() + '}';
}
StateStack.Push(this);
var newObject = new ParsingObject
{
State = newState,
Index = Index,
CurrentHtmlObject = new HtmlObject
{
Attributes = new List <DataAtrModel>(),
Children = new List <HtmlObject>(),
Parent = CurrentHtmlObject,
Tag = string.Empty
},
CurrentToken = string.Empty,
ParenthStack = new Stack <char>(),
RawHtml = RawHtml,
StateStack = StateStack,
TokenParameters = new List <ParsingObject>()
};
newObject._startIndex = Index;
newObject._important = important;
return(newObject);
}
/// <summary>
/// Find error recovery state.
/// </summary>
/// <returns>result.</returns>
private bool FindErrorRecoveryState()
{
while (true) // pop states until one found that accepts error token
{
if (FsaState.ParserTable != null &&
FsaState.ParserTable.ContainsKey(errorToken) &&
FsaState.ParserTable[errorToken] > 0) // shift
{
return(true);
}
StateStack.Pop();
ValueStack.Pop();
LocationStack.Pop();
if (StateStack.IsEmpty())
{
return(false);
}
else
{
FsaState = StateStack.TopElement();
}
}
}
public override void Execute(IList <Token> tokens, ref int i)
{
if (tokens[i].TokenType == TokenType.Modifier)
{
modifs.Add(tokens[i].Value);
i++;
}
else if (tokens[i].Value == "func")
{
i++;
StateStack.Push(new MethodState(StateStack, DefinedTypes, AsmBuilder, TypeBuilder, modifs.ToArray()));
modifs.Clear();
}
else if (tokens[i].TokenType == TokenType.Type)
{
StateStack.Push(new FieldState(StateStack, DefinedTypes, AsmBuilder, TypeBuilder, modifs.ToArray()));
modifs.Clear();
}
else if (tokens[i].TokenType == TokenType.End)
{
i++;
StateStack.Pop();
StateStack.Pop();
((TypeBuilder)TypeBuilder).CreateType();
}
else
{
ExceptionManager.ThrowCompiler(ErrorCode.UnexpectedToken, "", tokens[i].Line);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CollapsingStateStack{T}"/> class.
/// </summary>
/// <param name="capacity">The initial capacity of the stack. This is the expected maximum stack depth.
/// If the stack depth grows bigger, the stack automatically doubles its capacity internally.</param>
public CollapsingStateStack(int capacity = _defaultCapacity)
{
// The _impStack keeps the actual top-of-stack values.
_impStack = new StateStack <T>(capacity);
// The _countStack keeps the number of "Push" operations that occurred between two Tos alterations
_countStack = new StateStack <int>(capacity);
}
public MainScreen()
{
InitializeComponent();
this.DoubleBuffered = true;
this.SetStyle(ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer, true);
Dictionary <string, IState> states = new Dictionary <string, IState>()
{
{ "MainMenu", new MainMenuState() },
{ "Logo", new LogoState() }
};
_GameStack = new StateStack(this, ClientSize.Width, ClientSize.Height, states);
_GameStack.Push("MainMenu");
_GameStack.Push("Logo");
_GameTimer = new Timer();
_GameTimer.Interval = 10;
_GameTimer.Tick += new EventHandler(_GameStack.Update);
_GameTimer.Start();
ResizeEnd += new EventHandler(_GameStack.Buffer);
Load += new EventHandler(_GameStack.Buffer);
KeyDown += new KeyEventHandler(_GameStack.Input);
Paint += new PaintEventHandler(_GameStack.Render);
}
/// <summary>
/// Pop the current versioning state, returning the state to the one before it was pushed
/// </summary>
public void PopState()
{
var state = StateStack.Pop();
this.Mode = state.Mode;
this.SpecificVersion = state.SpecificVersion;
}
public override void InitState(EntityStats receiver, EntityStats applier = null)
{
StateStack ss = receiver.GetStack(this);
if (ss == null)
{
ss = new StateStack(this, stunDuration, 1);
receiver.states.Add(ss);
}
else
{
ss.ResetTimer();
}
/* receiver.canMove = false;
* SkillUser su = receiver.GetComponent<SkillUser>();
* if(su){
* su.canCastSkills = false;
* } */
SkillUser su = receiver.GetComponent <SkillUser>();
if (su)
{
su.canCastSkills = false;
}
receiver.stunned = true;
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="createModel">Creates model that should be checked.</param>
/// <param name="output">The callback that should be used to output messages.</param>
/// <param name="configuration">The analysis configuration that should be used.</param>
internal InvariantChecker(Func <RuntimeModel> createModel, Action <string> output, AnalysisConfiguration configuration)
{
Requires.NotNull(createModel, nameof(createModel));
Requires.NotNull(output, nameof(output));
_progressOnly = configuration.ProgressReportsOnly;
_output = output;
_workers = new Worker[configuration.CpuCount];
var tasks = new Task[configuration.CpuCount];
var stacks = new StateStack[configuration.CpuCount];
_loadBalancer = new LoadBalancer(stacks);
for (var i = 0; i < configuration.CpuCount; ++i)
{
var index = i;
tasks[i] = Task.Factory.StartNew(() =>
{
stacks[index] = new StateStack(configuration.StackCapacity);
_workers[index] = new Worker(index, this, stacks[index], createModel, configuration.SuccessorCapacity);
});
}
Task.WaitAll(tasks);
_states = new StateStorage(_workers[0].StateVectorLayout, configuration.StateCapacity);
#if false
Console.WriteLine(_workers[0].StateVectorLayout);
#endif
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="createModel">Creates the model that should be checked.</param>
/// <param name="output">The callback that should be used to output messages.</param>
/// <param name="configuration">The analysis configuration that should be used.</param>
internal ModelTraverser(Func<AnalysisModel> createModel, Action<string> output, AnalysisConfiguration configuration)
{
Requires.NotNull(createModel, nameof(createModel));
Requires.NotNull(output, nameof(output));
TransitionCollection.ValidateTransitionSizes();
var tasks = new Task[configuration.CpuCount];
var stacks = new StateStack[configuration.CpuCount];
_loadBalancer = new LoadBalancer(stacks);
Context = new TraversalContext(_loadBalancer, configuration, output);
_workers = new Worker[configuration.CpuCount];
for (var i = 0; i < configuration.CpuCount; ++i)
{
var index = i;
tasks[i] = Task.Factory.StartNew(() =>
{
stacks[index] = new StateStack(configuration.StackCapacity);
_workers[index] = new Worker(index, Context, stacks[index], createModel());
});
}
Task.WaitAll(tasks);
_states = new StateStorage(_workers[0].Model.StateVectorSize, configuration.StateCapacity);
Context.States = _states;
}
public void OnObjectStart(string name)
{
var state = new KVPartialState();
state.Key = name;
StateStack.Push(state);
}
/// <summary>
/// Run logic for this state - including input
/// </summary>
/// <param name="GameTime">Snapshot of timing</param>
public override void Update(GameTime GameTime)
{
// Get the current state, get the last state, and any new buttons are acted upon
var currentState = Keyboard.GetState();
foreach (var i in currentState.GetPressedKeys())
{
if (LastState.IsKeyUp(i))
{
StateStack.Clear();
}
}
// Get touch state
var touchState = TouchPanel.GetState();
foreach (var touch in touchState)
{
if (touch.State == TouchLocationState.Pressed)
{
StateStack.Clear();
}
}
LastState = currentState;
}
public override void InitState(EntityStats receiver, EntityStats applier = null)
{
if (amount <= 0 || amount > maxAmount)
{
return;
}
StateStack ss = new StateStack(this, -1, -1, 1, applier);
receiver.states.Add(ss);
addedMod = new StatModifier(values[amount - 1], targetModType, this);
if (targetType == StatType.STRENGTH)
{
receiver.strength.AddModifier(addedMod);
}
if (targetType == StatType.MIND)
{
receiver.mind.AddModifier(addedMod);
}
if (targetType == StatType.CONSTITUTION)
{
receiver.constitution.AddModifier(addedMod);
}
if (targetType == StatType.SPIRIT)
{
receiver.spirit.AddModifier(addedMod);
}
}
/// <summary>
/// Run logic for this state - including input
/// </summary>
/// <param name="GameTime">Snapshot of timing</param>
public override void Update(GameTime GameTime)
{
// Get the current state, get the last state, and any new buttons are acted upon
var currentState = Keyboard.GetState();
foreach (var i in currentState.GetPressedKeys())
{
if (LastState.IsKeyUp(i))
{
KeyPressed(i);
}
}
LastState = currentState;
// Do turn, if player next move is set
if (G.Player.NextMove != Player.Instruction.NOT_SET)
{
G.DoTurn();
}
if (G.GameOver)
{
StateStack.Add(new AtlasWarriors.LoseState(G));
}
}
/// <summary>
/// Shift.
/// </summary>
/// <param name="stateIndex">state index.</param>
private void Shift(int stateIndex)
{
FsaState = states[stateIndex];
ValueStack.Push(Scanner.yylval);
StateStack.Push(FsaState);
LocationStack.Push(Scanner.yylloc);
if (recovering)
{
if (NextToken != errorToken)
{
tokensSinceLastError++;
}
if (tokensSinceLastError > 5)
{
recovering = false;
}
}
if (NextToken != endOfFileToken)
{
NextToken = 0;
}
}
public void OnAfterDeserialize()
{
for (int i = StateList.Count; i >= 0; i--)
{
StateStack.Push(StateList[i]);
}
}
/// <summary>
/// Resume state is used for when we want to go back to a state we previously suspended.
/// </summary>
public void ResumeState()
{
if (StateStack.Count != 0)
{
CurrentState.Exit();
CurrentState = StateStack.Pop();
}
}
public void OnObjectStart(string name)
{
var state = new KvPartialState {
Key = name
};
StateStack.Push(state);
}
public void RemoveHeadState()
{
if (StateStack.Count < 1)
{
throw new Exception("There are no more states to remove");
}
StateStack.RemoveAt(0);
}
protected override void FinalizeState()
{
base.FinalizeState();
var stateEntry = StateStack.Peek();
var originalStateEntry = originalBuilder.StateStack.Peek();
Merge(from: stateEntry, into: originalStateEntry);
}
protected void RemoveInstanceCore <TInstance>(string extName)
{
var cell = StateStack.FirstOrDefault(p => p.InstanceType == typeof(TInstance) && p.ExtName == extName);
if (cell != null)
{
StateStack.Remove(cell);
}
}
public void ClearStates()
{
while (StateStack.Count != 0)
{
CurrentState.Exit();
CurrentState = StateStack.Pop();
}
CurrentState.Exit();
}
// Use this for initialization
void Start()
{
stateStack = GetComponent <StateStack>();
//Add all possible states here
stateStack.Add("Game", new GameState());
//Push the first thingy on
stateStack.Push("Game");
}
public void PushState()
{
StateStack.Add(
new StreamState
{
Position = Position,
Mode = Mode
}
);
}
//TODO activate the current state when the stack is empty
public void PopState()
{
if (StateStack.Count == 0)
{
throw new Exception("The state stack is empty. Cannot pop.");
}
StateStack.Peek().OnExit();
StateStack.Peek().gameObject.SetActive(false);
StateStack.Pop();
}
/// <summary>
/// Push something onto the state Stack of the bot, this calls the Stop() of current State
/// and the Start() of new State.
/// </summary>
/// <param name="botState">the state you want to change to</param>
public void PushAction(BotState botState, [CallerMemberName] string functionName = "")
{
if (GetCurrentState() != botState)
{
AmeisenLogger.Instance.Log(LogLevel.VERBOSE, $"FSM Push [{botState}] called by: {functionName}", this);
GetCurrentStateAction(GetCurrentState())?.StartExit.Invoke();
StateStack.Push(botState);
GetCurrentStateAction(GetCurrentState())?.StartAction.Invoke();
}
}
/// <summary>
/// Push a versioning state with a VersioningMode and a specific ItemVersion (making it active)
/// </summary>
/// <param name="mode">The VersioningMode to push</param>
/// <param name="specificVersion">The SpecificVersion to push</param>
public void PushState(VersioningMode mode, ItemVersion specificVersion)
{
StateStack.Push(new VersioningState {
Mode = this.Mode, SpecificVersion = this.SpecificVersion
});
this.Mode = mode;
if (specificVersion != null)
{
this.SpecificVersion = specificVersion;
}
}
public ParsingObject PopAttributeValue()
{
logger.Debug($"PopAttributeValue {State}");
var attribute = StateStack.Pop();
var element = attribute.StateStack.Pop();
element.currentAttr.ValueTemplate = CurrentToken;
attribute.Index = Index;
attribute.StateStack.Push(element);
return(attribute);
}
protected override void FinalizeState()
{
base.FinalizeState();
var stateEntry = StateStack.Peek();
var originalStateEntry = originalBuilder.StateStack.Peek();
foreach (var item in stateEntry.Items)
{
originalStateEntry.Items.Add(item);
}
}
/// <summary>
/// Pop the state Stack of the bot, calls the Start() of new State and the Stop() of current State.
/// </summary>
/// <param name="botState">the state you want to change to</param>
public BotState PopAction(BotState botState, [CallerMemberName] string functionName = "")
{
if (GetCurrentState() == botState)
{
AmeisenLogger.Instance.Log(LogLevel.VERBOSE, $"FSM Pop called by: {functionName}", this);
GetCurrentStateAction(GetCurrentState())?.StartExit.Invoke();
BotState tmpState = StateStack.Pop();
GetCurrentStateAction(GetCurrentState())?.StartAction.Invoke();
return(tmpState);
}
return(GetCurrentState());
}
