/// <summary>
/// Event when exiting a state
/// </summary>
public void OnStateExit(PetState state, PetState toState)
{
switch (state)
{
case PetState.Default:
{
MaxStableMoveSpeed = 7f;
StopActiveCoroutine(ForceDeviationChangeCoroutine);
break;
}
case PetState.Crouched:
{
MaxStableMoveSpeed = 7f;
StopActiveCoroutine(ForceDeviationChangeCoroutine);
Motor.SetCapsuleDimensions(0.5f, 1f, .25f); //Scales the hitbox.
MeshRoot.localScale = new Vector3(1f, .5f, 1.2f); //Scales the mesh root.
break;
}
case PetState.FollowPath:
{
_canCheckPathfinding = true;
break;
}
}
}
private void OnRealMinuteChanged(object sender, MinuteChangedEventArgs e)
{
PetState state = new PetState(Pet.Mood, Pet.Satiety, Pet.CleanessRate, Pet.Health);
PetUpdateParams param = PetUpdateUtil.CreateHourParamsFromPetState(state);
Pet.UpdatePetFromParams(param);
}
public static PetUpdateParams CreateHourParamsFromPetState(PetState state)
{
var petParams = new PetUpdateParams();
ConfigureHourParamsFromPetState(petParams, state);
return(petParams);
}
/// <summary>
/// Event when exiting a state
/// </summary>
public void OnStateExit(PetState state, PetState toState)
{
switch (state)
{
case PetState.Default:
{
switch (currentDefaultState)
{
case PetDefaultState.Run:
{
break;
}
case PetDefaultState.Walk:
{
break;
}
}
break;
}
case PetState.Crouched:
{
Motor.SetCapsuleDimensions(0.5f, 1f, .25f); //Scales the hitbox.
MeshRoot.localScale = new Vector3(1f, .5f, 1.2f); //Scales the mesh root.
break;
}
}
}
public virtual void Create(string _prefabName, Vector3 _offset)
{
if (!this.actorPtr || this.parentObj == null || this.parentObj.transform == null)
{
return;
}
this.offset = _offset;
this.offsetDistance = Vector3.Distance(new Vector3(0f, 0f, 0f), this.offset);
this.deltaTime = 0;
Vector3 pos = this.parentObj.transform.localToWorldMatrix.MultiplyPoint(this.offset);
this.meshObj = MonoSingleton <SceneMgr> .GetInstance().GetPooledGameObjLOD(_prefabName, false, SceneObjType.ActionRes, pos, this.parentObj.transform.rotation);
if (this.meshObj != null)
{
this.animSet = this.meshObj.GetComponent <Animation>();
if (this.animSet != null)
{
this.animSet.Play("Idle");
}
this.petTrans = this.meshObj.transform;
this.parentTrans = this.parentObj.transform;
this.bActive = true;
this.curState = PetState.Idle;
return;
}
this.bActive = false;
}
//public void GetPlayerState()
/// <summary>
/// Event when entering a state
/// </summary>
public void OnStateEnter(PetState state, PetState fromState)
{
switch (state)
{
case PetState.Default:
{
canChangeDeviationDirection = true;
_canForceDeviation = true;
MaxStableMoveSpeed = 7f;
targetMoveSpeed = 7f;
_canSetFollowPoint = true;
//radiusSize = 5f;
currentDefaultState = PetDefaultState.Idle;
break;
}
case PetState.Crouched:
{
canChangeDeviationDirection = true;
_canForceDeviation = true;
MaxStableMoveSpeed = 3f;
_canSetFollowPoint = true;
//radiusSize = 5f;
currentDefaultState = PetDefaultState.Idle;
StableMovementSharpness = 7f;
//Set dimensions and scale
Motor.SetCapsuleDimensions(0.5f, 1f, 0.25f); //Scales the hitbox.
MeshRoot.localScale = new Vector3(1f, 0.35f, 1.2f); //Scales the mesh root.
break;
}
}
}
/// <summary>
/// Event when exiting a state
/// </summary>
public void OnStateExit(PetState state, PetState toState)
{
switch (state)
{
case PetState.Default:
{
MaxStableMoveSpeed = 7f;
break;
}
case PetState.Crouched:
{
MaxStableMoveSpeed = 3f;
Motor.SetCapsuleDimensions(0.5f, 1f, .25f); //Scales the hitbox.
MeshRoot.localScale = new Vector3(1f, .5f, 1.2f); //Scales the mesh root.
break;
}
case PetState.MoveStraightToPlayer:
{
walkRadius = 3.75f; //3.2f
break;
}
case PetState.FollowPath:
{
_canCheckPathfinding = true;
break;
}
}
}
private void Point()
{
_petState = PetState.Targeted;
PlayerWatchData playerWatchData = _camera.GetComponent <PlayerWatchData>();
if (playerWatchData)
{
(GameObject hit, Transform potentialTarget, float touchDistance) = playerWatchData.GetRaycast();
if (hit.GetComponent <ObjectiveCompanionReachPoint>() || hit.GetComponent <Bush>())
{
_currentTarget = potentialTarget;
_interactionDistance = touchDistance;
Move(potentialTarget, touchDistance);
}
else
{
Debug.Log(string.Format("Hit missed. Reason: {0} {1} {2}", hit, hit.GetComponent <ObjectiveCompanionReachPoint>(), potentialTarget));
_petState = PetState.Follow;
}
}
else
{
_petState = PetState.Follow;
return;
}
}
// If Player Health is below x, the Pet will heal the Player to for x seconds.
private void PetHeal(Vector3 _petDesti)
{
if (!HasPetHeal)
{
// Pet will walk to Player smoothly.
transform.position = Vector2.SmoothDamp(transform.position, _petDesti, ref currentVelocity, followTimer, maxSpeed, Time.deltaTime);
// Distance between Player and Pet.
distanceApart = (transform.position - _petDesti).magnitude;
if (distanceApart < PetHealRange)
{
// Activate Healing Sprite
playerHealingSprite.SetActive(true);
CanActivateSprite = true;
// Increase Player Health from Pet's HP.
playerStats.Health += addPlayerHP;
health -= addPlayerHP;
HasPetHeal = true;
}
}
if (HasPetHeal)
{
// Start the cool down timer.
CanHealCoolDown = true;
// Changing to Guard State.
petState = PetState.GUARD;
}
}
private static void ConfigureHourParamsFromMood(PetUpdateParams petParams, PetState petState)
{
if (petState.Mood < GameConstants.CriticalLimit)
{
petParams.HealthDifference -= 5;
}
}
void OutOfRange()
{
Debug.Log("Pet OutOfRange");
transform.position = PlayerTransform.initialPos;
CurrentState = PetState.Idle;
ResetAttack();
}
// If there Player Health is 1/2, Pet State will deal damage to the nearest Enemy.
private void PetAttack(GameObject _closest)
{
// Distance between Enemy and Pet.
distanceApart = (transform.position - _closest.transform.position).magnitude;
// If Pet is not within Attack Range, walk to Enemy smoothly.
if (distanceApart > PetAttackRange)
{
// Pet will walk to Enemy smoothly.
transform.position = Vector2.SmoothDamp(transform.position, _closest.transform.position, ref currentVelocity, followTimer, maxSpeed, Time.deltaTime);
}
// Pet is within its Attack Range.
else if (distanceApart < PetAttackRange)
{
// Minus Enemy Health.
if (!HasPetAttack)
{
_closest.GetComponent <SkeletonEnemyManager>().Health -= (Attack * 0.5f);
HasPetAttack = true;
}
else if (HasPetAttack)
{
HasPetAttack = false;
}
if (_closest.GetComponent <SkeletonEnemyManager>().Health <= 0f)
{
petState = PetState.GUARD;
}
}
}
void ChaseTarget(Vector3 targetPosition, float chaseInterval, float minDistance)
{
if (CurrentState == PetState.Mutate)
{
return;
}
//var masterPosition = petMaster.position;
targetPosition.y = transform.position.y;
if (CurrentState != PetState.Chase && !IsCloseEnough(targetPosition, minDistance + chaseInterval))
{
CurrentState = PetState.Chase;
}
if (IsCloseEnough(targetPosition, minDistance))
{
CurrentState = PetState.None;
anim.SetFloat(Hash.Speed, 0f);
return;
}
if (CurrentState == PetState.Chase)
{
transform.LookAt(targetPosition);
anim.SetFloat(Hash.Speed, 3.0f);
}
}
void StateManager()
{
activeStateName = PetRunFSM.ActiveStateName;
updateStateHistory(activeStateName);
foreach (PetState s in states)
{
if (s.GetName() == activeStateName)
{
currentState = s;
}
}
//If the state has changed since last frame, run that state's init function
if (previousState != currentState)
{
//Debug.Log("Initializing " + currentState.GetName() + " State");
currentState.Init();
previousState = currentState;
}
if (currentState != null)
{
if (currentState.GetType() == typeof(OutOfEnergyState))
{
(currentState as OutOfEnergyState).SetPreviousState(getPreviousState());
}
currentState.Run();
}
}
void Start()
{
anim = GetComponent <Animator>();
agent = GetComponent <UnityEngine.AI.NavMeshAgent>();
state = GetComponent <PetState>();
// Don’t update position automatically, happens during OnAnimator.
agent.updatePosition = false;
}
private void Start()
{
Button btn = yourButton.GetComponent <Button>();
btn.onClick.AddListener(OnMouseDown);
PS = GameObject.FindGameObjectWithTag("Pet").GetComponent <PetState>();
}
/// <summary>
/// Handles movement state transitions and enter/exit callbacks
/// </summary>
public void TransitionToState(PetState newState)
{
PetState tmpInitialState = CurrentPetState; //Get current state.
OnStateExit(tmpInitialState, newState); //Do the OnStateExit stuff from current state to new state.
CurrentPetState = newState; //Current state = new state.
Debug.Log("Pet's state set to " + newState + ".");
OnStateEnter(newState, tmpInitialState); //Do the OnStateEnter stuff to new state from the last state.
}
public void PlayMotion(PetState state)
{
if (!IsMine)
{
return;
}
_photonView.RPC(RPCDefine.PetRPC.GetRPCMethod(RPCDefine.PetRPC.RPCEnum.PlayMotion), PhotonTargets.All, state);
}
private void EnterState(PetState newState)
{
State = newState;
var js = GetComponent <Jumping>();
switch (newState)
{
case PetState.Satisfied:
IdleTime = Random.Range(MinIdleTime, MaxIdleTime);
if (null != DemandIcon)
{
DemandIcon.sprite = null;
}
if (null != js)
{
js.Active = false;
}
break;
case PetState.Hungry:
PlayPetSound();
if (null != DemandIcon)
{
DemandIcon.sprite = HungrySprite;
}
if (null != js)
{
js.Active = false;
}
break;
case PetState.Eating:
EatingTime = Random.Range(MinEatingTime, MaxEatingTime);
if (null != DemandIcon)
{
DemandIcon.sprite = null;
}
if (null != js)
{
js.Active = false;
}
break;
case PetState.NeedsAShit:
PlayPetSound();
if (null != DemandIcon)
{
DemandIcon.sprite = NeedsShitSprite;
}
if (null != js)
{
js.Active = true;
}
break;
}
}
//When a path can't be created to the enemy...
private IEnumerator CantReachEnemyDelay()
{
CanReachEnemy = false;
CurrentState = PetState.Wait;
Debug.Log("Entered wait state");
CanCheckDist = false;
yield return(CustomTimer.Timer(.75f));
CanCheckDist = true;
}
// Use this for initialization
void Start()
{
CurrentState = PetState.None;
anim = GetComponent <Animator>();
petConstructor = GetComponent <ARPetConstructor>();
//anim.CrossFade(idle.name);
currentTarget = petMaster;
}
public static AnimationClip GetPetMotion(PetState state)
{
if (state == PetState.None)
{
Debug.LogError("Invalid Pet State For Animation Clip Resource Loading");
return(null);
}
return(Resources.Load <AnimationClip>(CLIP_PATH[(int)state + 1]));
}
// Similar to IDLE state of Enemy, Pet will stay still when it's near the Player and "Guard" it.
private void PetGuard(Vector3 _petDesti)
{
// Distance between Player and Pet.
distanceApart = (transform.position - _petDesti).magnitude;
// If Player is out of Pet range, change to FOLLOW.
if (distanceApart > PetGuardRange && distanceApart < PetFollowRange)
{
petState = PetState.FOLLOW;
}
}
void Start()
{
CanAttack = true;
CurrentState = PetState.Idle;
TargetTransform.initialPos = PlayerTransform.initialPos;
CanFollowPath.initialBool = true;
PetIsAttacking.initialBool = false;
EnemyIsInLOS.initialBool = false;
CanGetReposDir = true;
CanReachEnemy = true;
CanCheckDist = true;
CanAttackDelay = true;
}
/// <summary>
/// Создать питомца
/// </summary>
/// <param name="petId">Идентификатор питомца</param>
/// <param name="organisationId">Идентификатор организации</param>
/// <param name="name">Имя питомца</param>
/// <param name="gender">Пол питомца</param>
/// <param name="type">Тип питомца</param>
/// <param name="petState">Статус питомца</param>
/// <param name="afterPhotoLink">Ссылка на фотку после</param>
/// <param name="beforePhotoLink">Ссылка на фотку До</param>
/// <param name="mdShortBody">Краткий текст</param>
/// <param name="mdBody">Длинный текст</param>
/// <param name="cancellationToken">Токен признака отмены запроса</param>
/// <exception cref="PetAlreadyExistsException"></exception>
/// <exception cref="IdempotencyCheckException"></exception>
/// <returns></returns>
public async Task <Guid> Create(
Guid petId,
Guid organisationId,
String name,
PetGender gender,
PetType type,
PetState petState,
String?afterPhotoLink,
String?beforePhotoLink,
String?mdShortBody,
String?mdBody,
CancellationToken cancellationToken)
{
var pet = await _petRepository.GetAsync(petId : petId, organisation : (Organisation)organisationId, cancellationToken : cancellationToken);
// если с таким id пет уже был найден, то выполняем проверку идемпотентности
if (pet is not null)
{
if (pet.Gender != gender ||
pet.Type != type ||
pet.PetState != petState ||
!name.Equals(pet.Name, StringComparison.InvariantCultureIgnoreCase) ||
(mdShortBody is not null && !mdShortBody.Equals(pet.MdShortBody, StringComparison.InvariantCultureIgnoreCase)) ||
(mdBody is not null && !mdBody.Equals(pet.MdBody, StringComparison.InvariantCultureIgnoreCase))
)
{
throw new PetAlreadyExistsException(petId);
}
return(pet.Id);
}
await _petRepository.SaveAsync(
pet : new Entity.Pet(
petId: petId,
organisation: new Organisation(organisationId),
name: name,
gender: gender,
type: type,
petState: petState,
afterPhotoLink: afterPhotoLink,
beforePhotoLink: beforePhotoLink,
mdShortBody: mdShortBody,
mdBody: mdBody,
createDate: _dateTimeGetter.Get(),
updateDate: _dateTimeGetter.Get()),
cancellationToken : cancellationToken
);
return(petId);
}
private void OnKill()
{
state = PetState.Dead;
if (animator != null)
{
animator.SetTrigger("Death");
}
if (onDeath != null)
{
onDeath.Invoke();
}
}
void SearchNextPerformer()
{
currentState = TurnState.PROCESSING;
PetState PS = BS.notPerformer.GetComponent <PetState>();
PS.currentState = PetState.TurnState.PROCESSING;
for (int i = 0; i < BS.MonstersInBattle.Count; i++)
{
BS.notPerformers = GameObject.Find(BS.MonstersInBattle[i].name);
MonsterState MS = BS.notPerformers.GetComponent <MonsterState>();
MS.currentState = MonsterState.TurnState.PROCESSING;
}
}
public virtual void OnUse()
{
this.bActive = false;
this.curAnimName = null;
this.deltaTime = 0;
this.moveDir = Vector3.zero;
this.moveSpeed = 0f;
this.curState = PetState.Idle;
this.offset = Vector3.zero;
this.offsetDistance = 0f;
this.meshObj = null;
this.animSet = null;
this.parentObj = null;
this.actorPtr.Release();
}
public static void SetState(PetState state)
{
if (petState == state)
{
return;
}
petState = state;
ModEntry.Log("Set state to " + petState);
switch (state)
{
case PetState.Vanilla:
throwing = false;
break;
case PetState.CatchingUp:
break;
case PetState.Waiting:
Sit();
CurrentPath.Clear();
break;
case PetState.Chasing:
SetTimer();
break;
case PetState.WaitingToFetch:
SetTimer();
break;
case PetState.Fetching:
SetTimer();
break;
case PetState.Retrieve:
throwing = false;
break;
}
if (state != PetState.Retrieve && state != PetState.Waiting && Stick != null)
{
Game1.createItemDebris(Stick, GetPet().Position, 5, Game1.currentLocation);
Stick = null;
}
}
public void WanderAnimation()
{
PetState petState = (PetState)this.GetComponent(typeof(PetState));
if (!this.wanderFirstTime)
{
if (!this.get_animation().IsPlaying("WanderActions[0].anim"))
{
this.get_animation().CrossFade(this.WanderActions[0].anim);
}
float num = (float)20;
float num2 = 0f;
if (Time.get_time() - this.timeLastTurn > (float)4)
{
num2 = (float)0;
this.randomRot = (float)Random.Range(25, 45);
this.startDirection = this.get_transform().get_rotation();
this.newDirection = Quaternion.get_identity();
float num3 = this.get_transform().get_eulerAngles().y + this.randomRot;
this.newDirection.set_eulerAngles(new Vector3((float)0, num3, (float)0));
int num4 = Random.Range(1, 3);
this.turnIncr = (float)num4 * num / Mathf.Abs(this.randomRot);
this.turnIncr = (float)1 / Mathf.Abs(this.randomRot);
this.turnTimer = this.turnIncr;
this.timeLastTurn = Time.get_time();
}
if (this.turnTimer < this.randomRot)
{
this.get_transform().set_rotation(Quaternion.Slerp(this.startDirection, this.newDirection, this.turnTimer));
this.get_transform().set_eulerAngles(new Vector3((float)0, this.get_transform().get_eulerAngles().y, (float)0));
this.turnTimer += this.turnIncr;
if (this.turnTimer >= this.randomRot)
{
this.randomRot = (float)0;
this.turnTimer = (float)0;
}
}
Vector3 vector = this.get_transform().TransformDirection(Vector3.get_forward());
Vector3 vector2 = vector * this.moveSpeed;
UnityRuntimeServices.Invoke(this.GetComponent(typeof(CharacterController)), "SimpleMove", new object[]
{
vector2
}, typeof(MonoBehaviour));
}
}
public int GetPetState()
{
PetState petState = (PetState)this.GetComponent(typeof(PetState));
IdleLogic idleLogic = (IdleLogic)this.GetComponent(typeof(IdleLogic));
FollowLogic followLogic = (FollowLogic)this.GetComponent(typeof(FollowLogic));
WanderLogic wanderLogic = (WanderLogic)this.GetComponent(typeof(WanderLogic));
int result = this.indexAction;
this.useTimer = true;
if (this.calledByPlayer != 0)
{
float num = Vector3.Distance(this.get_transform().get_position(), this.owner.get_transform().get_position());
if (num <= this.ownerDist && RuntimeServices.ToBool(RuntimeServices.InvokeBinaryOperator("op_LessThan", RuntimeServices.GetProperty(RuntimeServices.GetProperty(this.owner.GetComponent(typeof(CharacterController)), "velocity"), "magnitude"), 1)))
{
result = 0;
}
else if (num > this.ownerDist)
{
result = 2;
}
this.useTimer = false;
}
else if (this.calledByPlayer == 0 && this.indexAction == 2)
{
result = Random.Range(0, 2);
}
else if (Time.get_time() - (float)this.stateStartTime > this.stateTimeOut)
{
int num2 = this.indexAction;
if (num2 == 0)
{
result = 1;
}
else if (num2 == 1)
{
result = 0;
}
else
{
result = this.indexAction;
}
}
return(result);
}