public static SequenceAction Sequence(SceneAction action1)
{
SequenceAction action = Action <SequenceAction>();
action.AddAction(action1);
return(action);
}
public async Task SetAsync(SceneAction action, CancellationToken cancellationToken = default)
{
await using var transaction = await _context.Database.BeginTransactionAsync(cancellationToken);
try
{
await RemoveAsync(action.Id, cancellationToken);
}
catch (Exception e)
{
await transaction.RollbackAsync(cancellationToken);
_logger.LogError(e, $"Failed to remove '{action.Id}'");
return;
}
await _context.SceneActions.AddAsync(action, cancellationToken);
try
{
await _context.SaveChangesAsync(cancellationToken);
}
catch (Exception e)
{
await transaction.RollbackAsync(cancellationToken);
_logger.LogError(e, "Failed to add new action");
return;
}
await transaction.CommitAsync(cancellationToken);
}
/// <summary>
/// 将动作序列和从属于它的动作序列全部IL化
/// </summary>
/// <param name="saRoot">递归开始节点</param>
/// <returns>IL字符串</returns>
private string ILGenerator(SceneAction saRoot)
{
StringBuilder resSb = new StringBuilder(String.Empty);
Stack <SceneAction> processStack = new Stack <SceneAction>();
processStack.Push(saRoot);
while (processStack.Count != 0)
{
SceneAction topSa = processStack.Pop();
// 栈，先处理falseRouting
if (topSa.FalseRouting != null)
{
for (int i = topSa.FalseRouting.Count - 1; i >= 0; i--)
{
processStack.Push(topSa.FalseRouting[i]);
}
}
// 处理trueRouting
if (topSa.TrueRouting != null)
{
for (int i = topSa.TrueRouting.Count - 1; i >= 0; i--)
{
processStack.Push(topSa.TrueRouting[i]);
}
}
resSb.AppendLine(Pile.needEncryption
? YuriEncryptor.EncryptString(topSa.ToIL(), Pile.Encryptor)
: topSa.ToIL());
}
return(resSb.ToString());
}
public void ForEachScene(SceneAction d)
{
foreach (Scene s in m_Scenes)
{
d(s);
}
}
public ParallelAction(SceneAction action1, SceneAction action2, SceneAction action3, SceneAction action4)
{
AddAction(action1);
AddAction(action2);
AddAction(action3);
AddAction(action4);
}
/// <summary>
/// 场景调用
/// </summary>
/// <param name="scene">场景实例</param>
/// <param name="target">目标标签</param>
public void CallScene(Scene scene, SceneAction target = null)
{
if (scene == null)
{
return;
}
LogUtils.LogLine(String.Format("Call Scene: {0} , with target: {1}", scene.Scenario, target == null ? "null" : target.NodeName),
"RuntimeManager", LogLevel.Important);
// 基础调用
this.CallStack.Submit(scene, target);
// 如果当前有并行，而又调用了带有并行的场景，那么就要暂停现在的并行
if (this.LastSceneName != scene.Scenario)
{
// fix:这块本来在外面的
if (this.ParallelExecutorStack.Count != 0)
{
var parasBeforeCalling = this.ParallelExecutorStack.Peek();
parasBeforeCalling.ForEach(t => t.Dispatcher.Stop());
}
// 处理场景的并行函数
this.ConstructParallel(scene);
}
// 更新场景名字记录
this.LastSceneName = scene.Scenario;
}
public static ParallelAction Parallel(SceneAction action1)
{
ParallelAction action = Action <ParallelAction>();
action.AddAction(action1);
return(action);
}
public SequenceAction(SceneAction action1, SceneAction action2, SceneAction action3, SceneAction action4)
{
AddAction(action1);
AddAction(action2);
AddAction(action3);
AddAction(action4);
}
private void Start()
{
if (controllerCamera == null || !controllerCamera.gameObject.activeInHierarchy)
{
controllerCamera = new GameObject("Controller UI Camera").AddComponent <Camera>();
controllerCamera.clearFlags = CameraClearFlags.Nothing; //CameraClearFlags.Depth;
controllerCamera.cullingMask = 0; // 1 << LayerMask.NameToLayer("UI");
controllerCamera.pixelRect = new Rect {
x = 0, y = 0, width = 10, height = 10
};
}
foreach (Canvas canvas in GetComponentsInChildren <Canvas>())
{
canvas.worldCamera = controllerCamera;
}
current_actions = new Dictionary <ControllerAction, ActionTracker>();
if (GetComponentInChildren <Collider>() == null)
{
RectTransform rtr = transform as RectTransform;
Rect r = rtr.rect;
BoxCollider coll = gameObject.AddComponent <BoxCollider>();
coll.isTrigger = true;
coll.size = new Vector3(r.width, r.height, 1); /* XXX check what occurs if the Canvas contains components
* that have a Z coordinate that differs a lot from 0 */
coll.center = r.center;
}
SceneAction.Register(sceneActionName, gameObject,
buttonEnter: OnButtonEnter, buttonOver: OnButtonOver, buttonLeave: OnButtonLeave,
buttonDown: OnButtonDown, buttonDrag: OnButtonDrag, buttonUp: OnButtonUp);
}
public SequenceAction(SceneAction action1, SceneAction action2, SceneAction action3, SceneAction action4)
{
AddAction(action1);
AddAction(action2);
AddAction(action3);
AddAction(action4);
}
public void CreateMap(Map map)
{
nowMapMessage.Clear();
nowMap = map;
for (short i = 0; i < map.mapXCount; i++)
{
for (short j = 0; j < map.mapYCount; j++)
{
MapNode node = new MapNode();
node.xPoint = i;
node.yPoint = j;
MapPointMessage temp = new MapPointMessage();
temp.xPoint = i;
temp.yPoint = j;
temp.xposition = (i - map.mapXCount / 2) * 10;
temp.yposition = (j - map.mapYCount / 2) * 10;
int index = i * map.mapYCount + j;
if (index >= map.mapData.Count)
{
temp.textureID = 0;
}
else
{
temp.textureID = map.mapData[index];
}
nowMapMessage.Add(node, temp);
}
}
SceneAction.OnUpDateMap();
}
public override void Update(GameTime gameTime)
{
conversation.Update(gameTime);
if (InputHandler.KeyReleased(Keys.Enter) || InputHandler.KeyReleased(Keys.Space) ||
InputHandler.ButtonReleased(Buttons.A, PlayerIndex.One))
{
InputHandler.Flush();
SceneAction action = conversation.CurrentScene.OptionAction;
switch (action.Action)
{
case ActionType.Talk:
conversation.ChangeScene(conversation.CurrentScene.OptionScene);
break;
case ActionType.Quest:
conversation.ChangeScene(conversation.CurrentScene.OptionScene);
break;
case ActionType.Change:
conversation =
conversations.GetConversation(conversation.CurrentScene.OptionScene);
conversation.StartConversation();
break;
case ActionType.End:
StateManager.PopState();
break;
}
}
base.Update(gameTime);
}
public ParallelAction(SceneAction action1, SceneAction action2, SceneAction action3, SceneAction action4)
{
AddAction(action1);
AddAction(action2);
AddAction(action3);
AddAction(action4);
}
/// <summary>
/// Constructs the scene actions.
/// </summary>
/// <param name="actionData">The action data.</param>
/// <returns>IEnumerable of actions that can be performed in the scene</returns>
private IEnumerable <SceneAction> ConstructSceneActions(string[] actionData)
{
List <SceneAction> sceneActions = new List <SceneAction>();
foreach (var action in actionData)
{
var actionSplit = action.SplitString("-");
foreach (var verbAction in actionSplit.Last().SplitString("(", ")"))
{
var subScripts = verbAction.ParseString("\"", "\"").SplitString("|");
var sceneAction = new SceneAction
{
KeyWord = actionSplit.First(),
KeyWordVerb = verbAction.ParseEnum <Verb>("*"),
AddToWordBag = verbAction.Contains("^") ? true : false,
NavigateToScene = verbAction.ParseInt("[", "]"),
ItemCheckConditions = this.ConstructSceneActionConditions(verbAction.ParseString("{", "}")),
SuccessResultScript = subScripts.ElementAtOrDefault(0),
FailureResultScript = subScripts.ElementAtOrDefault(1)
};
sceneActions.Add(sceneAction);
}
}
return(sceneActions);
}
public void AddAction(SceneAction action)
{
_actions.Add(action);
if (Actor != null)
{
action.Actor = Actor;
}
}
private static Exception ActionHasDescription(Scene scene, SceneAction action)
{
if (!string.IsNullOrWhiteSpace(action.Abbreviation) && string.IsNullOrWhiteSpace(action.Description))
{
return(ActionValidationError(Strings.Validation_ErrorNoActionDescription, scene, action));
}
return(null);
}
private static Exception ActionHasResultOrNextScene(Scene scene, SceneAction action)
{
if (string.IsNullOrWhiteSpace(action.Result) && string.IsNullOrWhiteSpace(action.NextScene))
{
return(ActionValidationError(Strings.Validation_ErrorNoActionResultOrScene, scene, action));
}
return(null);
}
public override void OnAction(SceneAction gameAction, object data)
{
switch (gameAction)
{
default:
base.OnAction(gameAction, data);
break;
}
}
/// <summary>
/// 将动作序列绑定到一个新的场景函数
/// </summary>
/// <param name="funcSa">动作序列</param>
/// <returns>场景函数</returns>
private SceneFunction ConstructSceneFunction(SceneAction funcSa)
{
if (funcSa.IsBelongFunc != true)
{
throw new InterpreterException()
{
Message = "一个非函数节点被作为函数声明处理",
HitLine = Convert.ToInt32((funcSa.Tag.Split('-'))[0]),
HitColumn = Convert.ToInt32((funcSa.Tag.Split('-'))[1]),
HitPhase = InterpreterPhase.Sematicer,
SceneFileName = this.scenario
};
}
// 获得函数签名
string signature = funcSa.ArgsDict["sign"];
string[] signItem = signature.Split(new char[] { '(', ')' }, StringSplitOptions.RemoveEmptyEntries);
if (signItem.Length < 1 || !IsSymbol(signItem[0].Trim()))
{
throw new InterpreterException()
{
Message = "函数签名不合法",
HitLine = Convert.ToInt32((funcSa.Tag.Split('-'))[0]),
HitColumn = Convert.ToInt32((funcSa.Tag.Split('-'))[1]),
HitPhase = InterpreterPhase.Sematicer,
SceneFileName = this.scenario
};
}
List <string> funcParas = new List <string>();
// 如果没有参数就跳过参数遍历
if (signItem.Length > 1)
{
string[] varItem = signItem[1].Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string ivar in varItem)
{
if (ivar.StartsWith("$") && IsSymbol(ivar.Substring(1)))
{
funcParas.Add(ivar);
}
else
{
throw new InterpreterException()
{
Message = "函数签名的参数列表不合法",
HitLine = Convert.ToInt32((funcSa.Tag.Split('-'))[0]),
HitColumn = Convert.ToInt32((funcSa.Tag.Split('-'))[1]),
HitPhase = InterpreterPhase.Sematicer,
SceneFileName = this.scenario
};
}
}
}
return(new SceneFunction(signItem[0].Trim(), this.scenario, funcSa));
}
private static void ShowActionResult(SceneAction action)
{
if (string.IsNullOrWhiteSpace(action.Result))
{
return;
}
UserInterfaceHelper.OutputLine();
UserInterfaceHelper.OutputLine(action.Result);
UserInterfaceHelper.Pause();
}
public static ParallelAction Parallel(SceneAction action1, SceneAction action2, SceneAction action3, SceneAction action4, SceneAction action5)
{
ParallelAction action = Action <ParallelAction>();
action.AddAction(action1);
action.AddAction(action2);
action.AddAction(action3);
action.AddAction(action4);
action.AddAction(action5);
return(action);
}
public static SequenceAction Sequence(SceneAction action1, SceneAction action2, SceneAction action3, SceneAction action4, SceneAction action5)
{
SequenceAction action = Action <SequenceAction>();
action.AddAction(action1);
action.AddAction(action2);
action.AddAction(action3);
action.AddAction(action4);
action.AddAction(action5);
return(action);
}
/// <summary>
/// 判断一个动作节点是否是复杂节点，即包含TrueRouting和FalseRouting
/// </summary>
/// <param name="saNode">节点</param>
/// <returns>是否复杂节点</returns>
private bool IsComplexBlock(SceneAction saNode)
{
switch (saNode.Type)
{
case SActionType.act_function:
case SActionType.act_if:
case SActionType.act_for:
return(true);
default:
return(false);
}
}
public static void ApplyRenderAction(SceneAction action)
{
foreach (var cp in ViewPageManager.PageCallStack)
{
if (cp is RenderablePage)
{
((RenderablePage)cp).OnSceneActionDone(action);
}
}
if (ViewManager.mWnd?.uiFrame?.Content != null && ViewManager.mWnd?.uiFrame?.Content is RenderablePage)
{
((RenderablePage)ViewManager.mWnd.uiFrame.Content).OnSceneActionDone(action);
}
}
/// <summary>
/// 系统向前进一个状态
/// 她只有在对话推进和选择项出现时才被触发
/// </summary>
public static void SteadyForward(bool fromWheel, SceneAction saPtr, MusicianDescriptor mdescriptor, BacklogHolder backlogHolder)
{
lock (typeof(RollbackManager))
{
// 回滚后返回，移栈并演绎
if (fromWheel && RollbackManager.IsRollingBack)
{
// 取上一状态
var recentStep = RollbackManager.backwardStack.Last();
RollbackManager.backwardStack.RemoveLast();
RollbackManager.forwardStack.AddLast(recentStep);
// 重演绎
RollbackManager.GotoSteadyState(recentStep);
}
// 非回滚状态时才重新构造
else if (fromWheel == false)
{
// 处理回顾
if (saPtr.Type == SActionType.act_dialog)
{
backlogHolder.AddLog(saPtr.Tag);
}
// 构造当前状态的拷贝
var vm = Director.RunMana.CallStack.Fork() as StackMachine;
vm.SetMachineName(String.Format("Yuri!Forked?{0}?{1}", DateTime.Now.Ticks, rand.Next(0, int.MaxValue)));
RollbackableSnapshot ssp = new RollbackableSnapshot()
{
TimeStamp = DateTime.Now,
IsBranchingRefer = Director.GetInstance().GetMainRender().IsBranching,
MusicRef = ForkableState.DeepCopyBySerialization(mdescriptor),
BacklogRef = ForkableState.DeepCopyBySerialization(backlogHolder),
ReactionRef = saPtr,
VMRef = vm,
globalDao = SymbolTable.GetInstance().GlobalCtxDao.Fork() as GlobalContextDAO,
sceneDao = SymbolTable.GetInstance().SceneCtxDao.Fork() as SceneContextDAO,
ScreenStateRef = ScreenManager.GetInstance().Fork() as ScreenManager,
SemaphoreDict = ForkableState.DeepCopyBySerialization(Director.RunMana.SemaphoreBindings),
EnableRClickRef = Director.RunMana.EnableRClick,
PerformingChapterRef = Director.RunMana.PerformingChapter
};
// 如果栈中容量溢出就剔掉最早进入的那个
if (RollbackManager.forwardStack.Count >= GlobalConfigContext.MaxRollbackStep)
{
RollbackManager.forwardStack.RemoveFirst();
}
// 入栈
RollbackManager.forwardStack.AddLast(ssp);
}
}
}
/// <summary>
/// 进行语义分析
/// </summary>
/// <param name="root">语法树根节点</param>
/// <returns>一个键值对，剧本的动作序列和函数向量</returns>
private KeyValuePair <SceneAction, List <SceneFunction> > Semanticer(SyntaxTreeNode root)
{
SceneAction resSa = null;
List <SceneAction> funcSaVec = new List <SceneAction>();
List <SceneFunction> funcVec = new List <SceneFunction>();
this.forStack = new Stack <SceneAction>();
this.removeQueueDict = new Dictionary <SceneAction, Queue <SceneAction> >();
this.blockDict = new Dictionary <string, SceneAction>();
this.AST(this.parseTree, ref resSa, funcSaVec);
this.BackpatchOptimizer(resSa, resSa, false);
funcSaVec.ForEach((x) => funcVec.Add(this.BackpatchOptimizer(x, x, true)));
resSa.Tag = this.scenario;
return(new KeyValuePair <SceneAction, List <SceneFunction> >(resSa, funcVec));
}
/// <summary>
/// 取下一动作指令并暂存当前执行的动作
/// </summary>
/// <param name="vsm">关于哪个调用堆栈做动作</param>
/// <returns>动作实例</returns>
public SceneAction MoveNext(StackMachine vsm)
{
SceneAction fetched = this.FetchNextInstruction(vsm);
if (fetched != null && vsm.ESP.State == StackMachineState.Interpreting)
{
this.DashingPureSa = fetched.Clone(true);
if (this.DashingPureSa.Type == SActionType.act_dialog ||
this.DashingPureSa.Type == SActionType.act_branch)
{
RollbackManager.SteadyForward(false, this.DashingPureSa, this.Musics, this.Backlogs);
}
}
return(fetched);
}
/// <summary>
/// 将场景做IL序列化
/// </summary>
/// <param name="scene">场景实例</param>
/// <returns>IL字符串</returns>
private string ILGenerator(Scene scene)
{
List <SceneFunction> sf = scene.FuncContainer;
SceneAction mainSa = scene.Ctor;
StringBuilder sb = new StringBuilder();
sb.AppendLine(Pile.needEncryption
? YuriEncryptor.EncryptString(scene.GetILSign(), Pile.Encryptor)
: scene.GetILSign());
sb.Append(this.ILGenerator(mainSa));
foreach (SceneFunction scenefunc in sf)
{
sb.Append(this.ILGenerator(scenefunc.Ctor));
}
return(sb.ToString());
}
private void Message(SceneAction action, Vector3 position, string message)
{
BGEditorUtility.SwapHandlesColor(new Color32(46, 143, 168, 255), () =>
{
// idea.. some hacker's work that needs to be redone
var error = message.IndexOf(ErrorColor) != -1;
Handles.Label(position, " "
+ "<size=16><b>"
+ BGEditorUtility.ColorIt("Action[", HeaderColor)
+ BGEditorUtility.ColorIt(action.Name, ActionColor)
+ BGEditorUtility.ColorIt("] ", HeaderColor)
+ (error ? ToError("Error") : ToOk("Ok"))
+ "</b></size>\r\n"
+ message, style);
});
}
public static bool ApplyPreviewRenderAction(SceneAction action)
{
bool skipFlag = false;
foreach (var cp in ViewPageManager.PageCallStack)
{
if (cp is RenderablePage)
{
skipFlag = ((RenderablePage)cp).PreviewSceneAction(action);
}
}
if (ViewManager.mWnd?.uiFrame?.Content != null && ViewManager.mWnd?.uiFrame?.Content is RenderablePage)
{
skipFlag = ((RenderablePage)ViewManager.mWnd.uiFrame.Content).PreviewSceneAction(action);
}
return(skipFlag);
}
/// <summary>
/// 将动作序列绑定到一个新的场景函数
/// </summary>
/// <param name="funcSa">动作序列</param>
/// <param name="sceneName">场景名称</param>
/// <returns>场景函数</returns>
private SceneFunction ParseSaToSF(SceneAction funcSa, string sceneName)
{
// 获得函数签名
string signature = funcSa.ArgsDict["sign"];
var signItem = signature.Split(new char[] { '(', ')' }, StringSplitOptions.RemoveEmptyEntries);
var funcParas = new List <string>();
// 如果没有参数就跳过参数遍历
if (signItem.Length > 1)
{
var varItem = signItem[1].Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
funcParas.AddRange(varItem);
}
return(new SceneFunction(signItem[0].Trim(), sceneName, funcSa)
{
Param = funcParas
});
}
/// <summary>
/// 将IL解析为SAP
/// </summary>
private void ProcessIL()
{
this.ilPackageContainer = new Dictionary <string, Dictionary <string, SceneActionPackage> >();
this.iResContainer = new Dictionary <string, Dictionary <string, SceneAction> >();
string currentSceneKey = String.Empty;
foreach (string lineitem in this.splitContianer)
{
// 处理头部
if (lineitem.StartsWith(">>>"))
{
string mycommand = lineitem.Substring(3).Replace("\r\n", String.Empty);
// EOF标记
if (mycommand == "YuriEOF")
{
break;
}
// 场景标记
if (mycommand.StartsWith("YuriIL?"))
{
var commandItem = mycommand.Split('?');
currentSceneKey = commandItem[1];
this.ilPackageContainer.Add(currentSceneKey, new Dictionary <string, SceneActionPackage>());
this.iResContainer.Add(currentSceneKey, new Dictionary <string, SceneAction>());
}
else if (mycommand.StartsWith("YuriAEIL"))
{
var commandItem = mycommand.Split('?');
//GlobalDataContainer.GAME_PROJECT_NAME = commandItem[1];
//GlobalDataContainer.GAME_TITLE_NAME = commandItem[1];
}
}
else
{
// sap
SceneActionPackage sap = this.ParseSceneActionPackage(lineitem);
this.ilPackageContainer[currentSceneKey].Add(sap.saNodeName, sap);
// sa
SceneAction sa = new SceneAction(sap);
this.iResContainer[currentSceneKey].Add(sa.NodeName, sa);
}
}
LogUtils.LogLine("Finished Convert IL to SAP", "YuriIL Convertor", LogLevel.Normal);
}
public ParallelAction(SceneAction action1)
{
AddAction(action1);
}
public void AddAction(SceneAction action)
{
_actions.Add(action);
if (Actor != null)
action.Actor = Actor;
}
public void ForEachScene(SceneAction d)
{
foreach (Scene s in m_Scenes)
d(s);
}
public SequenceAction(SceneAction action1, SceneAction action2)
{
AddAction(action1);
AddAction(action2);
}
public SequenceAction(SceneAction action1)
{
AddAction(action1);
}
