public override void DoEvent(EngineEvent _event)
{
base.DoEvent(_event);
//receiver.SetManager(manager);
receiver.Activate();
}
// Start is called before the first frame update
void Start()
{
healthScript = GameObject.FindGameObjectWithTag("GameHandler").GetComponent <HealthHandler>();
control = GameObject.FindGameObjectWithTag("Player").GetComponent <Control>();
engineScript = GameObject.Find("EngineParent").GetComponent <EngineEvent>();
dialogueScript = GameObject.Find("QuestionHandler").GetComponent <Dialogue>();
}
public void Tick()
{
if (Engine == null)
{
return;
}
if (_commands.Count > 0)
{
_logger.Info("Executing tick with {0} commands.", _commands.Count);
}
var input = new EngineTickInput(_commands);
_commands.Clear();
var tick = Engine.Tick(input);
tick.Start();
tick.Wait();
Engine.Synchronize();
foreach (var resultEvent in tick.Result.Events)
{
EngineEvent?.Invoke(this, new GameEngineEventArgs(resultEvent, Engine));
}
}
public void Notify(EngineEvent engineEvent)
{
switch (engineEvent)
{
case EngineEvent.Play:
this.Play();
break;
case EngineEvent.GameOver:
this.GameOver();
break;
case EngineEvent.Victory:
this.Victory();
break;
case EngineEvent.InvalidMovement:
this.InvalidMovement();
break;
case EngineEvent.PlayerMovement:
this.PlayMovement();
break;
case EngineEvent.PlayerTurnAround:
this.PlayMovement();
break;
}
}
public void Render(EngineEvent evt)
{
void WritePrefix(Package package)
{
var prefix = GetPackagePrefix(package);
Console.Write(prefix);
Console.Write(string.Join("",
Enumerable.Repeat(" ", _packageIdMaxLength - prefix.Length)));
}
switch (evt)
{
case AlreadyUpToDate already:
WritePrefix(already.Package);
Console.WriteLine("already up-to-date");
break;
case Done done:
WritePrefix(done.Package);
Console.WriteLine("done");
break;
case AllDone allDone:
Console.WriteLine("\nOk");
break;
}
}
protected void DispatchEvent(EngineEvent ee, CGObject param1, CGObject param2)
{
foreach (IEngineListener listener in engine_listeners)
{
listener.Act(ee, null, param1, param2);
}
}
public void DispatchEvent(EngineEvent ee, CGObject param1, CGObject param2)
{
foreach (IEngineListener listener in listeners)
{
listener.Act(ee, this, param1, param2);
}
}
protected override void SingletonAwakened()
{
onDifficultyChanges = new EngineEvent();
currentDifficulty = PreferenceManager.Difficulty;
onDifficultyChanges.AddAction(ChangeSettingsVariables);
CurrentPrefab = buttonPrefab;
onDifficultyChanges.Execute();
}
protected virtual void OnEnable()
{
onAnySlide = new EngineEvent();
onDownSlide = new EngineEvent();
onTopSlide = new EngineEvent();
onRightSlide = new EngineEvent();
onLeftSlide = new EngineEvent();
}
// Start is called before the first frame update
void Start()
{
audio = GetComponent <AudioSource>();
beamSpawned = false;
isRunning = false;
engineEvent = GameObject.Find("EngineParent").GetComponent <EngineEvent>();
rocketCount = 0;
levelEnd = false;
}
public override void DoEvent(EngineEvent _event)
{
base.DoEvent(_event);
if (objToUse != null)
{
method.go = objToUse;
method.InvokeMethod();
}
}
public override void DoEvent(EngineEvent _event)
{
base.DoEvent(_event);
var anim = objToUse.GetComponentInChildren <Animator>();
if (anim)
{
anim.CrossFade(state.stringValue, crossfadeTime, state.layer);
}
}
public virtual void Awake()
{
onEndDrag = new EngineEvent();
onBeginDrag = new EngineEvent();
onDrag = new EngineEvent();
onClick = new EngineEvent();
onDown = new EngineEvent();
onUp = new EngineEvent();
targetPosition = new Vector3();
}
public void React(EngineEvent e, params object[] args)
{
if (!_eventHandlers.TryGetValue(e, out var handler))
{
return;
}
var eventArgs = CastParams(e, args);
Task.Run(() => handler.Invoke(eventArgs));
}
public virtual void DoEvent(EngineEvent _event)
{
if (affectedObj == AffectedType.EventAssigned)
{
objToUse = _event.CurTarget;
}
else if (affectedObj == AffectedType.Override)
{
objToUse = overrideObject;
}
}
private SearchEngineEventArgs CastParams(EngineEvent e, object[] args)
{
switch (e)
{
case EngineEvent.FileIndexingStarted:
case EngineEvent.FileRemovingStarted:
case EngineEvent.FileUpdateInitiated:
case EngineEvent.PathWatchingStarted:
case EngineEvent.PathWatchingEnded:
if (args.Length != 1)
{
throw new ArgumentOutOfRangeException(nameof(args), args, "Invalid args count");
}
return(new SearchEngineEventArgs((string)args[0]));
case EngineEvent.FileIndexingEnded:
case EngineEvent.FileRemovingEnded:
if (args.Length < 1 && args.Length > 2)
{
throw new ArgumentOutOfRangeException(nameof(args), args, "Invalid args count");
}
if (args.Length == 1)
{
return(new SearchEngineEventArgs((string)args[0]));
}
return(new SearchEngineEventArgs((string)args[0], (Exception)args[1]));
case EngineEvent.FileUpdateFailed:
if (args.Length != 2)
{
throw new ArgumentOutOfRangeException(nameof(args), args, "Invalid args count");
}
return(new SearchEngineEventArgs((string)args[0], (Exception)args[1]));
case EngineEvent.PathChanged:
if (args.Length != 2)
{
throw new ArgumentOutOfRangeException(nameof(args), args, "Invalid args count");
}
return(new FilePathChangedEventArgs((string)args[0], (string)args[1]));
case EngineEvent.IndexCleanUpFailed:
if (args.Length != 1)
{
throw new ArgumentOutOfRangeException(nameof(args), args, "Invalid args count");
}
return(new SearchEngineEventArgs((Exception)args[0]));
default:
throw new ArgumentOutOfRangeException(nameof(e), e, "Invalid event");
}
}
public void addEvent(EngineEvent newEvent)
{
GameObject gameObject = new GameObject();
EventDebugObject tempObject = gameObject.AddComponent<EventDebugObject>();
tempObject.mStackTrace = Environment.StackTrace;
tempObject.mCommand = newEvent.GetCommandString();
//Debug.Log(newEvent.GetTime().ToString("0.00") + " -> " + tempObject.mCommand);
tempObject.name = newEvent.GetName();
gameObject.transform.parent = transform;
gameObject.transform.localPosition = Vector3.zero;
mEventCount++;
}
void Spawn(EngineEvent _event)
{
var spawn = GameObject.Instantiate(objToSpawn);
var pos = position;
var rot = rotation;
if (positionType == PositionType.SceneObject)
{
var obj = positionObj.GetSceneObject(_event.Source, objToUse);
pos = objToUse.transform.position;
rot = objToUse.transform.rotation.eulerAngles;
}
spawn.transform.position = pos;
spawn.transform.rotation = Quaternion.Euler(rot);
if (setParent)
{
var par = parentObj.GetSceneObject();
spawn.transform.SetParent(par.transform);
}
}
/* (non-Javadoc)
* @see woolfel.engine.rete.EngineEventListener#eventOccurred(woolfel.engine.rete.EngineEvent)
*/
#region EngineEventListener Members
public virtual void eventOccurred(EngineEvent event_Renamed)
{
if (event_Renamed.EventType == EngineEvent.ASSERT_EVENT)
{
asserts.Add(event_Renamed);
}
else if (event_Renamed.EventType == EngineEvent.ASSERT_PROFILE_EVENT)
{
asserts.Add(event_Renamed);
profiles.Add(event_Renamed);
}
else if (event_Renamed.EventType == EngineEvent.ASSERT_RETRACT_EVENT)
{
asserts.Add(event_Renamed);
retracts.Add(event_Renamed);
}
else if (event_Renamed.EventType == EngineEvent.ASSERT_RETRACT_PROFILE_EVENT)
{
asserts.Add(event_Renamed);
profiles.Add(event_Renamed);
retracts.Add(event_Renamed);
}
else if (event_Renamed.EventType == EngineEvent.PROFILE_EVENT)
{
profiles.Add(event_Renamed);
}
else if (event_Renamed.EventType == EngineEvent.RETRACT_EVENT)
{
retracts.Add(event_Renamed);
}
Object val = nodeFilter.Get(event_Renamed.SourceNode);
if (val != null)
{
((List <Object>)val).Add(event_Renamed);
}
}
void EventSwitch(EngineEvent _event)
{
switch (eventType)
{
case CommonEventType.SetActive:
SetActive();
break;
case CommonEventType.Destroy:
Destroy();
break;
case CommonEventType.Spawn:
Spawn(_event);
break;
case CommonEventType.Die:
TryGetUnit(Die);
break;
case CommonEventType.Respawn:
TryGetUnit(Respawn);
break;
case CommonEventType.Lose:
Lose();
break;
case CommonEventType.Win:
Win();
break;
default:
break;
}
}
// method
public void Accelerate(int delta)
{
CurrentSpeed += delta;
if (IsEngineDead)
{
EngineEvent?.Invoke(this, new EngineEventArgs("Engine is dead..."));
}
else
{
if (CurrentSpeed > MaxSpeed)
{
IsEngineDead = true;
EngineEvent?.Invoke(this, new EngineEventArgs("Engine is dead..."));
}
else if (20 >= Math.Abs(MaxSpeed - CurrentSpeed))
{
EngineEvent?.Invoke(this, new EngineEventArgs($"be careful bro! CurrentSpeed: {CurrentSpeed}."));
}
else
{
EngineEvent?.Invoke(this, new EngineEventArgs($"faster is better! CurrentSpeed: {CurrentSpeed}."));
}
}
}
private void SequenceProgress()
{
// 指定された時間が経てば文字列の更新処理
if (currentTime + engineParam.IntervalPrintChar < Time.time)
{
currentTime = Time.time;
if (++currentIndex >= currentMessage.Length)
{
if (nextMessageIndex < allMessage.Length)
{
sequence = Sequence.WaitNextPage;
}
else
{
sequence = Sequence.Complete;
}
}
else if (messageUI != null)
{
if (eventList.Count > 0 && (eventList[0].Index + newlineCount) == currentIndex)
{
EngineEvent engineEvent = eventList[0];
switch (engineEvent.Type)
{
case EngineEventType.Wait:
sequence = Sequence.WaitLittle;
waitTimeStart = Time.time;
waitTime = engineEvent.IntParam;
break;
}
eventList.Remove(engineEvent);
}
messageUI.text = currentMessage.Substring(0, currentIndex);
}
}
}
protected override void FinalizeCycle()
{
base.FinalizeCycle();
History.Push(CurrentEvent);
CurrentEvent = null;
}
public override void DoEvent(EngineEvent _event)
{
base.DoEvent(_event);
EventSwitch(_event);
}
public void RaiseEvent(EngineEvent əvənt)
{
RaiseEvent(əvənt, null);
}
void RaiseEvent(EngineEvent ƐƲƺŋƫ, object data)
{
var args = new EngineEventArgs(ƐƲƺŋƫ, data);
// Invoke used liberally for thread safety
if(Invoker != null && Invoker.IsHandleCreated && Invoker.InvokeRequired)
Invoker.Invoke(Hook, this, args);
else
Hook(this, args);
}
public EngineEventArgs(EngineEvent evənt)
{
_event = evənt;
}
protected override void InitializeRound()
{
base.InitializeRound();
History = new Stack<EngineEvent>();
CurrentEvent = null;
}
protected override void InitializeCycle(int Ip)
{
base.InitializeCycle(Ip);
CurrentEvent = new EngineEvent(core[Ip], cycle, cyclesLeft, Ip, activeWarrior, lastStepResult);
}
protected override void FinalizeRound()
{
base.FinalizeRound();
History = null;
CurrentEvent = null;
}
public void PollEvent()
{
while (SDL_PollEvent(out SDL_Event e) != 0)
{
switch (e.type)
{
case SDL_EventType.SDL_WINDOWEVENT:
switch (e.window.windowEvent)
{
case SDL_WindowEventID.SDL_WINDOWEVENT_CLOSE:
WindowEvent?.Invoke(new InputCallbackEventArg()
{
CallbackType = InputCallbackType.WindowClose
});
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_FOCUS_GAINED:
WindowEvent?.Invoke(new InputCallbackEventArg()
{
CallbackType = InputCallbackType.FocusGained
});
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_FOCUS_LOST:
WindowEvent?.Invoke(new InputCallbackEventArg()
{
CallbackType = InputCallbackType.FocusLost
});
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_EXPOSED:
WindowEvent?.Invoke(new InputCallbackEventArg()
{
CallbackType = InputCallbackType.WindowExposed
});
break;
case SDL_WindowEventID.SDL_WINDOWEVENT_SHOWN:
WindowEvent?.Invoke(new InputCallbackEventArg()
{
CallbackType = InputCallbackType.WindowShown
});
break;
}
break;
case SDL_EventType.SDL_KEYDOWN:
if (_keys.ContainsKey(e.key.keysym.sym))
{
_keys[e.key.keysym.sym] = true;
}
else
{
_keys.Add(e.key.keysym.sym, true);
}
break;
case SDL_EventType.SDL_KEYUP:
if (_keys.ContainsKey(e.key.keysym.sym))
{
_keys[e.key.keysym.sym] = false;
}
else
{
_keys.Add(e.key.keysym.sym, false);
}
break;
case SDL_EventType.SDL_MOUSEBUTTONDOWN:
switch (e.button.button)
{
case (byte)SDL_BUTTON_LEFT:
_leftMB = true;
break;
case (byte)SDL_BUTTON_RIGHT:
_rightMB = true;
break;
case (byte)SDL_BUTTON_MIDDLE:
_middleMB = true;
break;
}
break;
case SDL_EventType.SDL_MOUSEBUTTONUP:
switch (e.button.button)
{
case (byte)SDL_BUTTON_LEFT:
_leftMB = false;
break;
case (byte)SDL_BUTTON_RIGHT:
_rightMB = false;
break;
case (byte)SDL_BUTTON_MIDDLE:
_middleMB = false;
break;
}
break;
case SDL_EventType.SDL_RENDER_DEVICE_RESET:
EngineEvent?.Invoke(new InputCallbackEventArg()
{
CallbackType = InputCallbackType.RenderDeviceReset
});
break;
}
}
}
public EngineEventArgs(EngineEvent evənt, object data)
{
_event = evənt;
_data = data;
}
public void Register(EngineEvent e, SearchEngineEventHandler handler)
{
_eventHandlers.Add(e, handler);
}
// 以下は禁則処理の対応など
// 参考 https://github.com/tsubaki/HyphenationJpn_uGUI/blob/master/Assets/HyphenationJpn.cs
private string GetFormatedText(string msg)
{
if (string.IsNullOrEmpty(msg))
{
return(string.Empty);
}
RectTransform rectTransform = messageUI.rectTransform;
float rectWidth = rectTransform.rect.width;
float spaceCharacterWidth = GetSpaceWidth();
// override
messageUI.horizontalOverflow = HorizontalWrapMode.Overflow;
// work
StringBuilder lineBuilder = new StringBuilder();
StringBuilder originalMessage = new StringBuilder();
float lineWidth = 0;
int skipCount = 0;
int textCount = 0;
int newlineCount = 0;
int eventIndex = 0;
foreach (var originalLine in GetWordList(msg, out skipCount))
{
string newText = lineBuilder.ToString() + originalLine;
if (rectTransform.rect.height <= GetTextHeight(newText))
{
break;
}
lineWidth += GetTextWidth(originalLine);
if (originalLine.IndexOf('\n') >= 0 ||
originalLine == Environment.NewLine)
{
lineWidth = 0;
}
else
{
if (originalLine == " ")
{
lineWidth += spaceCharacterWidth;
}
if (lineWidth > rectWidth)
{
lineBuilder.Append(Environment.NewLine);
lineWidth = GetTextWidth(originalLine);
++newlineCount;
if (rectTransform.rect.height <= GetTextHeight(lineBuilder.ToString()))
{
break;
}
}
}
originalMessage.Append(originalLine);
textCount += originalLine.Length;
// 後で追加された改行の数をカウントして、イベント判定インデックスを進めておく
if (eventList.Count > eventIndex && eventList[eventIndex].Index < textCount)
{
EngineEvent engineEvent = eventList[eventIndex];
engineEvent.Index = engineEvent.Index + (newlineCount * 2);
eventList[eventIndex] = engineEvent;
++eventIndex;
}
lineBuilder.Append(originalLine);
}
nextMessageIndex += originalMessage.Length + skipCount;
return(lineBuilder.ToString());
}
protected override void InitializeCycle(int Ip)
{
base.InitializeCycle(Ip);
CurrentEvent = new EngineEvent(core[Ip], cycle, cyclesLeft, Ip, activeWarrior, lastStepResult);
}
public RegisterEventMessage(object sender, EngineEvent evt) : base(sender)
{
Event = evt;
}
public StepResult PrevStep()
{
if (!CanStepBack)
{
throw new InvalidOperationException("Cannot step back now");
}
EngineEvent e = History.Pop();
cycle = e.Cycles;
cyclesLeft = e.CyclesLeft;
int lastTask = e.Warrior.Tasks.Count;
int liveLastRound = liveWarriors.Count;
if (e.Died)
{
lastTask++;
if (warriors.Count == 0)
{
liveLastRound++;
}
}
if (e.Split)
{
lastTask--;
}
// refill live warriors queue
Queue <EngineWarrior> nlive = new Queue <EngineWarrior>();
nlive.Enqueue(e.Warrior);
for (int w = 0; w < liveLastRound - 1; w++)
{
nlive.Enqueue(liveWarriors.Dequeue());
}
liveWarriors = nlive;
//refill tasks queue
Queue <int> ntasks = new Queue <int>();
ntasks.Enqueue(e.Ip);
for (int t = 0; t < lastTask - 1; t++)
{
ntasks.Enqueue(e.Warrior.Tasks.Dequeue());
}
e.Warrior.Tasks = ntasks;
//rollback core
while (e.instructionsChanged.Count > 0)
{
EngineInstruction ei = e.instructionsChanged.Pop();
core[ei.Address].Operation = ei.Operation;
core[ei.Address].Modifier = ei.Modifier;
core[ei.Address].ModeA = ei.ModeA;
core[ei.Address].ModeB = ei.ModeB;
core[ei.Address].ValueA = ei.ValueA;
core[ei.Address].ValueB = ei.ValueB;
core[ei.Address].OriginalOwner = ei.OriginalOwner;
core[ei.Address].OriginalInstruction = ei.OriginalInstruction;
CoreEventRecord evnt = CoreEvents[ei.Address];
evnt.Event = InstructionEvent.None;
evnt.Cycle = cycle;
evnt.Touched = null;
evnt.Executed = null;
evnt.Read = null;
evnt.Died = null;
evnt.WrittenData = null;
evnt.WrittenInstruction = null;
evnt.Version = ++version;
evnt.Level = CoreEventsLevel.Clean;
}
if (e.PSpaceAddress != -1)
{
PSpaces[e.Warrior.WarriorIndex][e.PSpaceAddress] = e.PSpaceValue;
}
lastStepResult = e.PrevStepResult;
return(e.PrevStepResult);
}
protected override void SingletonAwakened()
{
onLanguageChanged = new EngineEvent();
Load();
}
public void ResolveEngineEventListener(EngineEvent evt)
{
_queue.Add(evt, _uiTaskToken);
}
