private static StateMachine?ReflectSM(IParseQueue q)
{
string method = q.Scan();
if (method == "file")
{
q.Advance();
return(StateMachineManager.FromName(q.Next()));
}
else if (method == "null")
{
q.Advance();
return(null);
}
else if (method == "stall")
{
q.Advance();
return(WaitForPhaseSM);
}
else
{
var line = q.GetLastLine();
try {
return(StateMachine.Create(q));
} catch (Exception ex) {
throw new SMException($"Nested StateMachine construction starting on line {line} failed.", ex);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ActorUnitTestingRuntime"/> class.
/// </summary>
internal ActorUnitTestingRuntime(Configuration configuration, Type actorType, IRandomValueGenerator valueGenerator)
: base(configuration, valueGenerator)
{
if (!actorType.IsSubclassOf(typeof(Actor)))
{
this.Assert(false, "Type '{0}' is not an actor.", actorType.FullName);
}
var id = new ActorId(actorType, null, this);
this.Instance = ActorFactory.Create(actorType);
IActorManager actorManager;
if (this.Instance is StateMachine stateMachine)
{
actorManager = new StateMachineManager(this, stateMachine, Guid.Empty);
}
else
{
actorManager = new ActorManager(this, this.Instance, Guid.Empty);
}
this.ActorInbox = new EventQueue(actorManager);
this.Instance.Configure(this, id, actorManager, this.ActorInbox);
this.Instance.SetupEventHandlers();
this.LogWriter.LogCreateActor(this.Instance.Id, null, null);
this.IsActorWaitingToReceiveEvent = false;
}
private void Create()
{
this.remote = (Remote)AppDomain.CurrentDomain.GetData("remote");
this.SM = StateMachineManager.CreateSMSec(this.Instance, this.testConfig, this.Tracer);
AppDomain.CurrentDomain.UnhandledException += this.CurrentDomain_UnhandledException;
AppDomain.CurrentDomain.DomainUnload += this.Ad_DomainUnload;
}
static void ExportAllStateMachine()
{
foreach (var st in GameObject.FindObjectsOfType <StateMachine> ())
{
StateMachineManager.ExportStateMachine(st, "Export/StateMachine/StateMachine_" + st.name + ".bytes");
}
}
protected void btnSave_Click(object sender, EventArgs e)
{
Page.Validate();
if (!this.Page.IsValid)
{
return;
}
MetaObject mo = null;
if (StateId > 0)
{
mo = StateMachineManager.GetState(ClassName, StateId);
mo.Properties["FriendlyName"].Value = txtFriendlyName.Text;
mo.Save();
}
else
{
StateMachineManager.AddState(ClassName, txtName.Text, txtFriendlyName.Text);
}
// Closing window
if (RefreshButton == String.Empty)
{
CHelper.CloseItAndRefresh(Response);
}
else // Dialog Mode
{
CHelper.CloseItAndRefresh(Response, RefreshButton);
}
}
public override void DataBind()
{
object bindObject = DataBinder.GetDataItem(this.Parent);
string retVal = "";
if (bindObject != null && bindObject is MetaObject)
{
string argumentType = ((MetaObject)bindObject).Properties["ArgumentType"].Value.ToString();
string argumentData = ((MetaObject)bindObject).Properties["ArgumentData"].Value.ToString();
Type objType = Mediachase.Ibn.Data.AssemblyUtil.LoadType(argumentType);
object obj = McXmlSerializer.GetObject(objType, argumentData);
if (obj != null)
{
PropertyInfo pinfo = objType.GetProperty("CurrentState");
if (pinfo != null)
{
object curState = pinfo.GetValue(obj, null);
if (curState is State)
{
retVal = String.Format("<b>{0}:</b> {1}",
CHelper.GetResFileString("{IbnFramework.TimeTracking:_mc_State}"),
CHelper.GetResFileString(StateMachineManager.GetState("TimeTrackingBlock", ((State)curState).Name).Properties["FriendlyName"].Value.ToString()));
}
}
}
if (String.IsNullOrEmpty(retVal))
{
retVal = CHelper.GetEventResourceString((MetaObject)bindObject);
}
lblStateValue.Text = retVal;
}
base.DataBind();
}
private void BindState()
{
string savedValue = ddlState.SelectedValue;
ddlState.Items.Clear();
int stateMachineId = int.Parse(ddlStateMachine.SelectedValue);
sm = new Mediachase.Ibn.Data.Services.StateMachine(mc, stateMachineId);
grdMain.Visible = true;
if (sm.States.Count == 0)
{
grdMain.Visible = false;
return;
}
foreach (State state in sm.States)
{
MetaObject mo = StateMachineManager.GetState(mc, state.Name);
ListItem li = new ListItem(CHelper.GetResFileString(mo.Properties["FriendlyName"].Value.ToString()), mo.PrimaryKeyId.Value.ToString());
ddlState.Items.Add(li);
}
if (savedValue != null)
{
CHelper.SafeSelect(ddlState, savedValue);
}
GenerateStructure();
}
private void BindData()
{
if (SMId > 0)
{
Mediachase.Ibn.Data.Services.StateMachine sm = StateMachineManager.GetStateMachine(ClassName, SMId);
txtName.Text = sm.Name;
foreach (State state in sm.States)
{
MetaObject mo = StateMachineManager.GetState(ClassName, state.Name);
lstSelectedStates.Items.Add(new ListItem(CHelper.GetResFileString(mo.Properties["FriendlyName"].Value.ToString()), state.Name));
}
foreach (MetaObject mo in StateMachineManager.GetAvailableStates(ClassName))
{
string sName = mo.Properties["Name"].Value.ToString();
ListItem item = lstSelectedStates.Items.FindByValue(sName);
if (item == null)
{
lstAvailableStates.Items.Add(new ListItem(CHelper.GetResFileString(mo.Properties["FriendlyName"].Value.ToString()), mo.Properties["Name"].Value.ToString()));
}
}
}
else
{
foreach (MetaObject mo in StateMachineManager.GetAvailableStates(ClassName))
{
lstAvailableStates.Items.Add(new ListItem(CHelper.GetResFileString(mo.Properties["FriendlyName"].Value.ToString()), mo.Properties["Name"].Value.ToString()));
}
}
}
private static void GetCurrentAndPrevStateIdByTimeTrackingBlock(TimeTrackingBlock block, out int curStateId, out int prevStateId)
{
curStateId = -1;
prevStateId = -1;
StateMachineService stateMachine = block.GetService <StateMachineService>();
if (stateMachine == null || stateMachine.StateMachine.States.Count == 0 || stateMachine.CurrentState == null)
{
return;
}
EventService eventService = block.GetService <EventService>();
if (eventService != null)
{
// Detects that state is changed, find moFromStateName, toStateName
MetaObject[] events = eventService.LoadEvents(TriggerContext.Current.TransactionId);
StateMachineEventServiceArgs args = StateMachine.GetStateChangedEventArgs(events);
if (args != null)
{
curStateId = StateMachineManager.GetState(TimeTrackingBlock.GetAssignedMetaClass(), args.CurrentState.Name).PrimaryKeyId.Value;
prevStateId = StateMachineManager.GetState(TimeTrackingBlock.GetAssignedMetaClass(), args.PrevState.Name).PrimaryKeyId.Value;
}
}
}
public async Task ApplyTransition_NextStateKeyOverride()
{
// Arrange
var context = new TestCaseContext();
var sut = new StateMachineManager(
context.OptionsService,
context.Logger,
context.DataService);
Mock.Get(context.DataService).Setup(
m => m.RunOnTransitionScript(context.InitialState, context.Transition, It.IsAny <CancellationToken>()))
.ReturnsAsync(new OnTransitionOutput {
NextStateKeyOverride = context.State2Key
});
// Act
await sut.SetInitialState();
await sut.ApplyTransition(context.TransitionKey);
var currentState = sut.GetCurrentState();
// Assert
Assert.Same(context.State2, currentState);
Mock.Get(context.DataService).Verify(
m => m.RunOnTransitionScript(context.InitialState, context.Transition, It.IsAny <CancellationToken>()),
Times.Once);
Mock.Get(context.DataService).Verify(
m => m.RunOnLeaveStateScript(context.InitialState, It.IsAny <CancellationToken>()),
Times.Once);
Mock.Get(context.DataService).Verify(
m => m.RunOnEnterStateScript(context.State2, It.IsAny <CancellationToken>()),
Times.Once);
}
public async Task SetCurrentState(bool leaveCurrentState)
{
// Arrange
var context = new TestCaseContext();
var sut = new StateMachineManager(
context.OptionsService,
context.Logger,
context.DataService);
// Act
await sut.SetInitialState();
await sut.SetCurrentState(context.State1Key, leaveCurrentState);
var currentState = sut.GetCurrentState();
// Assert
Assert.Same(context.State1, currentState);
var times = leaveCurrentState ? Times.Once() : Times.Never();
Mock.Get(context.DataService).Verify(
m => m.RunOnLeaveStateScript(context.InitialState, It.IsAny <CancellationToken>()),
times);
Mock.Get(context.DataService).Verify(
m => m.RunOnEnterStateScript(context.State1, It.IsAny <CancellationToken>()),
Times.Once);
}
void OnWizardCreate()
{
var go = Selection.activeGameObject;
var st = go.GetComponent <StateMachine> ();
StateMachineManager.CreateStateNode(st, name);
}
public void OnStateEnter(Animator animator, AnimatorStateInfo animatorStateInfo, int layerIndex)
{
_stateManager = StateMachineManager.Instance;
SoundManager.Instance.PlayMusic(clipMusic, 0.051f);
SoundManager.Instance.SetSpeaker(soundButtonImage);
SoundManager.Instance.SetQuaver(musicButtonImage);
}
public static void LocalReset()
{
//AudioTrackService.ClearAllAudio();
SFXService.ClearConstructed();
Events.Event0.DestroyAll();
ETime.Slowdown.RevokeAll(MultiOp.Priority.CLEAR_SCENE);
ETime.Timer.DestroyAll();
BehaviorEntity.DestroyAllSummons();
PublicDataHoisting.DestroyAll();
FiringCtx.ClearNames();
ReflWrap.ClearWrappers();
StateMachineManager.ClearCachedSMs();
BulletManager.ClearPoolControls();
BulletManager.ClearEmpty();
BulletManager.ClearAllBullets();
BulletManager.DestroyCopiedPools();
InstanceData.CampaignDataUpdated.Proc();
#if UNITY_EDITOR || ALLOW_RELOAD
Events.LocalReset.Proc();
#endif
//Ordered last so cancellations from HardCancel will occur under old data
Instance = new InstanceData(InstanceMode.NULL);
Debug.Log($"Reloading level: {Difficulty.Describe()} is the current difficulty");
UIManager.UpdateTags();
}
public void Start()
{
inputManager = GetComponent <InputManager>();
uiController = GetComponent <UIController>();
stateMachineManager = GetComponent <StateMachineManager>();
gameMath = GetComponent <GameMath>();
timeCalculations = GetComponent <TimeCalculations>();
save = GetComponent <Save>();
load = GetComponent <Load>();
player = GetComponent <Player>();
resetGame = GetComponent <ResetGame>();
if (PlayerPrefs.GetInt("CheckIfGameIsSaved") == 1)
{
load.LoadGameState();
uiController.UIControllerUpdate();
gameMath.GetingGameState();
gameMath.CalculateLoadGameState();
CallingGameMathForHungerAndHappienessLoss();
}
if (PlayerPrefs.GetInt("OrginalStartBool") == 1)
{
load.LoadOrignalGameDate();
}
if (PlayerPrefs.GetInt("CheckIfGameIsSaved") != 1)
{
SetGameStart();
}
}
/**
*
*/
public static StateMachineManager GetStateMachineManager()
{
if (inst == null)
{
inst = new StateMachineManager();
}
return(inst);
}
private void BindStates()
{
ddState.Items.Add(new ListItem(CHelper.GetResFileString("{IbnFramework.Global:_mc_All}"), "0"));
foreach (MetaObject mo in StateMachineManager.GetAvailableStates(TimeTrackingBlock.GetAssignedMetaClass()))
{
ddState.Items.Add(new ListItem(CHelper.GetResFileString(mo.Properties["FriendlyName"].Value.ToString()), mo.Properties["FriendlyName"].Value.ToString()));
}
}
public void Update()
{
string currentState = StateMachineManager.GetStateMachineManager().GetCurrentState();
if (currentState == "gameplay" || currentState == "alert")
{
//hpText.text = "Score: " + ((int)ScoreManager.GetScoreManager().GetScore()).ToString();
}
}
public void DecreaseScoreOnCollision()
{
score += COLLISION_D;
if (score < 0)
{
score = 0;
StateMachineManager.GetStateMachineManager().MakeTransition("defeat");
GUIManager.GetGUIManager().ArrangeGUI();
}
}
private void BindData()
{
if (StateId > 0)
{
MetaObject mo = StateMachineManager.GetState(ClassName, StateId);
txtName.Text = mo.Properties["Name"].Value.ToString();
txtName.ReadOnly = true;
txtFriendlyName.Text = mo.Properties["FriendlyName"].Value.ToString();
}
}
void Awake()
{
StateMachineManager.AddMachine(this);
BuildLayerDict();
foreach (StateLayer layer in layers)
{
layer.OnAwake();
}
}
private void GenerateStructure()
{
foreach (State toState in sm.States)
{
string stateName = toState.Name;
if (stateName == FromState)
{
continue;
}
MetaObject mo = StateMachineManager.GetState(ClassName, stateName);
HtmlTableRow tr = new HtmlTableRow();
tr.Style.Add(HtmlTextWriterStyle.Height, "25px");
HtmlTableCell td1 = new HtmlTableCell();
HtmlTableCell td2 = new HtmlTableCell();
td1.NoWrap = true;
CheckBox cb = new CheckBox();
cb.ID = String.Format("chk{0}", stateName);
TextBox txt = new TextBox();
txt.ID = String.Format("txt{0}", stateName);
txt.Width = Unit.Percentage(100);
if (!IsPostBack)
{
cb.Text = CHelper.GetResFileString(mo.Properties["FriendlyName"].Value.ToString());
StateTransition st = sm.FindTransition(FromState, stateName);
if (st != null)
{
cb.Checked = true;
txt.Text = st.Name;
}
else
{
txt.Text = mo.Properties["FriendlyName"].Value.ToString();
txt.Style.Add(HtmlTextWriterStyle.Display, "none");
}
}
td1.Controls.Add(cb);
td2.Controls.Add(txt);
tr.Cells.Add(td1);
tr.Cells.Add(td2);
tblMain.Rows.Add(tr);
cb.Attributes.Add("onclick", String.Format("ShowHide('{0}', '{1}')", cb.ClientID, txt.ClientID));
}
}
public void GetNextStatesTest()
{
// Arrange
StateMachineManager.Register(new [] { typeof(BasicTests).Assembly });
// Act
var nextStates = StateMachineManager.GetNextStates(AuthenticationState.Unauthenticated);
// Assert
Assert.Equal(AuthenticationState.Authenticated, nextStates.Last());
}
static void ExportStateMachine()
{
var st = Selection.activeGameObject != null?Selection.activeGameObject.GetComponent <StateMachine> () : null;
if (st == null)
{
Debug.LogWarningFormat("State Machine not selected");
return;
}
StateMachineManager.ExportStateMachine(st, "Export/StateMachine/StateMachine_" + st.name + ".bytes");
}
void Awake()
{
if (Singleton == null)
{
Singleton = this;
DontDestroyOnLoad(gameObject);
}
else
{
Destroy(gameObject);
}
}
protected void Page_Load(object sender, EventArgs e)
{
sm = StateMachineManager.GetStateMachine(ClassName, SMId);
GenerateStructure();
if (!IsPostBack)
{
MetaObject mo = StateMachineManager.GetState(ClassName, FromState);
lblFrom.Text = CHelper.GetResFileString(mo.Properties["FriendlyName"].Value.ToString());
}
}
public async Task ApplyTransition_NoState_Throws()
{
// Arrange
var context = new TestCaseContext();
var sut = new StateMachineManager(
context.OptionsService,
context.Logger,
context.DataService);
// Act + Assert
await Assert.ThrowsAsync <InvalidOperationException>(
() => sut.ApplyTransition(context.TransitionKey));
}
public void OnStateEnter(Animator animator, AnimatorStateInfo animatorStateInfo, int layerIndex)
{
string _PauseState = "Pause State";
if (animator.GetCurrentAnimatorStateInfo(0).IsName(_PauseState))
{
return;
}
_stateManager = StateMachineManager.Instance;
SetLevel();
staticClips = audioClips;
SoundManager.Instance.PlayMusic(audioClips[0], 0.051f);
}
void Awake()
{
if (Instance == null)
{
Instance = this;
}
else
{
Destroy(this.gameObject);
return;
}
DontDestroyOnLoad(this);
SaveLoad.Load();
}
public MqttClient(string clientId, IMqttClient client)
{
if (clientId.Length < 1 || clientId.Length > 23)
{
throw new ArgumentException("Client identifier must be between 1 and 23 charascters.");
}
_clientState = ClientState.Disconnected;
ClientId = clientId;
_client = client;
_client.OnMessageReceived += ClientOnMessageReceived;
_client.OnNetworkDisconnected += ClientOnOnNetworkDisconnected;
_manager = new StateMachineManager(_client);
}
void OnDestroy() {
instance = null;
}
