public OutcomeScriptMethodProvider(IList <string> outcomes)
{
_setOutcomeMethod = new ScriptMethod
{
Name = "setOutcome", Method = serviceProvider => (Action <string>)(name => outcomes.Add(name))
};
}
public bool ExecuteSrc()
{
var child = new ScriptMethod(_src, method);
bool bReturn = false;
ScriptValue result = ScriptValue.NULL;
return(child.Execute(null, out bReturn, out result));
}
public void AddMethod(ScriptMethod Method, String Name)
{
if (!Name.StartsWith("."))
{
Name = "." + Name;
}
EngineMethods.Add(Name, Method);
}
public VMFunction(string src, VMFunction parent = null)
{
if (parent != null)
{
_scriptMethod = new ScriptMethod(src, parent._scriptMethod);
}
else
{
_scriptMethod = new ScriptMethod(src);
}
}
public override void AddProperty(ScriptProperty property)
{
var get = property.GetMethod;
get = new ScriptMethod(get.Alias, get.TypeName, get.Parameters.Copy(), get.DeclaringType, get.ScriptLines, InnerScope, true, get.Access, get.Usage, get.ScriptTrace);
var set = property.SetMethod;
set = new ScriptMethod(set.Alias, set.TypeName, set.Parameters.Copy(), set.DeclaringType, set.ScriptLines, InnerScope, true, set.Access, set.Usage, set.ScriptTrace);
property = new ScriptProperty(property.Alias, property.TypeName, get, set, property.Access, property.Usage, property.DeclaringType, property.ScriptTrace, InnerScope);
Properties.Add(property.Alias, (property.GetFunc, property.SetFunc));
}
public CompiledScript(string script)
{
if (script.Contains("METHODSTART"))
{
}
else
{
ScriptMethod method = ScriptMethod.GetScriptMethod(Name, script);
Methods.Add(method);
}
}
public ScriptUsing Clone()
{
var ret = ScriptMethod.NewMethodForUsing(_method);
if (ret != null)
{
var su = New();
su.SetScriptMethod(ret);
return(su);
}
return(null);
}
public WorkflowScriptMethodsProvider(WorkflowExecutionContext workflowContext)
{
_workflowMethod = new ScriptMethod
{
Name = "workflow", Method = serviceProvider => (Func <object>)(() => workflowContext)
};
_workflowIdMethod = new ScriptMethod
{
Name = "workflowId",
Method = serviceProvider => (Func <string>)(() => workflowContext.Workflow.WorkflowId)
};
_inputMethod = new ScriptMethod
{
Name = "input",
Method = serviceProvider => (Func <string, object>)(name => workflowContext.Input[name])
};
_outputMethod = new ScriptMethod
{
Name = "output",
Method = serviceProvider =>
(Action <string, object>)((name, value) => workflowContext.Output[name] = value)
};
_propertyMethod = new ScriptMethod
{
Name = "property",
Method = serviceProvider => (Func <string, object>)((name) => workflowContext.Properties[name])
};
_setPropertyMethod = new ScriptMethod
{
Name = "setProperty",
Method = serviceProvider =>
(Action <string, object>)((name, value) => workflowContext.Properties[name] = value)
};
_resultMethod = new ScriptMethod
{
Name = "lastResult", Method = serviceProvider => (Func <object>)(() => workflowContext.LastResult)
};
_correlationIdMethod = new ScriptMethod
{
Name = "correlationId",
Method = serviceProvider => (Func <string>)(() => workflowContext.Workflow.CorrelationId)
};
}
public VarFunction(Access access, Usage usage, string objectName, Compiler.Scope scope, ScriptMethod function) :
base(access, usage, objectName, scope)
{
GamePath = $"{Program.Datapack.Name}:{function.Alias.Replace('\\', '/')}";
FolderPath = $"{Program.Datapack.Name}:{function.FullAlias}.mcfunction";
ScriptMethod = function;
Methods.Add("Invoke", (arguments) => {
Parameters.Grab(arguments);
new Spy(null, (function) => {
//for(int i = 0; i < arguments.Count; i++) arguments[i].Value.WriteCopyTo(Compiler.FunctionStack.Peek(), Parameters[i].Value);
function.WriteLine($"function {GamePath}");
}, null);
return(null);
});
}
public static bool Execute(string ifSrc, ScriptMethod space, out bool result)
{
result = false;
var tempSrc = ifSrc.Trim();
int fpbPos = tempSrc.IndexOf(Grammar.FPB);
int fpePos = tool.GrammarTool.ReadPairSignPos(tempSrc, fpbPos + 1, Grammar.FPB, Grammar.FPE);
if (fpbPos == -1 || fpbPos >= fpePos)
{
Logger.Error(tempSrc);
return(false);
}
var nameSrc = tempSrc.Substring(0, fpbPos).Trim();
if (nameSrc != Grammar.IF)
{
Logger.Error(tempSrc);
return(false);
}
var srcCondition = tempSrc.Substring(fpbPos + 1, fpePos - fpbPos - 1).Trim();
if (string.IsNullOrEmpty(srcCondition))
{
Logger.Error(tempSrc);
return(false);
}
ScriptValue tempValue = null;
if (!ScriptMethodCall.Execute(srcCondition, space, out tempValue))
{
if (!ScriptExpression.Execute(srcCondition, space, out tempValue))
{
Logger.Error(tempSrc);
return(false);
}
}
if (tempValue.GetValueType() != ScriptValueType.Bool)
{
Logger.Error(tempSrc);
return(false);
}
result = (bool)tempValue.GetValue();
return(true);
}
public void Run(long time, long tries)
{
MessageSender.CacheAssemblieMessages(typeof(MessA).Assembly);
MessA messa = new MessA();
ScriptMethod del = new ScriptMethod("Method2");
del.TrackInstance(messa);
long dC = 0, mC = 0, sM = 0;
for (int i = 0; i < tries; i++)
{
dC += Take_Time(time, (num, m) => m.Method2());
mC += Take_Time(time, (num, m) => MessageSender.SendMessage(m, "Method2", null, MessageOptions.DontRequireReceiver));
sM += Take_Time(time, (num, m) => del.Method.Invoke());
}
Console.WriteLine("Direct_Call mean: " + ((decimal)dC / (decimal)tries));
Console.WriteLine("Message_Call mean: " + ((decimal)mC / (decimal)tries));
Console.WriteLine("ScripMethod_Call mean: " + ((decimal)sM / (decimal)tries));
Console.WriteLine("The ratio of calls is: " + ((decimal)mC / (decimal)dC));
}
/// <inheritdoc />
protected override void Format(IScriptToken token, StringBuilder resulttext, IFormatterCollection formatters, int depth = 0)
{
ScriptMethod method = (ScriptMethod)token;
formatters[method.Host].FormatToken(method.Host, resulttext, formatters, depth);
if (method.MethodName != "invoke")
{
resulttext.Append('.').Append(method.MethodName);
}
resulttext.Append('(');
if (method.Parameters.Any())
{
foreach (IScriptToken parameter in method.Parameters)
{
formatters[parameter].FormatToken(parameter, resulttext, formatters, depth);
resulttext.Append(", ");
}
resulttext.Length -= 2;
}
resulttext.Append(')');
}
static void Parse(string value)
{
var json = JsonConvert.DeserializeObject <JToken>(value);
var comments = json.FindTokens("comment");
ScriptModule module = null;
foreach (var comment in comments)
{
var attributes = comment["attributes"] as JObject;
if (attributes == null)
{
continue;
}
var brief = (comment["brief"] ?? "").ToString();
var full = (comment["full"] ?? "").ToString();
if (attributes.ContainsKey("scriptModule"))
{
var scriptModule = attributes["scriptModule"];
var name = scriptModule.ToString();
if (!name.Contains('/'))
{
name = "FuseJS/" + name;
}
module = GetModule(name);
module.Documentation = full;
}
if (attributes.ContainsKey("scriptMethod"))
{
var scriptMethod = attributes["scriptMethod"];
var result = new ScriptMethod {
Name = scriptMethod["name"].ToString(), Documentation = full
};
module.Methods.Add(result);
foreach (var parameter in scriptMethod["parameters"])
{
result.Parameters.Add(parameter.ToString());
}
}
if (attributes.ContainsKey("scriptProperty"))
{
var scriptProperty = attributes["scriptProperty"];
var result = new ScriptProperty {
Name = scriptProperty.ToString(), Documentation = full
};
// Extract type and docs
if (result.Name.StartsWith("("))
{
var i = result.Name.IndexOf(')', 1);
result.Type = result.Name.Substring(1, i - 1);
var parts = result.Name.Substring(i + 1).Trim().Split(' ');
result.Name = parts[0];
result.Documentation = string.Join(" ", parts.Skip(1));
}
// Skip duplicates
if (module.Properties.Any(p => p.Name == result.Name))
{
continue;
}
module.Properties.Add(result);
}
if (attributes.ContainsKey("scriptEvent"))
{
var scriptEvent = attributes["scriptEvent"];
var result = new ScriptEvent {
Name = scriptEvent.ToString(), Documentation = brief
};
module.Events.Add(result);
}
}
}
public override void AddMethod(ScriptMethod method)
{
Methods.Add(method.Alias, method.Delegate);
}
public void Clear()
{
_src = "";
method = new ScriptMethod("");
}
public VMFunction(ScriptMethod method)
{
_scriptMethod = method;
}
/// <summary>
/// visits a indexer token
/// </summary>
/// <param name="method">token to visit</param>
public virtual void VisitMethod(ScriptMethod method)
{
VisitToken(method.Host);
VisitParameters(method);
}
public void SetScriptMethod(ScriptMethod method)
{
_method = method;
}
public ScriptMethodReference(ScriptMethod method)
{
var attr = method.Method.GetCustomAttribute <ScriptMethodAttribute>();
this.id = attr.Id;
}
public override void AddMethod(ScriptMethod method) => throw new NotImplementedException();
public void GenerateScript(Chapter chapter)
{
script = new UnityScript(ScriptType.Main);
state = new UnityScript(ScriptType.Main);
state.ScriptName = Config.GlobalStateClass;
script.Using.Add("System.Collections.Generic");
ScriptMethod camMethod = new ScriptMethod(Settings.CameraDefault);
script.Methods.Add(camMethod);
camMethod.IsStatic = true;
camMethod.CodeChunks.Add(new CodeChunk(1, new ScriptCameraDefault().ToString()));
#region Scenes
foreach (var scene in chapter.Scenes)
{
ScriptMethod method = new ScriptMethod(scene.SceneId);
script.Methods.Add(method);
method.Name = scene.Id;
method.IsMenuItem = true;
method.IsStatic = true;
method.CodeChunks.Add(new CodeChunk(1, script.GetMethod(Settings.CameraDefault).GetCall()));
UnityScript activity = new UnityScript(ScriptType.Activity);
activity.ScriptName = scene.Id + "Background0";
activityScripts.Add(activity);
var update = activity.GetMethod(Unity.MethodUpdate);
var start = activity.GetMethod(Unity.MethodStart);
var onGui = activity.GetMethod(Unity.MethodOnGUI);
#region Resources
foreach (var res in scene.Resources)
{
string resId = scene.Resources.IndexOf(res).ToString();
var existingActivity = activityScripts.Where(x => x.ScriptName == scene.Id + "Background" + resId);
var rActivity = existingActivity.Count() != 0 ? existingActivity.First() : new UnityScript(ScriptType.Activity);
var rStart = rActivity.GetMethod(Unity.MethodStart);
var rUpdate = rActivity.GetMethod(Unity.MethodUpdate);
if (existingActivity.Count() == 0)
{
activityScripts.Add(rActivity);
rActivity.ScriptName = scene.Id + "Background" + resId;
}
foreach (Asset asset in res.Assets)
{
if (asset.Type == Element.AssetBackground)
{
method.CodeChunks.Add(new CodeChunk(1, new ScriptBackground(resId, asset.UriUnityFormat).ToString()));
method.CodeChunks.Add(new CodeChunk(1, CodeUtility.GameObjectAddComponent("bg" + resId.ToString(), rActivity.ScriptName)));
if (res.Condition != null)
{
DeclareConditionProperties(res.Condition);
}
rUpdate.CodeChunks.Add(new CodeChunk(100, new ScriptVisibility(IfGenerator.Generate(res.Condition)).ToString()));
}
if (asset.Type == Element.AssetBackgroundMusic)
{
rActivity.Properties.Add(new ScriptProperty("bgMusic", "AudioSource", false));
rStart.CodeChunks.Add(new CodeChunk(1, new ScriptBackgroundMusicInit(asset.UriUnityFormat).ToString()));
rUpdate.CodeChunks.Add(new CodeChunk(100, new ScriptBackgroundMusicControl(IfGenerator.Generate(res.Condition)).ToString()));
}
}
}
#endregion
#region Exits
foreach (var exit in scene.Exits)
{
if (exit.Effect != null)
{
GenerateEffect(activity, exit.Effect);
}
if (exit.Condition != null)
{
DeclareConditionProperties(exit.Condition);
}
var exitId = scene.Exits.IndexOf(exit).ToString();
activity.AddProperty(new ScriptProperty("OverExit" + exitId, "bool"));
onGui.CodeChunks.Add(new CodeChunk(1, new ScriptOverExit(exit.MouseOverDescription, exitId).ToString()));
#region Target Scene/SlideScene
if (exit.TargetObject is Scene)
{
ScriptExit scriptExit;
if (exit.Effect != null)
{
scriptExit = new ScriptExit(exit, exitId, GenerateSetFlags(exit.Effect));
}
else
{
scriptExit = new ScriptExit(exit, exitId);
}
if (exit.TargetObjectId == scene.Id)
{
scriptExit.SceneDoesntChange = true;
}
update.CodeChunks.Add(new CodeChunk(1, scriptExit.ToString()));
}
else if (exit.TargetObject is SlideScene)
{
update.CodeChunks.Add(new CodeChunk(1, new ScriptExitToSlideScene(exit, exitId).ToString()));
var triggerSS = (SlideScene)exit.TargetObject;
activity.AddProperty(new ScriptProperty(triggerSS.PropertyActive, "bool"));
activity.AddProperty(new ScriptProperty(triggerSS.PropertyStarted, "bool"));
var scriptSsStarted = new ScriptSlideSceneStarted(triggerSS.Id, script.ScriptName).ToString();
var scriptSsActive = new ScriptSlideSceneActive(triggerSS.Id, script.ScriptName).ToString();
update.CodeChunks.Add(new CodeChunk(10, scriptSsStarted));
update.CodeChunks.Add(new CodeChunk(10, scriptSsActive));
}
#endregion
}
#endregion
#region ActiveAreas
foreach (var area in scene.ActiveAreas)
{
foreach (var action in area.Actions)
{
var actionId = "Use";
var actionType = ActionTypes.Use;
if (action is Custom)
{
actionType = ActionTypes.Custom;
actionId = "Custom";
}
else if (action is TalkTo)
{
actionType = ActionTypes.TalkTo;
actionId = "TalkTo";
}
else if (action is Examine)
{
actionType = ActionTypes.Examine;
actionId = "Examine";
}
var areaActionId = area.Id + actionId;
activity.AddProperty(new ScriptProperty(areaActionId + "GuiPosition", "Vector3"));
activity.AddProperty(new ScriptProperty(areaActionId + "GuiActive", "bool"));
var payloadActions = GenerateSetFlags(action.Effect);
activity.AddProperty(new ScriptProperty("OverExit" + areaActionId, "bool"));
onGui.CodeChunks.Add(new CodeChunk(1, new ScriptOverExit(area.Description.Name, areaActionId).ToString()));
onGui.CodeChunks.Add(new CodeChunk(1, new ScriptShowGui(areaActionId, payloadActions, actionType).ToString()));
if (area.Transform != null)
{
update.CodeChunks.Add(new CodeChunk(10, new ScriptActivateGuiConditioned(areaActionId, area.Transform).ToString()));
}
else
{
update.CodeChunks.Add(new CodeChunk(10, new ScriptActivateGui(areaActionId).ToString()));
}
}
//if (area.Use != null)
//{
// activity.AddProperty(new ScriptProperty(area.Id + "GuiPosition", "Vector3"));
// activity.AddProperty(new ScriptProperty(area.Id + "GuiActive", "bool"));
// var payloadActions = GenerateSetFlags(area.Use.Effect);
// if (area.Use.Effect != null)
// {
// GenerateEffect(activity, area.Use.Effect);
// if (area.Use.Effect.SpeakPlayer.Count != 0) payloadActions += CodeUtility.SetVar(area.Use.Effect.SpeakPlayer[0].Id, true);
// }
// var triggerSS = area.Use.Effect.TriggerSlideScene;
// if (triggerSS != null)
// {
// payloadActions += CodeUtility.SetVar(triggerSS.PropertyActive, true);
// AddSlideScene(activity, triggerSS);
// }
// var triggerS = area.Use.Effect.TriggerScene;
// if (triggerS != null) payloadActions += CodeUtility.SceneLoad(triggerS.Id);
// activity.AddProperty(new ScriptProperty("OverExit" + area.Id, "bool"));
// onGui.CodeChunks.Add(new CodeChunk(1, new ScriptOverExit(area.Description.Name, area.Id).ToString()));
// onGui.CodeChunks.Add(new CodeChunk(1, new ScriptShowGui(area.Id, payloadActions).ToString()));
// if (area.Transform != null) update.CodeChunks.Add(new CodeChunk(10, new ScriptActivateGuiConditioned(area.Id, area.Transform).ToString()));
// else update.CodeChunks.Add(new CodeChunk(10, new ScriptActivateGui(area.Id).ToString()));
//}
}
#endregion
#region Objects
foreach (var obj in scene.Objects)
{
Transform boundingBox = new Transform();
#region Resources
foreach (var res in obj.TargetObject.Resources)
{
foreach (var asset in res.Assets)
{
if (asset.Type == "image")
{
var imgPath = Path.GetDirectoryName(xmlRootPath) + "\\" + asset.Uri;
var imageId = Path.GetFileNameWithoutExtension(asset.Uri);
var gameObject = imageId + "Image";
if (obj.Layer == 2)
{
Transform bBox = new Transform();
boundingBox = bBox;
var h = PngUtility.GetHeight(imgPath);
var w = PngUtility.GetWidth(imgPath);
bBox.Height = h;
bBox.Width = w;
bBox.X = obj.X - w;
bBox.Y = obj.Y - h;
method.CodeChunks.Add(new CodeChunk(1, new ScriptObjectImage(imageId, asset.UriUnityFormat).ToString()));
}
else
{
boundingBox = PngUtility.GetBoundingBox((Bitmap)Bitmap.FromFile(imgPath));
method.CodeChunks.Add(new CodeChunk(1, new ScriptObjectImage(imageId, asset.UriUnityFormat).ToString()));
}
script.AddProperty(new ScriptProperty(gameObject, "GameObject", true));
UnityScript oBehavior = new UnityScript(ScriptType.Activity);
oBehavior.ScriptName = imageId + "Behaviour";
activityScripts.Add(oBehavior);
var oUpdate = oBehavior.GetMethod(Unity.MethodUpdate);
var visibilityCondition = res.Condition == null ? obj.Condition : res.Condition;
oUpdate.CodeChunks.Add(new CodeChunk(10, new ScriptVisibility(IfGenerator.Generate(visibilityCondition)).ToString()));
method.CodeChunks.Add(new CodeChunk(0, CodeTemplate.GameObjectAddComponent.Replace("{object}", gameObject).Replace("{component}", oBehavior.ScriptName)));
DeclareConditionProperties(res.Condition);
DeclareConditionProperties(obj.Condition);
}
}
}
#endregion
#region Actions
var targetObject = obj.TargetObject;
foreach (var action in targetObject.Actions)
{
activity.Properties.Add(new ScriptProperty(targetObject.Id + "GuiPosition", "Vector3"));
activity.Properties.Add(new ScriptProperty(targetObject.Id + "GuiActive", "bool"));
string payloadActions = String.Empty;
foreach (var setFlag in action.Effect.SetFlags.Actives)
{
payloadActions += CodeUtility.SetVar(setFlag.ToString(), true) + "\r\n";
}
foreach (var setFlag in action.Effect.SetFlags.Inactives)
{
payloadActions += CodeUtility.SetVar(setFlag.ToString(), false) + "\r\n";
}
DeclareConditionProperties(action.Effect.SetFlags);
activity.AddProperty(new ScriptProperty("OverExit" + targetObject.Id, "bool"));
onGui.CodeChunks.Add(new CodeChunk(1, new ScriptShowGui(targetObject.Id, payloadActions).ToString()));
update.CodeChunks.Add(new CodeChunk(1, new ScriptActivateGuiConditioned(targetObject.Id, boundingBox).ToString()));
}
if (obj.TargetObject.Use != null)
{
activity.Properties.Add(new ScriptProperty(targetObject.Id + "GuiPosition", "Vector3"));
activity.Properties.Add(new ScriptProperty(targetObject.Id + "GuiActive", "bool"));
var triggerSS = targetObject.Use.Effect.TriggerSlideScene;
var payloadActions = GenerateSetFlags(targetObject.Use.Effect);
if (triggerSS != null)
{
payloadActions += CodeUtility.SetVar(triggerSS.PropertyActive, true);
}
activity.AddProperty(new ScriptProperty("OverExit" + targetObject.Id, "bool"));
onGui.CodeChunks.Add(new CodeChunk(1, new ScriptShowGui(targetObject.Id, payloadActions).ToString()));
update.CodeChunks.Add(new CodeChunk(1, new ScriptActivateGuiConditioned(targetObject.Id, boundingBox).ToString()));
if (triggerSS != null)
{
AddSlideScene(activity, triggerSS);
}
}
#endregion
#region Over
activity.AddProperty(new ScriptProperty(obj.TargetObject.PropertyOver, "bool"));
onGui.CodeChunks.Add(new CodeChunk(5, new ScriptOverObject(obj.TargetObject.Description.ToString(), obj.TargetObject.PropertyOver).ToString()));
update.CodeChunks.Add(new CodeChunk(5, new ScriptIsOver(obj.TargetObject.PropertyOver, boundingBox).ToString()));
#endregion
}
#endregion
#region Conversations
foreach (var conv in scene.Conversations)
{
foreach (var node in conv.Nodes)
{
if (node is DialogueNode)
{
var dialogue = (DialogueNode)node;
var endEffect = node.EndEffect;
if (endEffect != null)
{
var triggerSS = endEffect.TriggerSlideScene;
if (triggerSS != null)
{
AddSlideScene(activity, triggerSS);
}
}
if (dialogue.EndEffect != null)
{
update.CodeChunks.Add(new CodeChunk(5, new ScriptExecuteEffect(dialogue.EndEffect, dialogue.PropertyEndEffect).ToString()));
activity.AddProperty(new ScriptProperty(dialogue.PropertyEndEffect, "bool"));
if (!dialogue.EndEffect.SetFlags.IsEmpty)
{
DeclareConditionProperties(dialogue.EndEffect.SetFlags);
}
}
foreach (var speak in dialogue.Dialogue)
{
activity.AddProperty(new ScriptProperty(speak.Id, "bool"));
string nextSpeak = null;
if (dialogue.Dialogue.Last() == speak)
{
if (dialogue.NextNodeId != null)
{
var nextNode = conv.Nodes.Single(x => x.NodeIndex == dialogue.NextNodeId);
if (nextNode is OptionNode)
{
nextSpeak = ((OptionNode)nextNode).Id;
}
else
{
nextSpeak = ((DialogueNode)nextNode).Dialogue[0].Id;
}
}
}
else
{
nextSpeak = dialogue.Dialogue[dialogue.Dialogue.IndexOf(speak) + 1].Id;
}
if (dialogue.Dialogue.Last() == speak)
{
update.CodeChunks.Add(new CodeChunk(8, new ScriptConversationSpeak(speak.Id, nextSpeak, dialogue.PropertyEndEffect).ToString()));
}
else
{
update.CodeChunks.Add(new CodeChunk(8, new ScriptConversationSpeak(speak.Id, nextSpeak).ToString()));
}
onGui.CodeChunks.Add(new CodeChunk(1, new ScriptGuiConversationSpeak(speak).ToString()));
}
}
else
{
var option = (OptionNode)node;
activity.AddProperty(new ScriptProperty(option.Id, "bool"));
onGui.CodeChunks.Add(new CodeChunk(1, new ScriptGuiOptionNode(option).ToString()));
}
}
}
#endregion
#region Characters
//foreach (var sChar in scene.Characters)
//{
// update.CodeChunks.Add(new CodeChunk(100, new ScriptVisibility(IfGenerator.Generate(sChar.Condition)).ToString()));
// foreach (var asset in sChar.Character.Assets)
// {
// if(asset.Type == Element.AssetStandUp)
// {
// var imageId = Path.GetFileNameWithoutExtension(asset.Uri);
// var gameObject = imageId + "Image";
// PngUtility.GetBoundingBox((Bitmap)Bitmap.FromFile(Path.GetDirectoryName(xmlRootPath) + "\\" + asset.Uri + "_01.png"));
// script.Properties.Add(new ScriptProperty(gameObject, "GameObject", true));
// method.CodeChunks.Add(new CodeChunk(1, new ScriptObjectImage(imageId, asset.Uri).ToString()));
// }
// }
//}
#endregion
}
#endregion
#region SlideScenes
foreach (var ss in chapter.SlideScenes)
{
script.Properties.Add(new ScriptProperty("slides" + ss.Id, "List<GameObject>", true));
ScriptMethod method = new ScriptMethod("StartSlideScene" + ss.Id);
script.Methods.Add(method);
method.IsStatic = true;
method.IsPublic = true;
string payload = "";
payload = CodeTemplate.InitSlideList.Replace("{id}", ss.Id) + "\r\n";
int sn = 1;
foreach (var slide in ss.Slides)
{
payload += new ScriptAddSlideScene(ss.Id, sn, slide.Uri).ToString() + "\r\n";
sn++;
}
method.CodeChunks.Add(new CodeChunk(1, payload));
ScriptMethod next = new ScriptMethod("NextSlideScene" + ss.Id);
script.Methods.Add(next);
next.Returns = ReturnType.Int;
next.IsStatic = true;
next.IsPublic = true;
next.CodeChunks.Add(new CodeChunk(1, new ScriptNextSlideScene(ss.Id).ToString()));
}
#endregion
#region Output writer
StreamWriter sw;
sw = new StreamWriter("UnityScripts/" + state.ScriptName + ".cs");
sw.Write(state.Generate());
sw.Close();
sw = new StreamWriter("UnityScripts/" + script.ScriptName + ".cs");
sw.Write(script.Generate());
sw.Close();
foreach (var item in activityScripts)
{
sw = new StreamWriter("UnityScripts/" + item.ScriptName + ".cs");
sw.Write(item.Generate());
sw.Close();
}
#endregion
#region Unity project
UnityProjectUtility.CreateUnityProject(chapter, xmlRootPath);
#endregion
}
public void SetScriptMethod(string src)
{
_method = new ScriptMethod(src);
}
//////////////////////////////////////////////////////////////////////////
private void WriteHtmlMethodDetailed(StreamWriter sw, ScriptMethod Method, string Suffix)
{
string MethodName = GetBracketName(Method.Headers[0]);
sw.WriteLine("<hr>");
// headers
sw.Write("<h3>");
for (int i = 0; i < Method.Headers.Count; i++)
{
if (i == 0)
{
sw.Write("<a name=\"" + MethodName + Suffix + "\"></a>");
}
else
{
sw.Write("<br>");
}
sw.Write(Method.Headers[i]);
}
sw.WriteLine("</h3>");
// description
sw.WriteLine("<p>" + Method.Desc + "</p>");
// params
if (Method.Parameters.Count > 0)
{
sw.WriteLine("<h4>" + TxtTermParameters.Text + "</h4>");
sw.WriteLine("<dl>");
foreach (ScriptParameter Param in Method.Parameters)
{
sw.WriteLine("<dt><i>" + Param.Name + "</i></dt>");
sw.WriteLine("<dd>" + Param.Desc + "</dd>");
}
sw.WriteLine("</dl>");
}
// return
if (Method.Return != "")
{
sw.WriteLine("<h4>" + TxtTermReturn.Text + "</h4>");
sw.WriteLine("<p>" + Method.Return + "</p>");
}
// remarks
if (Method.Remark != "")
{
sw.WriteLine("<h4>" + TxtTermRemarks.Text + "</h4>");
sw.WriteLine("<p>" + Method.Remark + "</p>");
}
// examples
if (Method.Examples.Count > 0)
{
int i = 0;
foreach (string Example in Method.Examples)
{
i++;
sw.Write("<h4>" + TxtTermExample.Text);
if (Method.Examples.Count > 1)
{
sw.Write(" " + i.ToString());
}
sw.WriteLine("</h4>");
sw.WriteLine("<table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" width=\"100%\">");
sw.WriteLine("<tr>");
sw.WriteLine("<td class=\"code\"><pre>");
sw.WriteLine(Example);
sw.WriteLine("</pre></td>");
sw.WriteLine("</tr>");
sw.WriteLine("</table>");
}
}
sw.WriteLine();
}
