/// <summary>
/// Invoked om behalf of PHY whenever a frame has been transmitted.
/// </summary>
void OnDataTransmitted()
{
WriteMac("Finished transmitting Ethernet frame.");
// The idle period between two consecutive frames must at least be 96
// bittimes long as per IEEE 802.3 specification.
emptyingFifo = sendFifo.Count != 0;
// If the FIFO's not empty yet, issue another transmission. Otherwise
// let the upper layer know we're ready for more data.
if (sendFifo.Count > 0)
{
Simulation.Callback(interframeGapTime, EmptySendFifo);
}
else
{
Simulation.Callback(interframeGapTime, () => {
InterruptReason = Lan.Interrupt.SendFifoEmpty;
Interrupt.RaiseEvent(this, null);
});
}
}
static Modes()
{
// Initialize the menu
ComboMenu = Menu.AddSubMenu("Combo");
Combo.Initialize();
HarassMenu = Menu.AddSubMenu("Harass");
Harass.Initialize();
LCMenu = Menu.AddSubMenu("LC");
LC.Initialize();
MiscMenu = Menu.AddSubMenu("Misc");
PermaActive.Initialize();
InsecMenu = Menu.AddSubMenu("GenSec™");
Insec.Initialize();
InterruptMenu = Menu.AddSubMenu("Interrupt");
Interrupt.Initialize();
// Initialize all modes
// Combo
Menu.AddSeparator();
// Harass
}
static Modes()
{
// Initialize the menu
ComboMenu = Menu.AddSubMenu("Combo");
Combo.Initialize();
InterruptMenu = Menu.AddSubMenu("Interrupt");
Interrupt.Initialize();
ShieldMenu = Menu.AddSubMenu("Shield");
ShieldManager.Initialize();
HarassMenu = Menu.AddSubMenu("Harass");
Harass.Initialize();
LCMenu = Menu.AddSubMenu("LastHit");
LC.Initialize();
MiscMenu = Menu.AddSubMenu("Misc");
PermaActive.Initialize();
// Initialize all modes
// Combo
Menu.AddSeparator();
// Harass
}
static void Evaluate(WyrazeniePrzerwaniaASTNode node)
{
Interrupt.InterruptHandler(procesor, node.Przerwanie.Token.TokenValue, ex, nr);
}
public Interrupt_v1_Interface(Interrupt interrupt)
{
inter = interrupt ?? throw new ArgumentNullException(nameof(interrupt));
}
public void OnInterrupt(Interrupt interrupt)
{
gameManager.viewModel.MainWindowDispatcher.Invoke(
() => MessageBox.Show($"{managerNum + 1}P is disconnected."));
}
private uint IMASK; //IE Global Interrupt enable
internal void set(Interrupt interrupt)
{
ISTAT |= (uint)interrupt;
//Console.WriteLine($"ISTAT SET MANUAL FROM DEVICE: {ISTAT:x8} IMASK {IMASK:x8}");
}
private uint IMASK; //IE Global Interrupt enable
internal void set(Interrupt interrupt)
{
ISTAT |= (uint)interrupt;
//Console.WriteLine("ISTAT SET MANUAL FROM DEVICE: " + ISTAT.ToString("x8") + " IMASK " + IMASK.ToString("x8"));
}
public void ParallelFilterNodeTest()
{
var root = new Interrupt(s => ((State)s).C);
var stages = new Queue <string>();
var manager = new BehaviourTree(root);
var conditionalA = new TestYieldConditionNode {
PrintA = "AYield", PrintB = "A", Stages = stages, Conditional = s => s.A
};
var conditionalB = new TestYieldConditionNode {
PrintA = "BYield", PrintB = "B", Stages = stages, Conditional = s => s.B
};
root.Children = new List <Node> {
conditionalA, conditionalB
};
foreach (var n in root.DepthFirstIterate())
{
n.Initialize();
}
Assert.AreEqual(0UL, manager.TickCount);
// x x true => true
stages.Enqueue("TICK");
manager.Update(new State {
A = true, B = false, C = true
});
Assert.AreEqual(Result.Unknown, manager.Result);
Assert.AreEqual(0UL, manager.TickCount);
var sequence = new List <string> {
"TICK", "AYield", "BYield"
};
Assert.IsTrue(stages.SequenceEqual(sequence));
stages.Enqueue("TICK");
manager.Update(new State {
A = true, B = false, C = true
});
Assert.AreEqual(Result.Success, manager.Result);
Assert.AreEqual(1UL, manager.TickCount);
sequence.AddRange(new[] { "TICK", "A", "B" });
Assert.IsTrue(stages.SequenceEqual(sequence));
// x x false => false
stages.Enqueue("TICK");
manager.Update(new State {
A = false, B = true, C = false
});
Assert.AreEqual(Result.Failure, manager.Result);
Assert.AreEqual(2UL, manager.TickCount);
sequence.AddRange(new[] { "TICK" });
Assert.IsTrue(stages.SequenceEqual(sequence));
// x x delayed false => false
stages.Enqueue("TICK");
manager.Update(new State {
A = false, B = true, C = true
});
Assert.AreEqual(Result.Unknown, manager.Result);
Assert.AreEqual(2UL, manager.TickCount);
sequence.AddRange(new[] { "TICK", "AYield", "BYield" });
Assert.IsTrue(stages.SequenceEqual(sequence));
stages.Enqueue("TICK");
manager.Update(new State {
A = false, B = true, C = false
});
Assert.AreEqual(Result.Failure, manager.Result);
Assert.AreEqual(3UL, manager.TickCount);
sequence.AddRange(new[] { "TICK" });
Assert.IsTrue(stages.SequenceEqual(sequence));
}
public void InterruptHandled(Interrupt interrupt) { InterruptHandled((byte)interrupt); }
public void InterruptRequest(Interrupt interrupt)
{
InterruptRequest((byte)interrupt);
}
public bool IsInQueue(Interrupt interrupt)
{
return(interruptQueue.Contains(interrupt));
}
public void InterruptHandled(Interrupt interrupt)
{
InterruptHandled((byte)interrupt);
}
public void InterruptRequest(Interrupt interrupt)
{
InterruptRequest((byte)interrupt);
}
public void OnInterrupt(Interrupt interrupt)
{
gameManager.viewModel.MainWindowDispatcher.Invoke(__onInterrupt);
}
/// <summary>
/// 向运行时环境发出中断
/// </summary>
/// <param name="vsm">要提交的调用堆栈</param>
/// <param name="ntr">中断</param>
public void SubmitInterrupt(StackMachine vsm, Interrupt ntr)
{
vsm.Submit(ntr);
}
/// <summary>
/// Initialises the virtual machine's internal structures.
/// </summary>
private void Initialise()
{
if (DebugMode) DebugWriter.WriteLine("Initialising machine...");
Registers = new short[NumRegs];
ProgramCounter = 0x0;
InterruptTable = new Interrupt[32];
_currentInstruction = new Instruction();
}
public void QueueInterrupt(Interrupt interrupt) => mInterruptQueue.Enqueue(interrupt);
/// <summary> </summary>
/// <param name="timeToFill"></param>
/// <param name="interrupt"></param>
/// <param name="decayRate"></param>
public FillBar(float timeToFill, Interrupt interrupt, float decayRate = float.NaN)
{
Max = timeToFill * 60.0f;
}
public void Trigger(Interrupt priority, ExceptionCause cause)
{
switch (priority)
{
case Interrupt.SynchronizeSignal:
case Interrupt.MemoryFault:
case Interrupt.Timer0:
case Interrupt.Timer1:
case Interrupt.Message:
case Interrupt.DirectAccess0:
case Interrupt.DirectAccess1:
case Interrupt.WiredAnd:
if (cause != ExceptionCause.None)
throw new ArgumentException(
"Exception cause not allowed for {0}.".Interpolate(priority),
"priority");
break;
case Interrupt.SoftwareException:
case Interrupt.User:
if (cause == ExceptionCause.None)
throw new ArgumentException(
"Exception cause required for {0}.".Interpolate(priority),
"priority");
break;
default:
throw new ArgumentException(
"Invalid Interrupt value ({0}).".Interpolate(priority),
"priority");
}
var exCause = 0;
switch (cause)
{
case ExceptionCause.None:
break;
case ExceptionCause.Unimplemented:
exCause = Core.Machine.Architecture == Architecture.EpiphanyIV ? 0xF : 0x4;
break;
case ExceptionCause.SoftwareInterrupt:
exCause = Core.Machine.Architecture == Architecture.EpiphanyIV ? 0xE : 0x1;
break;
case ExceptionCause.UnalignedAccess:
exCause = Core.Machine.Architecture == Architecture.EpiphanyIV ? 0xD : 0x2;
break;
case ExceptionCause.IllegalAccess:
exCause = Core.Machine.Architecture == Architecture.EpiphanyIV ? 0xC : 0x5;
break;
case ExceptionCause.FloatingPoint:
exCause = Core.Machine.Architecture == Architecture.EpiphanyIV ? 0x7 : 0x3;
break;
default:
throw new ArgumentException(
"Invalid ExceptionCause value ({0}).".Interpolate(cause),
"cause");
}
lock (_lock)
{
Core.Registers.InterruptLatch = Bits.Set(Core.Registers.InterruptLatch, (int)priority);
if (cause != ExceptionCause.None)
Core.Registers.CoreStatus = Bits.Insert(Core.Registers.CoreStatus, (uint)exCause, 16, 4);
}
}
//
//主函数cpu
//
public void cpu()
{
if (true)
{
switch (PSW)
{
case Interrupt.End:
{
//
//写入out文件
//
//
//撤销进程，进行进程调度
//
Destory(Execute);
int a = JudgeAttemper();
if (a < 10)
{
Attemper(a);
}
PSW = Interrupt.No;
break;
}
case Interrupt.IO:
{
BlockProcess(Execute, type, time);
PSW = Interrupt.No;
break;
}
default:
{
break;
}
}
switch (PSW1)
{
case Interrupt.IO:
{
int b = Block;
while (b < 10)
{
if (XDTime - PCBArray[b].GetDeviceTime - 1 == PCBArray[b].WaitTime)
{
Dev.DeAllocate(PCBArray[b].HaveDevice, PCBArray[b].DN);
WakeUp(b, PCBArray[b].HaveDevice);
PCBArray[b].DN = -1;
PCBArray[b].GetDeviceTime = 0;
PCBArray[b].HaveDevice = DeviceType.no;
PCBArray[b].WaitTime = -10;
}
b = PCBArray[b].Next;
}
PSW1 = Interrupt.No;
break;
}
default:
{
break;
}
}
if (Execute < 10)
{
IR = ram.SendToIR(PCBArray[Execute].PageAdress, PC);
PC = PC + 4;
bool str = ram.JudgeIR(IR);
if (str == true)
{
switch (IR[1])
{
case '=':
{
DR = Convert.ToInt32(IR[2].ToString());
break;
}
case '+':
{
DR++;
break;
}
case '-':
{
DR--;
break;
}
case 'a':
case 'A':
{
type = DeviceType.a;
time = Convert.ToInt32(IR[2].ToString());
PSW = Interrupt.IO;
break;
}
case 'b':
case 'B':
{
type = DeviceType.b;
time = Convert.ToInt32(IR[2].ToString());
PSW = Interrupt.IO;
break;
}
case 'c':
case 'C':
{
type = DeviceType.c;
time = Convert.ToInt32(IR[2].ToString());
PSW = Interrupt.IO;
break;
}
case 'n':
{
PSW = Interrupt.End;
break;
}
}
PCBArray[Execute].ExecuteTime++;
if (FinishIR != null)
{
EventArgs e = new EventArgs();
FinishIR(null, e);
}
}
else
{
Destory(Execute);
int b = JudgeAttemper();
if (b < 10)
{
Attemper(b);
}
if (ErrorIR != null)
{
EventArgs e = new EventArgs();
ErrorIR(null, e);
}
}
}
else
{
//
//do nothing
//
if (this.ExecuteIsWhite != null)
{
EventArgs e = new EventArgs();
ExecuteIsWhite(null, e);
}
}
int k = Block;
while (k < 10)
{
if (XDTime - PCBArray[k].GetDeviceTime == PCBArray[k].WaitTime)
{
PSW1 = Interrupt.IO;
}
k = PCBArray[k].Next;
}
if (QueueChange != null)
{
EventArgs e = new EventArgs();
QueueChange(null, e);
}
XDTime++;
IR = "";
}
}
/// <summary>
/// 将系统跳转到指定的稳定状态
/// </summary>
/// <param name="ssp">要演绎的状态包装</param>
public static void GotoSteadyState(RollbackableSnapshot ssp)
{
// 停止消息循环
Director.PauseUpdateContext();
// 结束全部动画
SpriteAnimation.ClearAnimateWaitingDict();
// 检查是否需要回滚当前的并行处理和信号绑定
bool needRepara = false;
if (ssp.VMRef.ESP.BindingSceneName != Director.RunMana.CallStack.SAVEP.BindingSceneName)
{
Director.RunMana.PauseParallel();
needRepara = true;
}
// 退到SSP所描述的状态
SymbolTable.GetInstance().SetDAO(ssp.sceneDao.Fork() as SceneContextDAO, ssp.globalDao.Fork() as GlobalContextDAO);
ScreenManager.ResetSynObject(ssp.ScreenStateRef.Fork() as ScreenManager);
Director.RunMana.ResetCallstackObject(ssp.VMRef.Fork() as StackMachine);
Director.RunMana.Backlogs = ForkableState.DeepCopyBySerialization(ssp.BacklogRef);
Director.RunMana.Musics = ForkableState.DeepCopyBySerialization(ssp.MusicRef);
Director.RunMana.DashingPureSa = ssp.ReactionRef.Clone(true);
Director.RunMana.SemaphoreBindings = ForkableState.DeepCopyBySerialization(ssp.SemaphoreDict);
Director.RunMana.EnableRClick = ssp.EnableRClickRef;
Director.RunMana.PerformingChapter = ssp.PerformingChapterRef;
Director.ScrMana = ScreenManager.GetInstance();
// 刷新主渲染器上的堆栈绑定
Director.GetInstance().RefreshMainRenderVMReference();
Director.GetInstance().GetMainRender().IsBranching = ssp.IsBranchingRefer;
// 重绘整个画面
ViewManager.GetInstance().ReDraw(true);
// 恢复音效
UpdateRender render = Director.GetInstance().GetMainRender();
if (GlobalConfigContext.UseBassEngine)
{
MusicianBass.GetInstance().RePerform(Director.RunMana.Musics);
}
else
{
Musician.GetInstance().RePerform(Director.RunMana.Musics);
}
// 清空字符串缓冲
render.dialogPreStr = String.Empty;
render.pendingDialogQueue.Clear();
// 关闭自动播放
Director.RunMana.IsAutoplaying = false;
// 弹空全部等待，复现保存最后一个动作
Director.RunMana.ExitUserWait();
Interrupt reactionNtr = new Interrupt()
{
Type = InterruptType.LoadReaction,
Detail = "Reaction for rollback",
InterruptSA = ssp.ReactionRef,
InterruptFuncSign = String.Empty,
ReturnTarget = null,
PureInterrupt = true
};
// 提交中断到主调用堆栈
Director.RunMana.CallStack.Submit(reactionNtr);
// 重启并行处理和信号系统
if (needRepara)
{
var sc = ResourceManager.GetInstance().GetScene(ssp.VMRef.EBP.BindingSceneName);
Director.RunMana.ConstructParallelForRollingBack(sc);
Director.RunMana.BackTraceParallel();
Director.RunMana.LastSceneName = sc.Scenario;
SemaphoreDispatcher.ReBinding(sc, Director.RunMana.SemaphoreBindings);
}
// 重启消息循环
Director.ResumeUpdateContext();
}
public void RaiseInterrupt(Interrupt type, ulong data1, ulong data2) => this.InterruptController.Enqueue(type, data1, data2);
private void Page_PreviewMouseRightButtonUp(object sender, MouseButtonEventArgs e)
{
if (e != null)
{
this.core.UpdateMouse(e);
}
if (this.isResumingFromLoad || (!SpriteAnimation.IsAnyAnimation && this.IsAllowClose))
{
if (this.currentStaging == "root")
{
this.IsAllowClose = false;
if (CallbackTarget != String.Empty)
{
var callbackNtr = new Interrupt()
{
Detail = "LHRCCallbackNTR",
InterruptSA = null,
Type = InterruptType.ButtonJump,
ReturnTarget = CallbackTarget,
ExitWait = true
};
// 提交返回主舞台的中断到主调用堆栈
Director.RunMana.CallStack.Submit(callbackNtr);
// 重置回调
CallbackTarget = String.Empty;
Director.RunMana.Symbols.GlobalCtxDao.GlobalSymbolTable.Assign("tracing_callback", String.Empty);
}
Storyboard closeSb = new Storyboard();
this.PanelSprite.Descriptor.ToX = 1920 + 1920 / 2;
SpriteAnimation.XMoveToAnimation(this.PanelSprite, new Duration(TimeSpan.FromMilliseconds(150)), 1920 + 1920 / 2, -0.8, providedStory: closeSb);
this.NameLogoSprite.Descriptor.ToOpacity = 0;
SpriteAnimation.OpacityToAnimation(this.NameLogoSprite, new Duration(TimeSpan.FromMilliseconds(150)), 0, 0, providedStory: closeSb);
this.EpisodeHintSprite.Descriptor.ToOpacity = 0;
SpriteAnimation.OpacityToAnimation(this.EpisodeHintSprite, new Duration(TimeSpan.FromMilliseconds(150)), 0, 0, providedStory: closeSb);
this.ButtonGroupSprite.Descriptor.ToOpacity = 0;
this.ButtonGroupSprite.Descriptor.ToY = 1080 / 2 + 50;
SpriteAnimation.OpacityToAnimation(this.ButtonGroupSprite, new Duration(TimeSpan.FromMilliseconds(150)), 0, 0, providedStory: closeSb);
SpriteAnimation.YMoveToAnimation(this.ButtonGroupSprite, new Duration(TimeSpan.FromMilliseconds(150)), 1080 / 2 + 25, 0, providedStory: closeSb);
SpriteAnimation.BlurMutexAnimation(this.MainStageSprite, TimeSpan.FromMilliseconds(300), 0, 0, providedStory: closeSb);
closeSb.Completed += (_, __) =>
{
this.PrepareClose();
this.core.GetMainRender().ResumeFromRclick();
if (this.IsFromAutoChanged)
{
RollbackManager.IsRollingBack = false;
Director.RunMana.IsAutoplaying = true;
Director.RunMana.ExitUserWait();
Director.RunMana.AutoPlayWait();
this.core.GetMainRender().HideMessageTria();
NotificationManager.Notify(String.Empty, "已启用自动播放", String.Empty, 1500);
this.IsFromAutoChanged = false;
}
else if (this.IsFromReturnTitle)
{
this.IsFromReturnTitle = false;
this.core.GetMainRender().Title();
}
};
closeSb.Begin();
}
else if (this.currentStaging == "backlog")
{
this.HandleBackward((_, __) => this.currentStaging = "root");
}
else if (this.currentStaging == "save")
{
this.HandleBackward((_, __) => this.currentStaging = "root");
}
else if (this.currentStaging == "load")
{
this.HandleBackward((_, __) => this.currentStaging = "root");
}
else if (this.currentStaging == "settings")
{
this.HandleBackward((_, __) => this.currentStaging = "root");
}
}
}
public ExecutionContext(int id, StackFrame stackTop, int currentValueStackSize, int valueStackCapacity, Value[] valueStack, Value[] localsStack, int[] localsStackSet, int localsStackSetToken, int executionCounter, bool activeExceptionHandled, Value activeException, bool executionStateChange, int executionStateChangeCommand, Interrupt activeInterrupt)
{
this.id = id;
this.stackTop = stackTop;
this.currentValueStackSize = currentValueStackSize;
this.valueStackCapacity = valueStackCapacity;
this.valueStack = valueStack;
this.localsStack = localsStack;
this.localsStackSet = localsStackSet;
this.localsStackSetToken = localsStackSetToken;
this.executionCounter = executionCounter;
this.activeExceptionHandled = activeExceptionHandled;
this.activeException = activeException;
this.executionStateChange = executionStateChange;
this.executionStateChangeCommand = executionStateChangeCommand;
this.activeInterrupt = activeInterrupt;
}
/// <summary>
/// Raises the <see cref="Interrupt"/> event.
/// </summary>
/// <param name="e">A <see cref="HandledEventArgs"/> that contains the event data.</param>
protected virtual void OnInterrupt(HandledEventArgs e)
{
Interrupt?.Invoke(this, e);
}
public void Attached(Interrupt interrupt, IDeviceView view)
{
this.interrupt = interrupt;
this.View = view;
Attached();
}
// Read the next line of input using line editing. Returns "null"
// if an EOF indication is encountered in the input.
public string ReadLine()
{
var treatControlCAsInterrupt = Console.TreatControlCAsInput;
Console.TreatControlCAsInput = !CtrlCInterrupts;
try
{
// Output the prompt.
WritePrompt?.Invoke(this, EventArgs.Empty);
// Enter the main character input loop.
_posn = 0;
_length = 0;
_column = 0;
_lastColumn = 0;
_overwrite = false;
_historyPosn = -1;
var ctrlv = false;
_state = ReadlineState.MoreInput;
do
{
var key = ConsoleExtensions.ReadKey(true);
var ch = key.KeyChar;
if (ctrlv)
{
ctrlv = false;
if ((ch >= 0x0001 && ch <= 0x001F) || ch == 0x007F)
{
// Insert a control character into the buffer.
AddChar(ch);
continue;
}
}
if (ch != '\0')
{
switch (ch)
{
case '\u0001':
{
// CTRL-A: move to the home position.
MoveHome();
}
break;
case '\u0002':
{
// CTRL-B: go back one character.
MoveLeft();
}
break;
case '\u0003':
{
// CTRL-C encountered in "raw" mode.
if (CtrlCInterrupts)
{
EndLine();
Interrupt?.Invoke(null, EventArgs.Empty);
return(null);
}
CancelLine();
_lastWord.Length = 0;
}
break;
case '\u0004':
{
// CTRL-D: EOF or delete the current character.
if (CtrlDIsEOF)
{
_lastWord.Length = 0;
// Signal an EOF if the buffer is empty.
if (_length == 0)
{
EndLine();
return(null);
}
}
else
{
Delete();
ResetComplete(ReadlineState.MoreInput);
}
}
break;
case '\u0005':
{
// CTRL-E: move to the end position.
MoveEnd();
}
break;
case '\u0006':
{
// CTRL-F: go forward one character.
MoveRight();
}
break;
case '\u0007':
{
// CTRL-G: ring the terminal bell.
Console.Beep();
}
break;
case '\u0008':
case '\u007F':
{
if (key.Key == ConsoleKey.Delete)
{
// Delete the character under the cursor.
Delete();
}
else
{
// Delete the character before the cursor.
Backspace();
}
ResetComplete(ReadlineState.MoreInput);
}
break;
case '\u0009':
{
// Process a tab.
Tab();
}
break;
case '\u000A':
case '\u000D':
{
// Line termination.
EndLine();
ResetComplete(ReadlineState.Done);
_lastWord.Length = 0;
}
break;
case '\u000B':
{
// CTRL-K: erase until the end of the line.
EraseToEnd();
}
break;
case '\u000C':
{
// CTRL-L: clear screen and redraw.
Console.Clear();
WritePrompt?.Invoke(this, EventArgs.Empty);
Redraw();
}
break;
case '\u000E':
{
// CTRL-N: move down in the history.
MoveDown();
}
break;
case '\u0010':
{
// CTRL-P: move up in the history.
MoveUp();
}
break;
case '\u0015':
{
// CTRL-U: erase to the start of the line.
EraseToStart();
ResetComplete(ReadlineState.None);
}
break;
case '\u0016':
{
// CTRL-V: prefix a control character.
ctrlv = true;
}
break;
case '\u0017':
{
// CTRL-W: erase the previous word.
EraseWord();
ResetComplete(ReadlineState.MoreInput);
}
break;
case '\u0019':
{
// CTRL-Y: yank the last erased string.
if (_yankedString != null)
{
foreach (var ch2 in _yankedString)
{
AddChar(ch2);
}
}
}
break;
case '\u001A':
{
// CTRL-Z: Windows end of file indication.
if (CtrlZIsEOF && _length == 0)
{
EndLine();
return(null);
}
}
break;
case '\u001B':
{
// Escape is "clear line".
Clear();
ResetComplete(ReadlineState.MoreInput);
}
break;
default:
{
if (ch >= ' ')
{
// Ordinary character.
AddChar(ch);
ResetComplete(ReadlineState.MoreInput);
}
}
break;
}
}
else if (key.Modifiers == 0)
{
switch (key.Key)
{
case ConsoleKey.Backspace:
{
// Delete the character before the cursor.
Backspace();
ResetComplete(ReadlineState.MoreInput);
}
break;
case ConsoleKey.Delete:
{
// Delete the character under the cursor.
Delete();
ResetComplete(ReadlineState.MoreInput);
}
break;
case ConsoleKey.Enter:
{
// Line termination.
EndLine();
ResetComplete(ReadlineState.Done);
}
break;
case ConsoleKey.Escape:
{
// Clear the current line.
Clear();
ResetComplete(ReadlineState.None);
}
break;
case ConsoleKey.Tab:
{
// Process a tab.
Tab();
}
break;
case ConsoleKey.LeftArrow:
{
// Move left one character.
MoveLeft();
}
break;
case ConsoleKey.RightArrow:
{
// Move right one character.
MoveRight();
}
break;
case ConsoleKey.UpArrow:
{
// Move up one line in the history.
MoveUp();
}
break;
case ConsoleKey.DownArrow:
{
// Move down one line in the history.
MoveDown();
}
break;
case ConsoleKey.Home:
{
// Move to the beginning of the line.
MoveHome();
}
break;
case ConsoleKey.End:
{
// Move to the end of the line.
MoveEnd();
}
break;
case ConsoleKey.Insert:
{
// Toggle insert/overwrite mode.
_overwrite = !_overwrite;
}
break;
}
}
else if ((key.Modifiers & ConsoleModifiers.Alt) != 0)
{
switch (key.Key)
{
case ConsoleKey.F:
{
// ALT-F: move forward a word.
MoveForwardWord();
}
break;
case ConsoleKey.B:
{
// ALT-B: move backward a word.
MoveBackwardWord();
}
break;
case ConsoleKey.D:
{
// ALT-D: erase until the end of the word.
EraseToEndWord();
}
break;
case ConsoleKey.Backspace:
case ConsoleKey.Delete:
{
// ALT-DEL: erase until the start of the word.
EraseToStartWord();
}
break;
}
}
} while (_state != ReadlineState.Done);
return(new string(_buffer, 0, _length));
}
finally
{
Console.TreatControlCAsInput = treatControlCAsInterrupt;
}
}
private void OnInterrupt()
{
Interrupt?.Invoke(this, EventArgs.Empty);
}
internal static int Priority(this Interrupt interrupt) => interrupt switch
{
public void CancelPendingRequest(Interrupt message)
{
Trace.WriteLine("Cancelling request: " + message.Source);
}
/// <summary>
/// 设置运行时环境管理器，用于读取保存的信息
/// </summary>
/// <param name="rm">反序列化后的RM实例</param>
public static void ResumeFromSaveData(RuntimeManager rm)
{
// 停止消息循环
Director.PauseUpdateContext();
// 清空回滚器
RollbackManager.Clear();
// 清空画面
ViewManager.GetInstance().RemoveView(ResourceType.Unknown);
// 检查是否需要回滚当前的并行处理
Director.RunMana.StopAllParallel();
// 变更运行时环境
Director.RunMana = rm;
Director.RunMana.ParallelHandler = Director.GetInstance().ParallelUpdateContext;
SymbolTable.ResetSynObject(Director.RunMana.Symbols);
LogUtils.LogLine("RuntimeManager is replaced", "Director", LogLevel.Important);
// 缓存指令指针
var irname = rm.CallStack.ESP.IR;
var isname = rm.CallStack.ESP.BindingSceneName;
rm.CallStack.ESP.MircoStep(Director.GetInstance().resMana.GetScene(isname).YuriDict[irname]);
// 变更屏幕管理器
ScreenManager.ResetSynObject(Director.RunMana.Screen);
LogUtils.LogLine("ScreenManager is replaced", "Director", LogLevel.Important);
// 重绘整个画面
ViewManager.GetInstance().ReDraw();
// 重新绑定渲染器的作用堆栈
UpdateRender render = Director.GetInstance().updateRender;
render.VsmReference = Director.RunMana.CallStack;
// 恢复背景音乐
if (GlobalConfigContext.UseBassEngine)
{
MusicianBass.GetInstance().RePerform(Director.RunMana.Musics);
}
else
{
Musician.GetInstance().RePerform(Director.RunMana.Musics);
}
// 清空字符串缓冲
render.dialogPreStr = String.Empty;
render.pendingDialogQueue.Clear();
// 关闭自动播放
Director.RunMana.IsAutoplaying = false;
// 弹空全部等待，复现保存最后一个动作
Director.RunMana.ExitUserWait();
Interrupt reactionNtr = new Interrupt()
{
Type = InterruptType.LoadReaction,
Detail = "Reaction for load data",
InterruptSA = Director.RunMana.DashingPureSa,
InterruptFuncSign = String.Empty,
ReturnTarget = null,
PureInterrupt = true
};
// 提交中断
Director.RunMana.CallStack.Submit(reactionNtr);
// 重启并行调度系统
var sc = ResourceManager.GetInstance().GetScene(Director.RunMana.CallStack.EBP.BindingSceneName);
Director.RunMana.ParallelExecutorStack = new Stack <List <ParallelExecutor> >();
Director.RunMana.ConstructParallel(sc);
Director.RunMana.RestartParallel();
Director.RunMana.LastScenario = sc.Scenario;
// 重启信号分发系统
SemaphoreDispatcher.ReBinding(sc, Director.RunMana.SemaphoreBindings);
// 重启主调用堆栈上的消息循环
Director.ResumeUpdateContext();
}
public void CancelPendingRequest(Interrupt message)
{
Trace.WriteLine("Cancelling request: " + message.Source);
}
public void CastInterrupted()
{
//casting logic
Interrupt?.Invoke(this, new ScriptEventArgs(CastState.Casting));
}
internal void RequestInterrupt(Interrupt interrupt)
{
IF |= (byte)interrupt;
}
