// 根据Canvas状态变化，调用
// Wake(), Sleep()函数
// 分别调用SpriteSleeperImage的Sleep()函数
protected void OnCanvasHierarchyChanged()
{
if (_hasCanvas)
{
// 根据Canvas，设置SleepState
// 如果状态发生了变化
SleepState state = (_canvas.isActiveAndEnabled) ? SleepState.Awake : SleepState.Sleeping;
if (state != _currentSleepState)
{
_currentSleepState = state;
if (state == SleepState.Awake)
{
//
Wake();
}
else
{
#if UNITY_EDITOR
if (!_canvas.gameObject.activeInHierarchy)
{
if (UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode &&
UnityEditor.EditorApplication.isPlaying)
{
Debug.LogWarning("Did you know it's more efficient to disable the Canvas component than to deactivate the GameObject? Read more here https://unity3d.com/learn/tutorials/topics/best-practices/other-ui-optimization-techniques-and-tips");
}
}
#endif
Sleep();
}
}
}
}
// Start is called before the first frame update
void Start()
{
manager = new HFSMManagerSystem();
HomeSystem homeSystem = new HomeSystem("HomeSystem", manager);
ReadBookState readBookState = new ReadBookState("ReadBookState", homeSystem, systemText, stateText);
readBookState.AddTransition("Cook", "CookState");
CookState cookState = new CookState("CookState", homeSystem, systemText, stateText);
cookState.AddTransition("Sleep", "SleepState");
SleepState sleepState = new SleepState("SleepState", homeSystem, systemText, stateText);
sleepState.AddTransition("ReadBook", "ReadBookState");
homeSystem.AddState(readBookState);
homeSystem.AddState(cookState);
homeSystem.AddState(sleepState);
MarketSystem marketSystem = new MarketSystem("MarketSystem", manager);
BuyState buyState = new BuyState("BuyState", marketSystem, systemText, stateText);
buyState.AddTransition("Pay", "PayState");
PayState payState = new PayState("PayState", marketSystem, systemText, stateText);
payState.AddTransition("Buy", "BuyState");
marketSystem.AddState(buyState);
marketSystem.AddState(payState);
manager.AddSubSystem(homeSystem);
manager.AddSubSystem(marketSystem);
}
void Awake()
{
homeSet = false;
survivorFood = 0;
survivorWater = 0;
survivorBandage = 0;
survivorScrap = 0;
survivorHealth = 100;
survivorHunger = 90;
survivorThirst = 90;
survivorTiredness = 90;
wayPointsList = new List <Vector3>();
collectState = new CollectState(this);
buildState = new BuildState(this);
nourrishState = new NourrishState(this);
fightState = new FightState(this);
repairState = new RepairState(this);
sleepState = new SleepState(this);
homeState = new HomeState(this);
healState = new HealState(this);
currentMap = GameObject.Find("Map");
}
// Use this for initialization
void Start()
{
states = new List <State>();
//Patroll state
List <Transition> patrolltrans = new List <Transition>();
patrolltrans.Add(new SeeMonsterTrans(gameObject));
PatrollState patroll = new PatrollState(gameObject, patrolltrans);
states.Add(patroll);
//Scream state
List <Transition> screamtrans = new List <Transition>();
screamtrans.Add(new SeeMonsterTrans(gameObject));
screamtrans.Add(new SeeAngerTrans(gameObject));
screamtrans.Add(new TimePassTrans(gameObject, 25f, "sleep"));
ScreamState scream = new ScreamState(gameObject, screamtrans, 10f);
states.Add(scream);
//Sleep state
List <Transition> sleeptrans = new List <Transition>();
sleeptrans.Add(new TimePassTrans(gameObject, 40f, "patroll"));
SleepState sleep = new SleepState(gameObject, sleeptrans);
states.Add(sleep);
initialState = patroll;
currentState = patroll;
triggeredTransition = null;
gameObject.GetComponent <GraphPathFollowing>().astar_target = null; //Set to null just in case
initialSpeed = gameObject.GetComponent <Agent>().maxSpeed;
}
// Start is called before the first frame update
void Awake()
{
navMeshAgent = GetComponent <UnityEngine.AI.NavMeshAgent>();
normalState = new NormalState(this);
hungryState = new HungryState(this);
sleepState = new SleepState(this);
runAwayState = new RunAwayState(this);
}
private SleepState()
{
if (_instance != null)
{
return;
}
_instance = this;
}
void InitFSM()
{
fsm = new FSMSystem();
FSMState sleepState = new SleepState(fsm);
sleepState.AddTransition(Transition.Open, StateID.Idle);
FSMState IdleState = new IdleState(fsm);
IdleState.AddTransition(Transition.Close, StateID.Sleep);
IdleState.AddTransition(Transition.SeePlayer, StateID.Patrol);
IdleState.AddTransition(Transition.Shopping, StateID.GoOut);
IdleState.AddTransition(Transition.StartPlay, StateID.Play);
FSMState patrolState = new PatrolState(fsm);
patrolState.AddTransition(Transition.Open, StateID.Idle);
patrolState.AddTransition(Transition.SeePlayer, StateID.Chase);
FSMState chaseState = new ChaseState(fsm);
chaseState.AddTransition(Transition.LostPlayer, StateID.Patrol);
chaseState.AddTransition(Transition.FindEnemy, StateID.Bark);
FSMState barkState = new BarkState(fsm);
barkState.AddTransition(Transition.LostPlayer, StateID.Patrol);
FSMState gooutState = new GoOutState(fsm);
gooutState.AddTransition(Transition.Back, StateID.ComeBack);
gooutState.AddTransition(Transition.SeePlayer, StateID.Patrol);
FSMState comebackState = new ComeBackState(fsm);
comebackState.AddTransition(Transition.Open, StateID.Idle);
FSMState playState = new PlayState(fsm);
playState.AddTransition(Transition.Open, StateID.Idle);
playState.AddTransition(Transition.Close, StateID.Sleep);
playState.AddTransition(Transition.SeePlayer, StateID.Patrol);
playState.AddTransition(Transition.Shopping, StateID.GoOut);
fsm.AddState(sleepState);
fsm.AddState(IdleState);
fsm.AddState(patrolState);
fsm.AddState(chaseState);
fsm.AddState(barkState);
fsm.AddState(comebackState);
fsm.AddState(gooutState);
fsm.AddState(playState);
}
private bool HandleWake(uint ms)
{
if (this.lastMs < ms)
{
return(false);
}
if (this.WokeUp != null && this.SleepLevel != SleepState.None)
{
this.WokeUp.Invoke(null, this.SleepLevel);
}
this.SleepLevel = SleepState.None;
return(true);
}
/// <summary>
/// public function for triggering dreams on eye close.
/// </summary>
public void Sleep()
{
sleepState = SleepState.asleep;
if (DreamController.loadedScene == Scenes.Cell)
{
r_dreamController.StartDream();
}
else
{
r_dreamController.EndDream();
}
}
public void StateSequenceCheckingLogEntryVisitorTest_FailingCase()
{
var stateA = new SleepState(2);
var stateB = new TurnState(0.0, 1.0);
var checker = new StateSequenceCheckingLogEntryVisitor();
checker.RegisterAsVisitor(brain);
checker.StateTypeSequence.Enqueue(stateA.GetType());
checker.StateTypeSequence.Enqueue(stateB.GetType());
brain.CurrentState = stateB;
brain.CurrentState = stateA;
Assert.False(checker.AreAllStatesVisited());
}
private void Awake()
{
sleepState = new SleepState(this);
outState = new OutState(this);
useState = new UseState(this);
wanderState = new WanderState(this);
timesRefused = 1;
navMeshAgent = GetComponent <NavMeshAgent>();
time = clock.GetComponent <DigitalGameTimeClock>().currentTime;
prefKeys = new float[activities.Length];
SortPreferences();
}
public static void StateDemo()
{
MonsterContext Context = new MonsterContext();
IMonsterState SleepState = new SleepState();
IMonsterState AttackState = new AttackState();
IMonsterState SpeakState = new SpeakState();
Context.SetState(AttackState);
Context.Action();
Context.SetState(SleepState);
Context.Action();
Context.SetState(SpeakState);
Context.Action();
}
protected override void CheckTransitions(FiniteStateMachine controller)
{
if (playerThrown)
{
ResetValues();
//Transition
//PatrolState state = GetComponent<PatrolState>();
//controller.TransitionToState(state);
SleepState state = GetComponent <SleepState>();
state.StartAnimation();
controller.TransitionToState(state);
}
}
void PopSleep()
{
InSleepCycle = false;
sleepState = SleepState.None;
body.isKinematic = false;
if (TargetBed != null)
{
Physics.IgnoreCollision(ball.Sphere, TargetBed.GetComponent <Collider>(), false);
}
ball.LockToGround = true;
FaceDirectionOfMovement = true;
moveTransform.parent = null;
billboard.faceCamera = true;
walk.enabled = true;
PlayFaceAnimation("idle");
}
public void HandleBreakStart(uint ms, double minutes)
{
if (this.SleepLevel != SleepState.None)
{
return;
}
if (ms < this.breakLimit)
{
return;
}
this.SleepLevel = SleepState.Break;
if (this.BreakLimitReached != null)
{
this.BreakLimitReached.Invoke(null, (int)minutes);
}
}
private void HandleEodStart(uint ms, double minutes)
{
if (this.SleepLevel != SleepState.Break)
{
return;
}
if (ms < this.limit)
{
return;
}
this.SleepLevel = SleepState.EndOfDay;
if (this.IdleLimitReached != null)
{
this.IdleLimitReached.Invoke(null, (int)minutes);
}
}
public void TestDetectingSequenceOfStateChanges()
{
var stateA = new SleepState(2);
var stateB = new TurnState(0.0, 1.0);
var sleepCheckerVisitor = RegisterTestLogVisitor(typeof(SleepState));
var turnCheckerVisitor = RegisterTestLogVisitor(typeof(TurnState));
brain.CurrentState = stateA;
for (int i = 0; i < 2; i++)
{
env.Tick();
}
brain.CurrentState = stateB;
Assert.True(sleepCheckerVisitor.DidEnterCheckedState);
Assert.True(turnCheckerVisitor.DidEnterCheckedState);
}
public void WakeUp()
{
sleepState = SleepState.lyingAwake;
if (DreamController.loadedScene == Scenes.Mountain)
{
dreamTransform = GameObject.Find("MountainStandingTransform").transform;
SetPosition(dreamTransform);
}
else if (DreamController.loadedScene == Scenes.Columns)
{
dreamTransform = GameObject.Find("ColumnStandingTransform").transform;
SetPosition(dreamTransform);
}
else if (DreamController.loadedScene == Scenes.Fire)
{
dreamTransform = GameObject.Find("FireStandingTransform").transform;
SetPosition(dreamTransform);
}
}
private void Wake(object sender, SleepState from)
{
Logger.Log($"Waking from {from}");
if (from == SleepState.Break && this.BreakStart.HasValue)
{
try
{
var start = this.BreakStart.Value;
this.BreakStart = null;
CreateToast(start, DateTime.UtcNow);
} catch (Exception ex)
{
Logger.Log(ex.Message, true);
}
}
else if (from == SleepState.EndOfDay)
{
Data.AddStartOfDay();
this.TimerTick = TimeSpan.FromMinutes(5.0);
this.TimerCB(null);
}
}
public void StateSequenceCheckingLogEntryVisitorTest_SuccessfulCase()
{
var stateA = new SleepState(2);
var stateB = new TurnState(0.0, 1.0);
var checker = new StateSequenceCheckingLogEntryVisitor();
checker.RegisterAsVisitor(brain);
checker.IgnoreIdleState = true;
checker.StateTypeSequence.Enqueue(stateA.GetType());
checker.StateTypeSequence.Enqueue(stateB.GetType());
Assert.False(checker.AreAllStatesVisited());
brain.CurrentState = stateA;
WaitTicks(2);
Assert.False(checker.AreAllStatesVisited());
brain.CurrentState = stateB;
WaitTicks(3);
Assert.True(checker.AreAllStatesVisited());
brain.CurrentState = stateA;
WaitTicks(2);
Assert.False(checker.AreAllStatesVisited());
}
void PushSleep()
{
InSleepCycle = true;
CurrentMoveSpeed = SprintSpeed;
SleepInterrupt = false;
spriteLerp = billboard.gameObject.GetComponent <LerpToTarget>();
if (spriteLerp == null)
{
spriteLerp = billboard.gameObject.AddComponent <LerpToTarget>();
}
moveTransformLerp = moveTransform.gameObject.GetComponent <LerpToTarget>();
if (moveTransformLerp == null)
{
moveTransformLerp = moveTransform.gameObject.AddComponent <LerpToTarget>();
}
if (!isPlayerControlled && TargetBed != null && Vector3.Distance(moveTransform.position, TargetBed.transform.position) > MaxBedLerpDistance)
{
sleepState = SleepState.MovingToBed;
CurrentMoveSpeed = WalkSpeed;
if (!SetPath(TargetBed.destination.transform.position, delegate
{
StartSleep();
}))
{
Debug.Log("path failed");
}
}
else
{
sleepState = SleepState.GettingIntoBed;
StartSleep();
}
}
void UpdateSleep()
{
if (!InSleepCycle)
{
return;
}
if (isPlayerControlled)
{
if (Input.GetButtonDown("Interact"))
{
SleepInterrupt = true;
}
}
if (SleepInterrupt && sleepState != SleepState.WakingUp)
{
sleepState = SleepState.WakingUp;
wakeStart = Time.time;
if (isPlayerControlled)
{
Time.timeScale = 1;
musicSource.Stop();
Global.Instance.AudioWakeUp(1);
cam.LookControlEnabled = true;
}
if (TargetBed != null)
{
moveTransformLerp.moveTransform = moveTransform;
moveTransformLerp.targetTransform = TargetBed.wakeTarget;
moveTransformLerp.lerpType = LerpToTarget.LerpType.Curve;
moveTransformLerp.duration = spriteLerp.duration;
moveTransformLerp.LerpRotation = false;
moveTransformLerp.enabled = true;
moveTransformLerp.OnLerpEnd = delegate
{
PopState();
};
}
else
{
PopState();
}
}
switch (sleepState)
{
case SleepState.MovingToBed:
break;
case SleepState.GettingIntoBed:
if (isPlayerControlled)
{
if (Time.unscaledTime - start < sleepCameraLerpDurationIn)
{
float alpha = (Time.unscaledTime - start) / sleepCameraLerpDurationIn;
cam.lookInput.y = Mathf.Lerp(cam.lookInput.y, 90, alpha);
}
}
break;
case SleepState.Sleeping:
Wake = Mathf.Clamp(Wake + WakeGainRate * Time.deltaTime, 0, WakeFull);
if (Time.time - SleepStartTime > SleepDuration)
{
SleepInterrupt = true;
}
if (isPlayerControlled)
{
if (Time.unscaledTime - start < sleepTODWait)
{
float alpha = (Time.unscaledTime - start) / sleepTODWait;
Global.Instance.CurrentTimeOfDay = todStart + sleepTODDuration * alpha;
Global.Instance.UpdateTimeOfDay();
}
}
break;
case SleepState.WakingUp:
if (isPlayerControlled)
{
if (Time.unscaledTime - wakeStart < sleepCameraLerpDurationOut)
{
float alpha = (Time.unscaledTime - wakeStart) / sleepCameraLerpDurationOut;
cam.lookInput.y = Mathf.Lerp(cam.lookInput.y, 15, alpha);
}
}
break;
default:
break;
}
}
void StartSleep()
{
sleepState = SleepState.GettingIntoBed;
CurrentMoveSpeed = 0;
body.isKinematic = true;
ball.LockToGround = false;
FaceDirectionOfMovement = false;
billboard.faceCamera = false;
walk.enabled = false;
spriteLerp.moveTransform = billboard.transform;
if (TargetBed != null && Vector3.Distance(moveTransform.position, TargetBed.transform.position) < MaxBedLerpDistance)
{
Physics.IgnoreCollision(ball.Sphere, TargetBed.GetComponent <Collider>(), true);
moveTransform.parent = TargetBed.sleepTarget;
moveTransformLerp.moveTransform = moveTransform;
moveTransformLerp.targetTransform = TargetBed.sleepTarget;
moveTransformLerp.lerpType = LerpToTarget.LerpType.Curve;
moveTransformLerp.duration = LerpDuration;
moveTransformLerp.LerpRotation = false;
moveTransformLerp.OnLerpEnd = null;
moveTransformLerp.enabled = true;
spriteLerp.targetTransform = TargetBed.sleepTarget;
spriteLerp.WorldTarget = false;
}
else
{
spriteLerp.WorldTarget = true;
spriteLerp.targetPositionWorld = new Vector3(moveTransform.position.x, Global.Instance.GlobalSpriteOnGroundY, moveTransform.position.z);
spriteLerp.targetRotationForward = Vector3.up;
spriteLerp.targetRotationUp = moveTransform.forward;
}
spriteLerp.lerpType = LerpToTarget.LerpType.Curve;
spriteLerp.duration = LerpDuration;
spriteLerp.LerpRotation = true;
spriteLerp.enabled = true;
spriteLerp.OnLerpEnd = delegate
{
if (!SleepInterrupt)
{
sleepState = SleepState.Sleeping;
SleepStartTime = Time.time;
PlayFaceAnimation("sleep");
if (isPlayerControlled)
{
Time.timeScale = sleepTimescale;
start = Time.unscaledTime;
}
}
};
if (isPlayerControlled)
{
Zone zone = Global.Instance.GetZone(gameObject);
musicSource = zone.GetComponent <AudioSource>();
musicSource.clip = sleepyMusic;
musicSource.Play();
Global.Instance.AudioGoSleep(1);
cam = Global.Instance.cameraController;
cam.LookControlEnabled = false;
start = Time.unscaledTime;
todStart = Global.Instance.CurrentTimeOfDay;
}
}
public bool UpdateSleepState(Transform player, FirstPersonController fpsController)
{
switch (sleepState)
{
case SleepState.lyingGoingToSleep:
if (DreamController.loadedScene == Scenes.Cell && CheckPlayerFacing(player))
{
sleepState = SleepState.goingUp;
}
break;
case SleepState.lyingAwake:
r_dreamController.SetActiveScene();
if (CheckPlayerFacing(player))
{
sleepState = SleepState.goingUp;
}
break;
case SleepState.goingUp:
Vector3 standUpPosition;
Vector3 standUpRotation;
if (DreamController.loadedScene == Scenes.Cell)
{
standUpPosition = cellStandingTransform.position;
standUpRotation = cellStandingTransform.rotation.eulerAngles;
}
else if (DreamController.loadedScene != Scenes.Cell)
{
standUpPosition = dreamTransform.position;
standUpRotation = dreamTransform.rotation.eulerAngles;
}
else
{
standUpPosition = transform.position;
standUpRotation = Vector3.zero;
}
if (PlayerLerp(player, fpsController, standUpPosition, standUpRotation))
{
sleepState = SleepState.standing;
fpsController.ResetMouseLook();
}
return(true);
case SleepState.standing:
_controller.enabled = true;
break;
case SleepState.goingDown:
if (DreamController.loadedScene == Scenes.Cell)
{
sleepingPosition = cellSleepTransform.position;
sleepingRotation = cellSleepTransform.rotation.eulerAngles;
}
if (PlayerLerp(player, fpsController, sleepingPosition, sleepingRotation))
{
sleepState = SleepState.lyingGoingToSleep;
fpsController.ResetMouseLook();
}
return(true);
case SleepState.asleep:
//wait for a trigger from another script, such as text finishing on DreamController
break;
}
return(false);
}
//Vector3 zero = new Vector3(0, 0, 0);
/// <summary>
/// public function for sending the player to sleep.
/// </summary>
public void LieDown(Vector3 position, Vector3 rotation)
{
sleepState = SleepState.goingDown;
sleepingPosition = position;
sleepingRotation = rotation;
}
// Update is called once per frame
void Update()
{
sleepState = r_sleepingScript.sleepState;
switch (eye)
{
case Lid.opening:
if (progress < 1)
{
MoveEyelid(topEyelid_Rect, eyeOpenSpeed * 2);
MoveEyelid(bottomEyelid_Rect, -eyeOpenSpeed);
blur.blurSize = negProgress * blurSpeed;
r_mouseLook.EyelidSlow(false, 1);
}
else
{
eye = Lid.wakeBlink;
}
break;
case Lid.wakeBlink:
if (Blink(false))
{
eye = Lid.open;
}
break;
case Lid.open:
if (sleepState == SleepState.lyingGoingToSleep && !blurIsOn)
{
eye = Lid.sleepBlink;
}
break;
case Lid.sleepBlink:
if (Blink(true))
{
eye = Lid.closing;
}
break;
case Lid.closing:
if (sleepState != SleepState.lyingGoingToSleep)
{
eye = Lid.opening;
r_mouseLook.EyelidSlow(false, 1);
}
if (progress > 0.2f)
{
MoveEyelid(topEyelid_Rect, -eyeOpenSpeed * 1.5f);
MoveEyelid(bottomEyelid_Rect, eyeOpenSpeed);
blur.blurSize = negProgress * blurSpeed;
r_mouseLook.EyelidSlow(true, progress);
}
else
{
eye = Lid.closed;
r_mouseLook.EyelidSlow(false, 1);
//CLOSED EYELIDS POINT
//the PC is asleep. I need to send a message out.
r_sleepingScript.Sleep();
}
break;
case Lid.closed:
//this causes it to wait for sleeping script
if (sleepState == SleepState.lyingAwake)
{
eye = Lid.opening;
}
break;
}
progress_TopEyelid = topEyelid_Rect.anchoredPosition.y / (max_Y_TopEyelid - normal_Y_TopEyelid);
progress_BottomEyelid = bottomEyelid_Rect.anchoredPosition.y / (max_Y_BottomEyelid - normal_Y_BottomEyelid);
progress = (progress_BottomEyelid + progress_TopEyelid) / 2;
negProgress = Mathf.Abs(progress - 1);
}
private void UpdateSleepPhaseDisplay(object sender, SleepState phase)
{
this.sleepPhaseLabel.Text = phase.GetType().ToString();
}
