public Sequence CreateSequenceFromBase(SequenceBase sequenceBase)
{
Sequence seq = new Sequence();
switch (sequenceBase.SeqType)
{
case SequenceType.Animation:
seq.AttractAnimation = (AttractAnimation)sequenceBase;
break;
case SequenceType.AnimationLayer:
seq.animation_layer = (AttractAnimation)sequenceBase;
break;
case SequenceType.Combo:
seq.Combo = (Combo)sequenceBase;
break;
case SequenceType.Credits:
seq.Credits = (Credits)sequenceBase;
break;
case SequenceType.GroupLayer:
seq.GroupLayer = (GroupLayer)sequenceBase;
break;
case SequenceType.HighScores:
seq.HighScores = (HighScores)sequenceBase;
break;
case SequenceType.LastScores:
seq.LastScores = (LastScores)sequenceBase;
break;
case SequenceType.MarkupLayer:
seq.MarkupLayer = (MarkupLayer)sequenceBase;
break;
case SequenceType.PanningLayer:
seq.panning_layer = (PanningLayer)sequenceBase;
break;
case SequenceType.RandomText:
seq.RandomText = (RandomText)sequenceBase;
break;
case SequenceType.ScriptedText:
seq.ScriptedText = (ScriptedText)sequenceBase;
break;
case SequenceType.TextLayer:
seq.text_layer = (TextLayer)sequenceBase;
break;
default:
break;
}
return(seq);
}
protected override void Start()
{
base.Start();
currentIndex = startIndex;
if (transform.childCount > 0)
{
sequences = new SequenceBase[transform.childCount];
for (int i = 0; i < transform.childCount; i++)
{
SequenceBase sequence = transform.GetChild(i).GetComponent <SequenceBase>();
sequence.sequenceIndex = i;
if (sequence)
{
sequences[i] = sequence;
}
}
}
else
{
Debug.Log("Place the sequences as children of the sequence manager object");
}
//After a certain delay, start the sequence. Remove the delay at the release
Invoke("TempStepActivation", 0.5f);
sequenceFinisedEvent += FinishSequence;
}
/// <summary>
///
/// </summary>
/// <param name="seq_"></param>
public void OpenGraphInNewTab(SequenceBase seq_)
{
foreach (TabItem item in tabControl.Items)
{
if ((item.DataContext as FlowGraphControlViewModel).ID == seq_.Id)
{
tabControl.SelectedItem = item;
return;
}
}
TabItem tab = new TabItem();
FlowGraphControlViewModel fgvm = FlowGraphManager.Instance.GetViewModelByID(seq_.Id);
tab.DataContext = fgvm;
FlowGraphControl fgc = new FlowGraphControl();
fgc.DataContext = fgvm;
tab.Content = fgc;
Binding bind = new Binding("Name");
bind.Source = fgvm;
tab.SetBinding(TabItem.HeaderProperty, bind);
tabControl.SelectedIndex = tabControl.Items.Add(tab);
}
/// <summary>
/// Returns a string containing a C# declaration of the result variable of the sequence (or sequence computation) construct
/// </summary>
public static string DeclareResultVar(SequenceBase seq)
{
if (seq is Sequence)
{
return("bool res_" + seq.Id + ";\n");
}
else
{
return("object res_" + seq.Id + ";\n");
}
}
/// <summary>
/// Returns a string containing a C# assignment to set the result variable of the sequence or sequence computation construct
/// to the value as computed by the C# expression in the string given
/// (every sequence part writes a success-value which is read by other parts determining execution flow)
/// </summary>
public static string SetResultVar(SequenceBase seq, String valueToWrite)
{
if (seq is Sequence)
{
return("res_" + seq.Id + " = (bool)(" + valueToWrite + ");\n");
}
else
{
return("res_" + seq.Id + " = " + valueToWrite + ";\n");
}
}
/// <summary>
///
/// </summary>
/// <param name="seq_"></param>
/// <param name="stack_"></param>
/// <param name="parent_"></param>
public ProcessingContext(SequenceBase seq_, MemoryStackFrameManager stack_, ProcessingContext parent_ = null)
{
State = ProcessingContextState.Stop;
m_FreeCallID++;
CallID = m_FreeCallID;
Parent = parent_;
SequenceBase = seq_;
MemoryStackFrame = stack_;
}
/// <summary>
///
/// </summary>
/// <param name="seq_"></param>
/// <param name="stack_"></param>
/// <param name="parent_"></param>
public ProcessingContext(SequenceBase seq_, MemoryStackFrameManager stack_, ProcessingContext parent_ = null)
{
State = ProcessingContextState.Stop;
m_FreeCallID++;
CallID = m_FreeCallID;
Parent = parent_;
SequenceBase = seq_;
MemoryStackFrame = stack_;
}
/// <summary>
/// Call after Load() to connect nodes each others
/// </summary>
/// <param name="node_"></param>
/// <param name="connectionListNode_"></param>
internal virtual void ResolveLinks(XmlNode connectionListNode_, SequenceBase sequence_)
{
foreach (XmlNode connNode in connectionListNode_.SelectNodes("Connection[@srcNodeID='" + Id + "']"))
{
int outputSlotID = int.Parse(connNode.Attributes["srcNodeSlotID"].Value);
int destNodeID = int.Parse(connNode.Attributes["destNodeID"].Value);
int destNodeInputID = int.Parse(connNode.Attributes["destNodeSlotID"].Value);
SequenceNode destNode = sequence_.GetNodeById(destNodeID);
GetSlotById(outputSlotID).ConnectTo(destNode.GetSlotById(destNodeInputID));
}
}
protected override void OnApplyTemplate()
{
base.OnApplyTemplate();
m_inner_sequence = DataContext as SequenceBase;
m_items = GetTemplateChild("Items") as ItemsControl;
m_items.ItemsSource = m_inner_sequence.Items;
m_border = GetTemplateChild("Border") as Border;
m_border.DragOver += m_inner_sequence.OnDropOver;
m_border.Drop += m_inner_sequence.OnDrop;
}
/// <summary>
///
/// </summary>
/// <param name="seq_"></param>
/// <param name="eventType_"></param>
/// <param name="index_"></param>
/// <param name="param_"></param>
public void LaunchSequence(SequenceBase seq_, Type eventType_, int index_, object param_)
{
MemoryStackFrameManager stackFrames = new MemoryStackFrameManager();
//stackFrames.Clear();
stackFrames.AddStackFrame(); // 1st frame
seq_.AllocateAllVariables(stackFrames.CurrentFrame);
ProcessingContext processContext = new ProcessingContext(seq_, stackFrames);
seq_.OnEvent(processContext, eventType_, index_, param_);
m_CallStacks.Add(processContext);
Resume();
}
protected override void OnApplyTemplate()
{
base.OnApplyTemplate();
items = GetTemplateChild("Sequences") as ListView;
items.SizeChanged += (sender, e) =>
{
if (controller == null || currentScene == null)
{
return;
}
var frameScale = (e.NewSize.Width - borderSize) / currentScene.FrameDuration;
foreach (var sequence in controller.Sequences)
{
sequence.UpdateScale(frameScale);
}
};
items.DragItemsStarting += (sender, e) =>
{
var item = e.Items.FirstOrDefault() as ISequence;
if (item != null)
{
e.Data.Properties.Add("Context", item);
}
};
items.DragOver += (sender, e) => {
e.AcceptedOperation = Windows.ApplicationModel.DataTransfer.DataPackageOperation.Copy;
};
items.Drop += (sender, e) => {
if (controller == null || currentScene == null)
{
return;
}
var seq = new SequenceBase();
seq.Items.Add(new SequenceElementBase(currentScene));
var frameScale = (items.ActualWidth - 40) / currentScene.FrameDuration;
seq.UpdateScale(frameScale);
controller.Sequences.Add(seq);
};
// Получаем слайдер
slider = GetTemplateChild("DurationSlider") as Slider;
slider.ValueChanged += SceneDurationChange;
}
// ================================================================ //
// MonoBehaviour에서 상속.
void Awake()
{
// 시퀀스 모듈이 설정되어 있지 않으면 기본 모듈을 추가한다.
if (this.sequence == null)
{
this.sequence = this.gameObject.AddComponent <SequenceBase>();
}
// Network 클래스 컴포넌트 획득.
GameObject obj = GameObject.Find("Network");
if (obj != null)
{
this.network = obj.GetComponent <Network>();
}
}
/// <summary>
/// 创建一个新的顺序播放器，加到ShowList列表中
/// </summary>
/// <param name="type"></param>
private void NewShow(enumSequenceType type)
{
SequenceBase sequence;
switch (type)
{
case enumSequenceType.e_Sequence_Skill:
case enumSequenceType.e_Sequence_Equip:
sequence = new SequenceShow();
break;
default:
sequence = new SequenceShow();
break;
}
sequence.type = type;
if (this.ShowList.Count == 0)
{
sequence.StartTime = Time.time;
sequence.LastAnimEndTime = Time.time;
}
else
{
SequenceBase curSequence = this.GetCurrentShow();
try
{
sequence.StartTime = curSequence.EndTime + 0.1f;
sequence.LastAnimEndTime = curSequence.LastAnimEndTime;
if (Time.time > sequence.StartTime)
{
sequence.StartTime = Time.time;
}
if (Time.time > sequence.LastAnimEndTime)
{
sequence.LastAnimEndTime = Time.time;
}
}
catch (Exception e)
{
this.m_log.Fatal(e);
}
}
this.ShowList.Add(sequence);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void tabControl_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (SelectedGraphChanged != null)
{
SequenceBase seq = null;
if (tabControl.SelectedItem is TabItem)
{
TabItem item = (tabControl.SelectedItem as TabItem);
if (item.Content is FlowGraphControl)
{
seq = (item.Content as FlowGraphControl).ViewModel.Sequence;
}
}
SelectedGraphChanged(this, new EventArg1Param <SequenceBase>(seq));
}
}
/// <summary>
///
/// </summary>
/// <param name="seq_"></param>
public void OpenGraphInNewTab(SequenceBase seq_)
{
foreach (TabItem item in tabControl.Items)
{
if ((item.DataContext as FlowGraphControlViewModel).ID == seq_.Id)
{
tabControl.SelectedItem = item;
return;
}
}
TabItem tab = new TabItem();
FlowGraphControlViewModel fgvm = FlowGraphManager.Instance.GetViewModelByID(seq_.Id);
tab.DataContext = fgvm;
FlowGraphControl fgc = new FlowGraphControl();
fgc.DataContext = fgvm;
tab.Content = fgc;
Binding bind = new Binding("Name");
bind.Source = fgvm;
tab.SetBinding(TabItem.HeaderProperty, bind);
tabControl.SelectedIndex = tabControl.Items.Add(tab);
}
public static CombatGameState GetCombat(this SequenceBase s)
{
return(null);
}
/// <summary>
///
/// </summary>
public FlowGraphControlViewModel(SequenceBase seq_) :
this()
{
Sequence = seq_;
}
/// <summary>
///
/// </summary>
public FlowGraphControlViewModel(SequenceBase seq_)
: this()
{
Sequence = seq_;
}
/// <summary>
///
/// </summary>
/// <param name="seq_"></param>
/// <param name="stack_"></param>
/// <param name="slot_"></param>
public ProcessingContextStep(SequenceBase seq_, MemoryStack stack_, NodeSlot slot_)
{
SequenceBase = seq_;
MemoryStack = stack_;
Slot = slot_;
}
/// <summary>
/// Returns a string containing a C# expression to get the value of the result variable of the sequence or sequence computation construct
/// (every sequence part writes a success-value which is read by other parts determining execution flow)
/// </summary>
public static string GetResultVar(SequenceBase seq)
{
return("res_" + seq.Id);
}
/// <summary>
///
/// </summary>
/// <param name="seq_"></param>
/// <param name="eventType_"></param>
/// <param name="index_"></param>
/// <param name="param_"></param>
public void LaunchSequence(SequenceBase seq_, Type eventType_, int index_, object param_)
{
MemoryStackFrameManager stackFrames = new MemoryStackFrameManager();
//stackFrames.Clear();
stackFrames.AddStackFrame(); // 1st frame
seq_.AllocateAllVariables(stackFrames.CurrentFrame);
ProcessingContext processContext = new ProcessingContext(seq_, stackFrames);
seq_.OnEvent(processContext, eventType_, index_, param_);
m_CallStacks.Add(processContext);
Resume();
}
/// <summary>
///
/// </summary>
/// <param name="seq_"></param>
/// <param name="eventType_"></param>
public void RegisterNextSequence(SequenceBase seq_, Type eventType_, object param_)
{
CurrentProcessingContext.MemoryStackFrame.AddStackFrame();
seq_.AllocateAllVariables(CurrentProcessingContext.MemoryStackFrame.CurrentFrame);
seq_.OnEvent(this, eventType_, 0, param_);
}
/// <summary>
///
/// </summary>
/// <param name="seq_"></param>
/// <param name="eventType_"></param>
public void RegisterNextSequence(SequenceBase seq_, Type eventType_, object param_)
{
CurrentProcessingContext.MemoryStackFrame.AddStackFrame();
seq_.AllocateAllVariables(CurrentProcessingContext.MemoryStackFrame.CurrentFrame);
seq_.OnEvent(this, eventType_, 0, param_);
}
public GroupLayer(SequenceBase sequenceBase) : base()
{
}
public SequenceItemViewModel(SequenceBase sequence)
{
Sequence = sequence;
Sequence.SequenceName = Sequence.SeqType + "SequenceStyle";
}
/// <summary>
///
/// </summary>
/// <param name="connectionListNode_"></param>
/// <param name="sequence_"></param>
internal override void ResolveLinks(XmlNode connectionListNode_, SequenceBase sequence_)
{
GetScriptElement();
base.ResolveLinks(connectionListNode_, sequence_);
}
/// <summary>
/// Call after Load() to connect nodes each others
/// </summary>
/// <param name="node_"></param>
/// <param name="connectionListNode_"></param>
internal virtual void ResolveLinks(XmlNode connectionListNode_, SequenceBase sequence_)
{
foreach (XmlNode connNode in connectionListNode_.SelectNodes("Connection[@srcNodeID='" + Id + "']"))
{
int outputSlotID = int.Parse(connNode.Attributes["srcNodeSlotID"].Value);
int destNodeID = int.Parse(connNode.Attributes["destNodeID"].Value);
int destNodeInputID = int.Parse(connNode.Attributes["destNodeSlotID"].Value);
SequenceNode destNode = sequence_.GetNodeById(destNodeID);
GetSlotById(outputSlotID).ConnectTo(destNode.GetSlotById(destNodeInputID));
}
}
/// <summary>
///
/// </summary>
/// <param name="connectionListNode_"></param>
/// <param name="sequence_"></param>
internal override void ResolveLinks(XmlNode connectionListNode_, SequenceBase sequence_)
{
GetScriptElement();
base.ResolveLinks(connectionListNode_, sequence_);
}
