public override void Start()
{
bossSkill = GetComponent <BossSkill>();
sensor = new Sensor(10, 120, this);
FsmManager = new FsmManager((int)DragonAnimEnum.Max);
DragonIdleState dragonIdleState = new DragonIdleState(anim, this);
DragonDieState dragonDieState = new DragonDieState(anim, this);
DragonHitState dragonHitState = new DragonHitState(anim, this);
DragonAttackState dragonAttackState = new DragonAttackState(anim, this);
DragonPersueState dragonPersueState = new DragonPersueState(anim, this);
DragonReleaseSkillState dragonReleaseSkillState = new DragonReleaseSkillState(anim, this);
FsmManager.AddState(dragonIdleState);
FsmManager.AddState(dragonDieState);
FsmManager.AddState(dragonHitState);
FsmManager.AddState(dragonAttackState);
FsmManager.AddState(dragonPersueState);
FsmManager.AddState(dragonReleaseSkillState);
FsmManager.ChangeState((int)DragonAnimEnum.Idle);
}
void Update()
{
if (FsmManager.PlayerComputer && Input.GetKeyDown(KeyCode.Return) && typer != null)
{
StartCoroutine(Computer());
}
if (!MOP.DynamicDrawDistance.Value)
{
return;
}
float toGoDrawDistance = FsmManager.GetDrawDistance();
if (player.position.y > 20)
{
toGoDrawDistance *= 2;
}
else if (Hypervisor.Instance.IsInSector())
{
toGoDrawDistance /= 2;
}
mainCamera.farClipPlane = Mathf.Lerp(mainCamera.farClipPlane, toGoDrawDistance, Time.deltaTime * .5f);
}
public virtual void FsmInit()
{
fsmManager = new FsmManager((int)PlayerAnimationEnum.Max);
PlayerIdle playerIdle = new PlayerIdle(anim, this);
PlayerRun playerRun = new PlayerRun(anim, this);
PlayerAttack1 playerAttack1 = new PlayerAttack1(anim, this);
PlayerAttack2 playerAttack2 = new PlayerAttack2(anim, this);
PlayerAttack3 playerAttack3 = new PlayerAttack3(anim, this);
fsmManager.AddState(playerIdle);
fsmManager.AddState(playerRun);
fsmManager.AddState(playerAttack1);
fsmManager.AddState(playerAttack2);
fsmManager.AddState(playerAttack3);
fsmManager.ChangeState((int)PlayerAnimationEnum.Idle);
}
public void ToggleFull(bool enabled)
{
if (!FsmManager.PlayerHasHayosikoKey())
{
// We are using partial disabling to avoid any issues with MSC scripts relating uncle.
TogglePartial(enabled);
return;
}
else
{
// We are not using partial disabling, if player has permanently obtained Hayosiko, as it is not needed anymore.
TogglePartial(true);
}
if (!enabled)
{
MoveNonDisableableObjects(temporaryParent);
}
gameObject.SetActive(enabled);
if (enabled)
{
MoveNonDisableableObjects(null);
}
}
private void Awake()
{
Utility.Converter.ScreenDpi = Screen.dpi;
if (Utility.Converter.ScreenDpi <= 0)
{
Utility.Converter.ScreenDpi = DefaultDpi;
}
//Application.targetFrameRate = m_FrameRate;
Time.timeScale = m_GameSpeed;
Application.runInBackground = m_RunInBackground;
Screen.sleepTimeout = m_NeverSleep ? SleepTimeout.NeverSleep : SleepTimeout.SystemSetting;
DontDestroyOnLoad(gameObject);
///////////////////////////////////////流程正式开始
GameMainEntry.GameMainEntryComponent = this;
var pd_mg = GameMainEntry.GetModule <ProcedureManager>();
var pd_fsm = new FsmManager();
var pd_setting = new Procedure_Setting();
pd_mg.Initialize(pd_fsm, pd_setting);
pd_mg.StartProcedure <Procedure_Setting>();
//////////////////////////////////////////
}
IEnumerator DelayedSaveRoutine()
{
yield return(new WaitForSeconds(1));
if (FsmManager.IsSuskiLargeCall())
{
PreSaveGame();
}
}
//ProcedureManager m_pdm;
public void Enter()
{
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.UnhandledException += new UnhandledExceptionEventHandler(ExceptHandler);
var pd_mg = GameMainEntry.GetModule <ProcedureManager>();
var pd_fsm = new FsmManager();
var pd_setting = new Procedure_Setting();
pd_mg.Initialize(pd_fsm, pd_setting);
pd_mg.StartProcedure <Procedure_Setting>();
bool m_quit = false;
DateTime lastdt = DateTime.Now;
DateTime curdt = DateTime.Now;
TimeSpan curts;
float elapseSeconds = 0;
Task.Factory.StartNew(() =>
{
bool bloop = true;
while (bloop)
{
string strcmd = Console.ReadLine();
if (strcmd == "quit")
{
bloop = false;
m_quit = true;
}
else if (strcmd == "exp")
{
}
}
}
);
while (!m_quit)
{
Thread.Sleep(GameConstant.TThreadInternal);
curdt = DateTime.Now;
curts = curdt - lastdt;
elapseSeconds = (float)curts.TotalMilliseconds / 1000;
GameMainEntry.Update(elapseSeconds, elapseSeconds);
//m_pdm.Execute((float)curts.TotalMilliseconds/1000);
lastdt = curdt;
}
//m_pdm.Shut();
return;
}
/// <summary>
/// 初始化流程管理器。
/// </summary>
/// <param name="fsmManager">有限状态机管理器。</param>
/// <param name="procedures">流程管理器包含的流程。</param>
public void Initialize(FsmManager fsmManager, params ProcedureBase[] procedures)
{
if (fsmManager == null)
{
throw new LufyException("FSM manager is invalid.");
}
m_FsmManager = fsmManager;
m_ProcedureFsm = m_FsmManager.CreateFsm(this, procedures);
}
// Start is called before the first frame update
void Start()
{
m_FsmManager = GetComponent <FsmManager>();
FsmState <FsmTest>[] states = new FsmState <FsmTest> [3];
states[0] = new HeroRun();
states[1] = new HeroIdle();
states[2] = new HeroAttack();
m_HeroFsm = m_FsmManager.CreateFsm(this, states);
m_HeroFsm.Start(typeof(HeroRun));
}
public void ToggleCombineActive(bool enabled)
{
// If combine harvester is not available yet, simply ignore it.
if (!FsmManager.IsCombineAvailable())
{
return;
}
// Use normal toggling script.
this.ToggleActive(enabled);
}
internal override void Shutdown()
{
if (m_FsmManager != null)
{
if (m_ProcedureFsm != null)
{
m_FsmManager.DestroyFsm(m_ProcedureFsm);
m_ProcedureFsm = null;
}
m_FsmManager = null;
}
}
public override void Enter()
{
_inputSystem = ServiceLocator.Get <IInputSystem>();
ServiceLocator.Get <GuiManager>().Open(GuiViewType.Match, true);
var difficult = (int)FsmManager.GetBlackboardValue("Difficult");
_pongManager = CreatePongManager();
_pongManager.Initialize(ServiceLocator.Get <SettingsManager>().Config.Difficulties[difficult]);
_pongManager.SpawnPaddles();
_pongManager.SpawnBall();
SignalBus.Invoke(new GameStartedSignal(_pongManager.Paddle1, _pongManager.Paddle2));
}
void RegistFsm()
{
m_Fsm = new FsmManager();
BulletStartStatus start = new BulletStartStatus(this, m_Animator);
m_Fsm.AddStatus((int)E_BulletFsmStatus.Start, start);
BulletRunningStatus run = new BulletRunningStatus(this, m_Animator);
m_Fsm.AddStatus((int)E_BulletFsmStatus.Running, run);
BulletEndStatus end = new BulletEndStatus(this, m_Animator);
m_Fsm.AddStatus((int)E_BulletFsmStatus.End, end);
ChangeStatus(E_BulletFsmStatus.Start);
}
// Use this for initialization
void Start()
{
charactorCtrl = GetComponent <CharacterController>();
// charactorCtrl.isTrigger = false;
charactorCtrl.detectCollisions = false;
tmpAnimator = GetComponent <Animator>();
fsmManager = new FsmManager((byte)AnimalState.MaxValue);
PlayerIdl tmpIdle = new PlayerIdl(tmpAnimator);
fsmManager.AddState(tmpIdle);
PlayerRunJump tmpRunJump = new PlayerRunJump(tmpAnimator);
fsmManager.AddState(tmpRunJump);
PlayerRun tmpRun = new PlayerRun(tmpAnimator);
fsmManager.AddState(tmpRun);
PlayerRunSide tmpRunSide = new PlayerRunSide(tmpAnimator);
fsmManager.AddState(tmpRunSide);
PlayerBackDeath tmpBackDeath = new PlayerBackDeath(tmpAnimator);
fsmManager.AddState(tmpBackDeath);
PlayerForwardDeath tmpForwardDeth = new PlayerForwardDeath(tmpAnimator);
fsmManager.AddState(tmpForwardDeth);
PlayerAttack tmpAttack = new PlayerAttack(tmpAnimator);
fsmManager.AddState(tmpAttack);
}
public override void FsmInit()
{
fsmManager = new FsmManager((int)LongRangeEnum.Max);
PlayerIdle playerIdle = new PlayerIdle(anim, this);
PlayerRun playerRun = new PlayerRun(anim, this);
LongRangeAttack longRangeAttack = new LongRangeAttack(anim, this);
fsmManager.AddState(playerIdle);
fsmManager.AddState(playerRun);
fsmManager.AddState(longRangeAttack);
fsmManager.ChangeState((int)LongRangeEnum.Idle);
}
public override void Update()
{
if (this.roleData.hp <= 0)
{
return;
}
skillTimer += Time.deltaTime;
if (skillTimer >= skillCooldown)
{
canReleaseSkill = true;
}
FsmManager.FsmUpdate();
sensorTimer += Time.deltaTime;
if (sensorTimer > sensorCheckInterval)
{
sensor.SensorUpdate();
}
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
if (!EditorApplication.isPlaying)
{
EditorGUILayout.HelpBox("Available during runtime only.", MessageType.Info);
return;
}
FsmManager t = (FsmManager)target;
EditorGUILayout.LabelField("FSM Count", t.Count.ToString());
IFsm[] fsms = t.GetAllFsms();
foreach (IFsm fsm in fsms)
{
DrawFsm(fsm);
}
Repaint();
}
public virtual void Start()
{
sensor = new Sensor(10, 120, this);
FsmManager = new FsmManager((int)GoblinAnimationEnum.Max);
GoblinAttackState goblinAttackState = new GoblinAttackState(anim, this);
GoblinDieState goblinDieState = new GoblinDieState(anim, this);
GoblinHitState goblinHitState = new GoblinHitState(anim, this);
GoblinIdleState goblinIdleState = new GoblinIdleState(anim, this);
GoblinPatrolState goblinPatrolState = new GoblinPatrolState(anim, this);
GoblinPersueState goblinPersueState = new GoblinPersueState(anim, this);
FsmManager.AddState(goblinIdleState);
FsmManager.AddState(goblinDieState);
FsmManager.AddState(goblinHitState);
FsmManager.AddState(goblinAttackState);
FsmManager.AddState(goblinPatrolState);
FsmManager.AddState(goblinPersueState);
FsmManager.ChangeState((int)GoblinAnimationEnum.Idle);
}
void Start()
{
tmpTime = 0;
fsmManager = new FsmManager((byte)AnimalState.MaxValue);
Animator tmpAnimator = transform.GetComponent <Animator>();
FsmBase tmpIdle = new OrcIdle(tmpAnimator);
fsmManager.AddState(tmpIdle);//0
FsmBase tmpAttack1 = new OrcAttack1(tmpAnimator);
fsmManager.AddState(tmpAttack1);//1
FsmBase tmpAttack2 = new OrcAttack2(tmpAnimator);
fsmManager.AddState(tmpAttack2);//2
FsmBase tmpAttack3 = new OrcAttack3(tmpAnimator);
fsmManager.AddState(tmpAttack3);//3
FsmBase tmpAttack4 = new OrcAttack4(tmpAnimator);
fsmManager.AddState(tmpAttack4);//4
FsmBase tmpAttack5 = new OrcAttack5(tmpAnimator);
fsmManager.AddState(tmpAttack5);//5
FsmBase tmpDeath = new OrcDeath(tmpAnimator);
fsmManager.AddState(tmpDeath);//6
FsmBase tmpRun = new OrcRun(tmpAnimator);
fsmManager.AddState(tmpRun);//7
FsmBase tmpLeft = new OrcLeft(tmpAnimator);
fsmManager.AddState(tmpLeft);//8
FsmBase tmpRight = new OrcRight(tmpAnimator);
fsmManager.AddState(tmpRight);//9
}
private void Awake()
{
_fsmManager = ServiceLocator.Get <FsmManager>();
}
public ProcedureManager()
{
m_FsmManager = FrameworkEntry.Instance.GetManager <FsmManager>();
m_ProcedeureFsm = null;
m_procedures = new List <ProcedureBase>();
}
IEnumerator LoopRoutine()
{
MopSettings.IsModActive = true;
FramerateRecorder rec = gameObject.AddComponent <FramerateRecorder>();
rec.Initialize();
while (MopSettings.IsModActive)
{
// Ticks make sure that MOP is still up and running.
// If the ticks didn't update, that means this routine stopped.
++ticks;
if (!itemInitializationDelayDone)
{
// We are slightly delaying the initialization, so all items have chance to set in place, because f**k MSC and its physics.
waitTime++;
if (waitTime >= WaitDone)
{
FinishLoading();
}
}
isPlayerAtYard = MOP.ActiveDistance.Value == 0 ? Vector3.Distance(player.position, placeManager[0].transform.position) < 100
: Vector3.Distance(player.position, placeManager[0].transform.position) < 100 * MopSettings.ActiveDistanceMultiplicationValue;
// When player is in any of the sectors, MOP will act like the player is at yard.
if (SectorManager.Instance.IsPlayerInSector())
{
inSectorMode = true;
isPlayerAtYard = true;
}
else
{
inSectorMode = false;
}
yield return(null);
int i;
long half = worldObjectManager.Count >> 1;
// World Objects.
for (i = 0; i < worldObjectManager.Count; ++i)
{
if (i == half)
{
yield return(null);
}
try
{
GenericObject worldObject = worldObjectManager[i];
// Check if object was destroyed (mostly intended for AI pedastrians).
if (worldObject.GameObject == null)
{
worldObjectManager.Remove(worldObject);
continue;
}
if (SectorManager.Instance.IsPlayerInSector() && SectorManager.Instance.SectorRulesContains(worldObject.GameObject.name))
{
worldObject.GameObject.SetActive(true);
continue;
}
// Should the object be disabled when the player leaves the house?
if (worldObject.DisableOn.HasFlag(DisableOn.PlayerAwayFromHome) || worldObject.DisableOn.HasFlag(DisableOn.PlayerInHome))
{
if (worldObject.GameObject.name == "NPC_CARS" && inSectorMode)
{
continue;
}
if (worldObject.GameObject.name == "COMPUTER" && worldObject.GameObject.transform.Find("SYSTEM").gameObject.activeSelf)
{
continue;
}
worldObject.Toggle(worldObject.DisableOn.HasFlag(DisableOn.PlayerAwayFromHome) ? isPlayerAtYard : !isPlayerAtYard);
}
else if (worldObject.DisableOn.HasFlag(DisableOn.Distance))
{
// The object will be disabled, if the player is in the range of that object.
worldObject.Toggle(IsEnabled(worldObject.transform, worldObject.Distance));
}
}
catch (Exception ex)
{
ExceptionManager.New(ex, false, "WORLD_OBJECT_TOGGLE_ERROR");
}
}
// Safe mode prevents toggling elemenets that MAY case some issues (vehicles, items, etc.)
if (MopSettings.Mode == PerformanceMode.Safe)
{
yield return(new WaitForSeconds(.7f));
continue;
}
// So we create two separate lists - one is meant to enable, and second is ment to disable them,
// Why?
// If we enable items before enabling vehicle inside of which these items are supposed to be, they'll fall through to ground.
// And the opposite happens if we disable vehicles before disabling items.
// So if we are disabling items, we need to do that BEFORE we disable vehicles.
// And we need to enable items AFTER we enable vehicles.
itemsToEnable.Clear();
itemsToDisable.Clear();
half = ItemsManager.Instance.Count >> 1;
for (i = 0; i < ItemsManager.Instance.Count; ++i)
{
if (i == half)
{
yield return(null);
}
// Safe check if somehow the i gets bigger than array length.
if (i >= ItemsManager.Instance.Count)
{
break;
}
try
{
ItemBehaviour item = ItemsManager.Instance[i];
if (item == null || item.gameObject == null)
{
itemsToRemove.Add(item);
continue;
}
// Check the mode in what MOP is supposed to run and adjust to it.
bool toEnable = true;
if (MopSettings.Mode == 0)
{
toEnable = IsEnabled(item.transform, FsmManager.IsPlayerInCar() && !isPlayerAtYard ? 20 : 150);
}
else
{
toEnable = IsEnabled(item.transform, 150);
}
if (toEnable)
{
item.ToggleChangeFix();
if (item.ActiveSelf)
{
continue;
}
itemsToEnable.Add(item);
}
else
{
if (!item.ActiveSelf)
{
continue;
}
itemsToDisable.Add(item);
}
if (item.rb != null && item.rb.IsSleeping())
{
if (item.IsPartMagnetAttached())
{
continue;
}
if (CompatibilityManager.IsInBackpack(item))
{
continue;
}
item.rb.isKinematic = true;
}
}
catch (Exception ex)
{
ExceptionManager.New(ex, false, "ITEM_TOGGLE_GATHER_ERROR");
}
}
// Items To Disable
int full = itemsToDisable.Count;
if (full > 0)
{
half = itemsToDisable.Count >> 1;
for (i = 0; i < full; ++i)
{
if (half != 0 && i == half)
{
yield return(null);
}
try
{
itemsToDisable[i].Toggle(false);
}
catch (Exception ex)
{
ExceptionManager.New(ex, false, "ITEM_TOGGLE_DISABLE_ERROR - " + itemsToDisable[i] != null ? itemsToDisable[i].gameObject.name : "null");
}
}
}
// Vehicles (new)
half = vehicleManager.Count >> 1;
for (i = 0; i < vehicleManager.Count; ++i)
{
if (half != 0 && i == half)
{
yield return(null);
}
try
{
if (vehicleManager[i] == null)
{
vehicleManager.RemoveAt(i);
continue;
}
float distance = Vector3.Distance(player.transform.position, vehicleManager[i].transform.position);
float toggleDistance = MOP.ActiveDistance.Value == 0
? MopSettings.UnityCarActiveDistance : MopSettings.UnityCarActiveDistance * MopSettings.ActiveDistanceMultiplicationValue;
switch (vehicleManager[i].VehicleType)
{
case VehiclesTypes.Satsuma:
Satsuma.Instance.ToggleElements(distance);
vehicleManager[i].ToggleEventSounds(distance < 3);
break;
case VehiclesTypes.Jonnez:
vehicleManager[i].ToggleEventSounds(distance < 2);
break;
}
vehicleManager[i].ToggleUnityCar(IsVehiclePhysicsEnabled(distance, toggleDistance));
vehicleManager[i].Toggle(IsVehicleEnabled(distance));
}
catch (Exception ex)
{
ExceptionManager.New(ex, false, $"VEHICLE_TOGGLE_ERROR_{i}");
}
}
// Items To Enable
full = itemsToEnable.Count;
if (full > 0)
{
half = full >> 1;
for (i = 0; i < full; ++i)
{
if (half != 0 && i == half)
{
yield return(null);
}
try
{
itemsToEnable[i].Toggle(true);
}
catch (Exception ex)
{
ExceptionManager.New(ex, false, "ITEM_TOGGLE_ENABLE_ERROR - " + itemsToEnable[i] != null ? itemsToDisable[i].gameObject.name : "null");
}
}
}
// Places (New)
full = placeManager.Count;
half = full >> 1;
for (i = 0; i < full; ++i)
{
if (i == half)
{
yield return(null);
}
try
{
if (SectorManager.Instance.IsPlayerInSector() && SectorManager.Instance.SectorRulesContains(placeManager[i].GetName()))
{
continue;
}
placeManager[i].ToggleActive(IsPlaceEnabled(placeManager[i].transform, placeManager[i].GetToggleDistance()));
}
catch (Exception ex)
{
ExceptionManager.New(ex, false, $"PLACE_TOGGLE_ERROR_{i}");
}
}
// Remove items that don't exist anymore.
if (itemsToRemove.Count > 0)
{
for (i = itemsToRemove.Count - 1; i >= 0; --i)
{
ItemsManager.Instance.RemoveAt(i);
}
itemsToRemove.Clear();
}
yield return(new WaitForSeconds(.7f));
if (retries > 0 && !restartSucceedMessaged)
{
restartSucceedMessaged = true;
ModConsole.Log("<color=green>[MOP] Restart succeeded!</color>");
}
}
}
protected override void OnAwake()
{
base.OnAwake();
m_FsmManager = new FsmManager();
}
public override void ChangeToIdle()
{
FsmManager.ChangeState((int)DragonAnimEnum.Idle);
}
public override void ChangeToAttack()
{
FsmManager.ChangeState((int)DragonAnimEnum.Attack);
}
public void Initialize(FsmManager manager)
{
FsmManager = manager;
}
public override void ChangeToHit()
{
FsmManager.ChangeState((int)DragonAnimEnum.Hit);
}
public override void ChangeToPersue()
{
FsmManager.ChangeState((int)DragonAnimEnum.Persue);
}
