public void ChangeToCursor(BlobState _state)
{
if (cursorState != _state)
{
cursorState = _state;
switch (_state)
{
case BlobState.PASSIVE:
blobLine.colorGradient = passiveColour;
wobbleActive = 1;
lineWidth = passiveLineWidth;
break;
case BlobState.ACTIVE:
blobLine.colorGradient = activeColour;
wobbleActive = 0;
blobLine.widthMultiplier *= 2;
lineWidth = activeLineWidth;
break;
case BlobState.HIDDEN:
blobLine.colorGradient = passiveColour;
wobbleActive = 1;
blobLine.widthMultiplier *= 0.5f;
lineWidth = passiveLineWidth;
break;
}
}
}
private void Jump(Vector2 jumpVector)
{
// Can't jump in mid air
if (currentState != BlobState.ON_WALL)
{
Debug.Log("Not on wall - can't jump");
return;
}
// Didn't drag enough to register swipe
if (jumpVector.sqrMagnitude < minDragDistance)
{
Debug.Log("Not enough drag to jump");
return;
}
// Drag is towards the wall we're stuck on
if (!CheckJumpAngle(currentDirection, jumpVector, jumpAngleLimit))
{
Debug.Log("Trying to jump to wall we're on");
return;
}
// Jumping:
Debug.Log("Jumping to: " + jumpVector);
body.velocity = jumpVector.normalized * jumpSpeed;
currentState = BlobState.JUMPING;
animator.SetBool(animJumping, true);
ChangeSpriteDirection();
angleDisplay.Hide();
jumpsNum++;
}
private void OnTriggerEnter(Collider other)
{
if (other.tag == "JumpingPad")
{
JumpTrigger();
}
if (other.tag == "PositionTrigger")
{
TriggerNextPosition();
}
if (other.tag == "DeathZone")
{
state = BlobState.Dead;
RemoveFromList();
gameObject.SetActive(false);
if (blobDied != null)
{
blobDied(this);
}
}
if (other.tag == "WinningTrigger")
{
state = BlobState.InGoal;
Invoke("DisableRigidBody", UnityEngine.Random.Range(0.4f, 1f));
if (blobSaved != null)
{
blobSaved(this);
}
}
}
public void Restart()
{
gameOverScreen.SetActive(false);
angleDisplay.Hide();
body.position = startingPosition;
body.velocity = initialVelocity.normalized * jumpSpeed;
jumpsNum = 0;
facingUp = true;
currentState = initialState;
currentDirection = initialDirection;
// Allows starting with jump or with sticking to wall
if (currentState == BlobState.JUMPING)
{
animator.Play("Blob_Jump");
animator.SetBool(animJumping, true);
}
else
{
animator.Play("Blob_OnWall");
animator.SetBool(animJumping, false);
}
ChangeSpriteDirection();
}
void CopyMaterialToState(Material material, ref BlobState state)
{
state._FresnelBias = material.GetFloat("_FresnelBias");
state._FresnelPow = material.GetFloat("_FresnelPow");
state._FresnelIntensity = material.GetFloat("_FresnelIntensity");
state._ReflectionIntensity = material.GetFloat("_ReflectionIntensity");
}
/// <summary>
/// Stores <paramref name="state"/> in the repository with the specified <paramref name="key"/>.
/// If there is already a state stored with the same key, it will be replaced by <paramref name="state"/>.
/// </summary>
/// <typeparam name="T">The type of the state. The repository will store the state in the repository as a JSON-serialized string.</typeparam>
/// <param name="key">The state's key (case insensitive).</param>
/// <param name="state">The state to store.</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>A <see cref="Task"/> object that represents the asynchronous operation.</returns>
/// <exception cref="System.ArgumentNullException">This exception is thrown if the key or the state are null.</exception>
/// <exception cref="StateSerializationException">This exception is thrown if state serialization fails.</exception>
/// <exception cref="StateTooBigException">This exception is thrown if serialized state exceeds allowed length.</exception>
/// <exception cref="FailedToSaveStateException">This exception is thrown if state saving failed due to an internal error.</exception>
public Task StoreStateAsync <T>(string key, T state, CancellationToken cancellationToken)
{
Diagnostics.EnsureArgumentNotNull(() => key);
if (state == null)
{
throw new ArgumentNullException(nameof(state));
}
key = key.ToUpperInvariant();
this.tracer.TraceInformation($"Serializing state for Smart Detector {this.smartDetectorId} and rule {this.alertRuleResourceId}");
string serializedState;
try
{
serializedState = JsonConvert.SerializeObject(state);
}
catch (Exception ex)
{
throw new StateSerializationException(ex);
}
if (serializedState.Length > MaxSerializedStateLength)
{
throw new StateTooBigException(serializedState.Length, MaxSerializedStateLength);
}
this.tracer.TraceInformation($"Compressing state for Smart Detector {this.smartDetectorId} and rule {this.alertRuleResourceId}");
string compressedSerializedState = CompressString(serializedState);
BlobState blobState = new BlobState
{
Key = key,
SmartDetectorId = this.smartDetectorId,
AlertRuleResourceId = this.alertRuleResourceId,
State = compressedSerializedState
};
string serializedBlobState = JsonConvert.SerializeObject(blobState);
this.tracer.TraceInformation($"Uploading state to '{this.GenerateBlobName(key)}' for Smart Detector {this.smartDetectorId} and rule {this.alertRuleResourceId}");
Task <ICloudBlob> uploadBlobTask;
try
{
uploadBlobTask = this.cloudBlobContainerWrapper.UploadBlobAsync(this.GenerateBlobName(key), serializedBlobState, cancellationToken);
}
catch (Exception ex)
{
throw new FailedToSaveStateException(ex);
}
this.tracer.TraceInformation($"Successfully uploaded state for Smart Detector {this.smartDetectorId} and rule {this.alertRuleResourceId}");
return(uploadBlobTask);
}
// Change state.
public void ChangeState(BlobState newState)
{
if (currentState != null)
{
currentState.Leave();
}
currentState = newState;
currentState.Enter();
}
void LerpCurParamsTo(BlobState to)
{
float t = 8f * Time.deltaTime;
cur._FresnelBias = Mathf.MoveTowards(cur._FresnelBias, to._FresnelBias, t);
cur._FresnelPow = Mathf.MoveTowards(cur._FresnelPow, to._FresnelPow, t);
cur._FresnelIntensity = Mathf.MoveTowards(cur._FresnelIntensity, to._FresnelIntensity, t);
cur._ReflectionIntensity = Mathf.MoveTowards(cur._ReflectionIntensity, to._ReflectionIntensity, t);
cur._Saturation = Mathf.MoveTowards(cur._Saturation, to._Saturation, t);
}
public virtual void GetThrown(Vector3 startPosition, Vector3 endPosition)
{
transform.position = startPosition;
State = BlobState.Flying;
blobAnimator.SetBool("isFlying", true);
float duration = Vector3.Distance(startPosition, endPosition) / throwSpeed;
PlayThrowSound();
transform.DOJump(endPosition, throwHeight, 1, duration).OnComplete(OnLanding);
}
void OnCollisionEnter2D(Collision2D collision)
{
// Stop movement and jumping animation
body.velocity = Vector2.zero;
animator.SetBool(animJumping, false);
// Check collision direction
ContactPoint2D[] contactPoints = new ContactPoint2D[2];
collision.GetContacts(contactPoints);
Vector2 firstContact = contactPoints[0].point;
Vector2 secondContact = contactPoints[1].point;
// We've hit a vertical wall
if (Mathf.Approximately(firstContact.x, secondContact.x))
{
if (firstContact.x > transform.position.x)
{
currentDirection = Direction.LEFT;
}
else
{
currentDirection = Direction.RIGHT;
}
}
else // We've probably hit a horizontal wall
{
if (firstContact.y > transform.position.y)
{
currentDirection = Direction.DOWN;
}
else
{
currentDirection = Direction.UP;
}
}
if (collision.transform.CompareTag("Spike"))
{
currentState = BlobState.DEAD;
animator.SetTrigger(animDied);
gameOverScreen.SetActive(true);
}
if (collision.transform.CompareTag("Wall"))
{
currentState = BlobState.ON_WALL;
}
ChangeSpriteDirection();
}
// Update is called once per frame
void Update()
{
BlobState targetState = (playerController.isMuted) ? muted : normal;
LerpCurParamsTo(targetState);
CopyParamsToBlob();
//player health
float playerHealth = 1f - (playerController.playerHealth / 100f);
blobMat.material.SetFloat("_NoiseAmp", dyingNoiseAmp.Evaluate(playerHealth));
blobMat.material.SetFloat("_NoiseFreq", dyingNoiseFreq.Evaluate(playerHealth));
blobMat.material.SetFloat("_SpikeAmp", dyingSpikeAmp.Evaluate(playerHealth));
blobMat.material.SetFloat("_Size", dyingSize.Evaluate(playerHealth));
}
private IEnumerator Wander()
{
blobState = BlobState.Wandering;
//get random direction
var randomAngle = Random.Range(0f, Mathf.PI * 2f);
var randomDirection = new Vector2(Mathf.Sin(randomAngle), Mathf.Cos(randomAngle)).normalized;
//wander in random direction for x seconds
var wanderTime = Random.Range(minWanderTime, maxWanderTime);
while (wanderTime > 0)
{
_rigidbody.AddForce(randomDirection * moveSpeed, ForceMode.VelocityChange);
wanderTime -= Time.deltaTime;
yield return(null);
}
StartCoroutine(Wander());
}
private IEnumerator GetFood(FruitLogic targetFoodScript)
{
blobState = BlobState.MovingToFood;
// move towards found food
var blobPositon = transform.position;
var foodPosition = targetFoodScript.transform.position;
var distanceToFood = Vector3.Distance(blobPositon, foodPosition);
var vectorTowardsFood = (blobPositon - foodPosition).normalized;
while (distanceToFood > eatingRange)
{
_rigidbody.AddForce(vectorTowardsFood * moveSpeed, ForceMode.VelocityChange);
distanceToFood = Vector3.Distance(transform.position, targetFoodScript.transform.position);
vectorTowardsFood = (blobPositon - foodPosition).normalized;
yield return(null);
}
StartCoroutine(EatFood(targetFoodScript));
}
internal virtual void SearchInteractables()
{
RaycastHit[] hits = Physics.SphereCastAll(transform.position, interactionRange, Vector3.up, 0, interactableLayerMask);
List <EnemyController> nearbyEnemies = new List <EnemyController>();
List <Interactable> nearbyInteractables = new List <Interactable>();
foreach (var hit in hits)
{
EnemyController enemy = hit.collider.GetComponent <EnemyController>();
if (enemy != null)
{
nearbyEnemies.Add(enemy);
continue;
}
Interactable interactable = hit.collider.GetComponent <Interactable>();
if (interactable != null && interactable.CanBeAssigned(this))
{
nearbyInteractables.Add(interactable);
}
}
if (nearbyEnemies.Count > 0)
{
// Attack closest enemy
var closestEnemy = Helper.GetClosestObject(nearbyEnemies.ToArray(), transform.position);
currentInteractable = closestEnemy;
State = closestEnemy.AssignBlob(this);
return;
}
if (nearbyInteractables.Count > 0)
{
// Interact with closest interactable
currentInteractable = Helper.GetClosestObject(nearbyInteractables.ToArray(), transform.position);
State = currentInteractable.AssignBlob(this);
return;
}
}
internal static HandleRef getCPtr(BlobState obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
public virtual void StartFollowing(Transform target)
{
State = BlobState.Following;
followTarget = target;
PlayAudioClip(callSounds[Random.Range(0, callSounds.Length)]);
}
public virtual void StartInteracting(Interactable target)
{
State = BlobState.Interacting;
currentInteractable = target;
PlayAudioClip(callSounds[Random.Range(0, callSounds.Length)]);
}
public virtual void OnLanding()
{
State = BlobState.Idle;
blobAnimator.SetBool("isFlying", false);
SearchInteractables();
}
private void Awake()
{
rb = GetComponent <Rigidbody>();
state = BlobState.Alive;
}
internal void InitializeBaseBlob()
{
State = BlobState.Idle;
navMeshAgent.speed = movementSpeed;
}
internal static HandleRef getCPtr(BlobState obj)
{
return((obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr);
}
/// <summary>
/// Gets a Smart Detector's state that was saved with <paramref name="key"/>.
/// If state does not exist, returns <code>default(<typeparamref name="T"/>)</code>.
/// </summary>
/// <typeparam name="T">The type of the state. The repository will try to JSON-deserialize the stored state to this type.</typeparam>
/// <param name="key">The key that was used to store the state (case insensitive).</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns>A <see cref="Task"/> object that represents the asynchronous operation, returning the requested state.</returns>
/// <exception cref="System.ArgumentNullException">This exception is thrown if the key is null.</exception>
/// <exception cref="StateSerializationException">This exception is thrown if state deserialization fails.</exception>
/// <exception cref="FailedToLoadStateException">This exception is thrown if state retrieval failed due to an internal error.</exception>
public async Task <T> GetStateAsync <T>(string key, CancellationToken cancellationToken)
{
Diagnostics.EnsureArgumentNotNull(() => key);
key = key.ToLowerInvariant();
this.tracer.TraceInformation($"Downloading state from '{this.GenerateBlobName(key)}' for {smartDetectorId}");
string serializedBlobState = null;
try
{
serializedBlobState = await this.cloudBlobContainerWrapper.DownloadBlobContentAsync(this.GenerateBlobName(key), cancellationToken);
}
catch (StorageException ex) when((HttpStatusCode)ex.RequestInformation.HttpStatusCode == HttpStatusCode.NotFound)
{
this.tracer.TraceInformation("State not found in the repository, returning empty state");
return(default(T));
}
catch (Exception ex)
{
throw new FailedToLoadStateException(ex);
}
this.tracer.TraceInformation($"Deserializing state for {smartDetectorId}");
BlobState blobState = null;
try
{
blobState = JsonConvert.DeserializeObject <BlobState>(serializedBlobState);
}
catch (Exception ex)
{
this.tracer.ReportException(ex);
this.tracer.TraceError("Blob state deserialization failed, trying to delete the state and returning empty state");
// Try to delete the state
await this.TryDeleteStateAsync(key, cancellationToken);
return(default(T));
}
if (string.Equals(blobState.SmartDetectorId, this.smartDetectorId) == false || string.Equals(blobState.Key, key) == false)
{
this.tracer.TraceError("State does not match expected Smart Detector id or key, trying to delete the state and returning empty state");
// Try to delete the state
await this.TryDeleteStateAsync(key, cancellationToken);
return(default(T));
}
if (string.IsNullOrWhiteSpace(blobState.State))
{
return(default(T));
}
string compressedSerializedState = blobState.State;
this.tracer.TraceInformation($"Decompressing state for {smartDetectorId}");
string serializedState = DecompressString(compressedSerializedState);
T state = default(T);
try
{
state = JsonConvert.DeserializeObject <T>(serializedState);
}
catch (Exception ex)
{
throw new StateSerializationException(ex);
}
this.tracer.TraceInformation($"Successfully retrieved state for {smartDetectorId}");
return(state);
}
