private void adjustPositionOverlap()
{
ContactFilter2D filter = new ContactFilter2D();
filter.layerMask = LayerMask.GetMask("Enemies");
filter.useLayerMask = true;
Collider2D[] results = new Collider2D[10];
bodyCollider.OverlapCollider(filter, results);
foreach (var result in results)
{
if (result)
{
if (result.tag.Contains("Skeleton"))
{
if (Math.Sign(transform.localScale.x) == Math.Sign(result.gameObject.transform.localScale.x))
{
float rand = UnityEngine.Random.value;
if (rand <= 0.5)
{
MoveBackward();
if (isAlerted && canSeePlayer())
{
FacePlayer();
}
}
}
}
}
}
}
void Fight()
{
ContactFilter2D contactFilter = new ContactFilter2D();
contactFilter.SetLayerMask(LayerMask.GetMask("Enemy"));
int numColliders = 10;
Collider2D[] colliders = new Collider2D[numColliders];
playerCC.OverlapCollider(contactFilter, colliders);
timeLeft -= Time.deltaTime;
if (!timerOn)
{
timerOn = true; timeLeft = .3f; animator.SetTrigger("Fight");
}
if (timerOn && timeLeft <= 0)
{
timerOn = false;
}
if (colliders[0] != null)
{
if (colliders.Any(x => x.GetComponent <Monster>()))
{
Monster monster; monster = colliders[0].GetComponent <Monster>(); monster.ReceiveDamage();
}
}
attack = false;
}
private void HandleTriggers()
{
//set up the filter.
ContactFilter2D filter = new ContactFilter2D();
filter.useTriggers = true;
filter.layerMask = groundMask;
Collider2D[] results = new Collider2D[5];
//get the overlap of this collider with others.
Physics2D.queriesHitTriggers = true;
int c = collider.OverlapCollider(filter, results);
//reset the verify buffer
triggerVerifyBuffer.Clear();
for (int i = 0; i < c; i++)
{
var col = results[i];
//handle trigger colliders.
if (col.isTrigger)
{
int triggerID = col.GetInstanceID();
triggerVerifyBuffer.Add(triggerID);
//trigger not yet registered?
if (!knownTriggers.Contains(triggerID))
{
//a benefit of writing our own "custom physics" is that we can exchange this for, or just add entirely new messages or events.
col.SendMessage("OnTriggerEnter2D", collider, SendMessageOptions.DontRequireReceiver);
instanceIDToCollider.Add(triggerID, col);
//print("found trigger");
knownTriggers.Add(triggerID);
}
}
}
//verify knownTriggers with the buffer.
//I know linq ew, but its much simpler rn, not too concerned with optimization, this game is super small.
//knownTriggers = new List<int>(knownTriggers.Where(item => triggerVerifyBuffer.Contains(item)));
//Send OnTriggerExit2D to any objects required.
List <int> verifiedTriggers = new List <int>(5);
int triggerCount = knownTriggers.Count;
for (int i = 0; i < triggerCount; i++)
{
int id = knownTriggers[i];
if (triggerVerifyBuffer.Contains(id))
{
verifiedTriggers.Add(id);
}
else
{
instanceIDToCollider[id].SendMessage("OnTriggerExit2D", collider, SendMessageOptions.DontRequireReceiver);
instanceIDToCollider.Remove(id);
}
}
knownTriggers = verifiedTriggers;
}
// Path points
void LoadPoints(PathTemplate template)
{
points.Clear();
// Create a lookup table of all points, indexed by local position.
foreach (Transform point in template.transform)
{
if (point.CompareTag("Point"))
{
points[point.localPosition] = new Point()
{
position = point.position,
connections = new List <Point>(),
};
}
}
// For each line, find and connect the points touching its collider.
LayerMask pointMask = LayerMask.GetMask("Points");
ContactFilter2D pointFilter = new ContactFilter2D();
pointFilter.SetLayerMask(pointMask);
foreach (Transform line in template.transform)
{
if (line.CompareTag("Line"))
{
Vector2 lineVector = line.localRotation * line.localScale;
CapsuleCollider2D lineCollider = line.GetComponent <CapsuleCollider2D>();
lineCollider.size = new Vector2(1, 1 + 1 / line.localScale.y);
// Find all point colliders touching the line.
Collider2D[] pointColls = new Collider2D[10];
lineCollider.OverlapCollider(pointFilter, pointColls);
// Convert to a list of points touching the line, ordered by their position along the line.
Point[] linePoints = pointColls
.Where(coll => coll != null && coll.transform.parent == template.transform)
.Select(coll => points[coll.transform.localPosition])
.OrderBy(point => Vector2.Dot(point.position - line.position, lineVector))
.ToArray();
// Connect each point to its adjacent points.
for (int i = 0; i < linePoints.Length; i++)
{
if (i > 0)
{
linePoints[i].connections.Add(linePoints[i - 1]);
}
if (i < linePoints.Length - 1)
{
linePoints[i].connections.Add(linePoints[i + 1]);
}
}
}
}
}
public void Attack()
{
Collider2D[] colliders = new Collider2D[1];
if (capsuleCollider.OverlapCollider(filter, colliders) > 0)
{
PlayerController player = colliders[0].GetComponent <PlayerController>();
if (player != null)
{
player.GetDamage(damage);
}
}
}
// Update is called once per frame
protected virtual void Update()
{
// rilevo collisioni
capsuleCollider.OverlapCollider(filter, hits);
// itero le collisioni rilevate, applico l'azione in base alla collisione e pulisco l'array delle collisioni
for (int i = 0; i < hits.Length; i++)
{
if (hits[i] == null)
{
continue;
}
OnCollide(hits[i]);
hits[i] = null;
}
}
private void Update()
{
results = new Collider2D[20];
check.OverlapCollider(filter, results);
for (int i = 0; i < results.Length; i++)
{
if (results[i] != null)
{
if (results[i].gameObject.tag == "interactable")
{
if (results[i].gameObject.GetComponent <Door>() != null)
{
if (!in_proximity.Contains(results[i].gameObject))
{
results[i].gameObject.GetComponent <Door>().showArrow(true);
in_proximity.Add(results[i].gameObject);
}
}
}
}
}
prox = false;
if (in_proximity.Count > 0)
{
for (int j = 0; j < results.Length; j++)
{
if (results[j] != null)
{
if (in_proximity[0] == results[j].gameObject)
{
prox = true;
}
}
}
if (!prox)
{
in_proximity[0].gameObject.GetComponent <Door>().showArrow(false);
in_proximity.Remove(in_proximity[0]);
}
}
}
private void HandleJumping()
{
if (isJumping)
{
// If we're already jumping, see if we need to continue
isJumpingHitsCount = _c.OverlapCollider(isJumpingFilter, isJumpingHits);
isForcedJumping = false;
for (int i = 0; i < isJumpingHitsCount; i++)
{
if (isJumpingHits[0].gameObject.layer == LayerManager.Water)
{
isForcedJumping = true;
break;
}
}
if (!isForcedJumping)
{
isJumping = Input.GetButton(JUMP_BUTTON);
}
}
else
{
isJumping = Input.GetButton(JUMP_BUTTON);
}
if (isJumping)
{
GameState.SpendFuel(JumpFuelCost * Time.deltaTime);
}
gameObject.layer = isJumping ? LayerManager.PlayerJumping : LayerManager.Player;
if (isJumping)
{
Soundboard.PlayThrusters(Time.deltaTime, 0.25f);
}
else
{
Soundboard.ResetThrusters();
}
}
public List <GameObject> interaction()
{
results = new Collider2D[30];
check.OverlapCollider(filter, results);
return_objects = new List <GameObject>();
for (int i = 0; i < results.Length; i++)
{
if (results[i] != null)
{
if (results[i].gameObject.tag == "interactable")
{
if (results[i].gameObject.GetComponent <Interactable>() != null)
{
return_objects.Add(results[i].gameObject);
}
}
}
}
return(return_objects);
}
// --------------------------------------
#region Collision Avoidance - both TCAS and MTCD
void TCASCollisionCheck()
{
// Debug.Log("Check called");
TCASThreatList.Clear();
ContactFilter2D filter = new ContactFilter2D();
filter.SetLayerMask(TCASLayerMask);
Collider2D[] contacts = new Collider2D[10];
int tcasObjects = tcas.OverlapCollider(filter, contacts);
if (tcasObjects <= 1)
{
rightTCASThrust = 0f;
leftTCASThrust = 0f;
forwardTCASThrust = 0f;
backwardsTCASThrust = 0f;
return;
}
// Debug.Log("TCAS contacts " + (tcasObjects - 1) + " " + contacts.Length);
// Put all valid threats into CollisionThreat list
for (int i = 0; i < tcasObjects; i++)
{
if (contacts[i] && contacts[i].gameObject.name != gameObject.name)
{
// Debug.Log("TCAS contact: " + contacts[i].name);
TCASthreatPosition.x = gameObject.transform.InverseTransformPoint(contacts[i].transform.position).x;
TCASthreatPosition.y = gameObject.transform.InverseTransformPoint(contacts[i].transform.position).y;
// threatVelocity.x = gameObject.transform.InverseTransformDirection(contacts[i].GetComponent<Rigidbody2D>().velocity).x;
// threatVelocity.y = gameObject.transform.InverseTransformDirection(contacts[i].GetComponent<Rigidbody2D>().velocity).y;
TCASThreatList.Add(new NTools.CollisionThreat(TCASthreatPosition, TCASthreatPosition, TCASthreatVelocity, 0f, 0f));
}
}
// Work through CollisonThreat list and produce TCASThrusts
if (TCASThreatList.Count != 0)
{
// zeroing the previous avoiding values
rightTCASThrust = 0f;
leftTCASThrust = 0f;
forwardTCASThrust = 0f;
backwardsTCASThrust = 0f;
for (int i = 0; i < TCASThreatList.Count; i++)
{
// Debug.Log("In the TCAS final loop");
// get inline avoidance thrust
if (TCASThreatList[i].threatCoordinates.y > 0f)
{
backwardsTCASThrust += (5 - TCASThreatList[i].threatCoordinates.y) / 3f;
}
else if (TCASThreatList[i].threatCoordinates.y < 0f)
{
forwardTCASThrust += (5 + TCASThreatList[i].threatCoordinates.y) / 4f;
}
// get lateral avoidance thrust
if (TCASThreatList[i].threatCoordinates.x > 0f)
{
leftTCASThrust += (5 - TCASThreatList[i].threatCoordinates.x) / 2f;
}
else if (TCASThreatList[i].threatCoordinates.x < 0f)
{
rightTCASThrust += (5 + TCASThreatList[i].threatCoordinates.x) / 2f;
}
}
}
}
// Update is called once per frame
void Update()
{
horizontalMove = Input.GetAxisRaw("Horizontal");
if (horizontalMove < 0)
{
spriteRenderer.flipX = true;
}
else if (horizontalMove > 0)
{
spriteRenderer.flipX = false;
}
animator.SetFloat("Speed", Mathf.Abs(horizontalMove));
verticalMove = Input.GetAxisRaw("Vertical");
if (verticalMove < 0)
{
animator.SetBool("IsCrouching", true);
capsuleCollider.offset = new Vector2(capsuleCollider.offset.x, startColliderOffsetY + 0.3f);
}
else
{
animator.SetBool("IsCrouching", false);
capsuleCollider.offset = new Vector2(capsuleCollider.offset.x, startColliderOffsetY);
if (verticalMove > 0)
{
if (canClimb)
{
climb = true;
animator.SetBool("IsClimbing", true);
}
else
{
capsuleCollider.OverlapCollider(new ContactFilter2D().NoFilter(), overlapColliders);
foreach (Collider2D col in overlapColliders)
{
if (col != null && col.tag == "Lever")
{
col.SendMessage("Pull");
}
}
}
}
else
{
climb = false;
animator.SetBool("IsClimbing", false);
}
}
if (Input.GetButtonDown("Jump") && (jumpCount < 2))
{
jump = true;
animator.SetBool("IsJumping", true);
jumpCount++;
}
timeLeft -= Time.deltaTime;
int timeLeftInt = (int)timeLeft;
timeText.text = timeLeftInt.ToString();
if (timeLeft <= 0)
{
timeLeft = levelTime;
if (livesCount > 0)
{
LoseALife();
}
else
{
Debug.Log("Lost the game");
}
}
}
void Update()
{
if (!hasAuthority)
{
return;
}
//Attack
if (Input.GetKeyDown(KeyCode.X))
{
if (flower)
{
int horizontal = (int)Input.GetAxisRaw("Horizontal");
if (Input.GetKey(KeyCode.UpArrow))
{
switch (horizontal)
{
case -1:
CmdFireBall(150);
break;
case 0:
CmdFireBall(90);
break;
case 1:
CmdFireBall(30);
break;
}
}
else
{
switch (horizontal)
{
case -1:
CmdFireBall(180);
break;
case 0:
CmdFireBall(spriteRenderer.flipX ? 180 : 0);
break;
case 1:
CmdFireBall(0);
break;
}
}
}
else
{
//Play an attack animation
anim.SetTrigger("Attack");
anim.animator.SetTrigger("Attack");
CmdAttack();
}
}
//Stop Speed
if (Input.GetButtonUp("Horizontal"))
{
rigid.velocity = new Vector2(rigid.velocity.normalized.x * 0.5f, rigid.velocity.y);
}
//Direction Sprite
if (Input.GetButton("Horizontal"))
{
bool newFlipX = Input.GetAxisRaw("Horizontal") == -1;
if (spriteRenderer.flipX != newFlipX)
{
CmdFlipX(newFlipX);
}
}
//Animation
if (Mathf.Abs(rigid.velocity.x) < 0.3)
{
anim.animator.SetBool("isWalking", false);
}
else
{
anim.animator.SetBool("isWalking", true);
}
if (isJumping && !isPassing)
{
ContactFilter2D contactFilter = new ContactFilter2D();
contactFilter.SetLayerMask(LayerMask.GetMask("Platform"));
Collider2D[] results = new Collider2D[9];
if (capsuleCollider.OverlapCollider(contactFilter, results) != 0)
{
if (gameObject.layer == 10) // Player
{
gameObject.layer = 13; // PlayerPassing
}
else
{
gameObject.layer = 14; // PlayerPassingDamaged
}
isPassing = true;
}
}
else if (isPassing)
{
ContactFilter2D contactFilter = new ContactFilter2D();
contactFilter.SetLayerMask(LayerMask.GetMask("Platform"));
Collider2D[] results = new Collider2D[9];
if (capsuleCollider.OverlapCollider(contactFilter, results) == 0)
{
if (gameObject.layer == 13) // PlayerPassing
{
gameObject.layer = 10; // Player
}
else
{
gameObject.layer = 11; // PlayerDamaged
}
isPassing = false;
}
}
//Jump
if (Input.GetButtonDown("Jump") && !isJumping)
{
rigid.position += Vector2.up * 0.2f;
rigid.AddForce(Vector2.up * jumpPower, ForceMode2D.Impulse);
isJumping = true;
anim.animator.SetBool("isJumping", true);
}
if (Input.GetKeyDown(KeyCode.DownArrow) && !isPassing && transform.position.y > 1)
{
if (gameObject.layer == 10) // Player
{
gameObject.layer = 13; // PlayerPassing
}
else
{
gameObject.layer = 14; // PlayerPassingDamaged
}
isPassing = true;
}
}
// checks all unfriendly contacts in the collider and updates bogie list
void Ping()
{
bool bogieListed = false;
float distance = 0f;
ContactFilter2D filter = new ContactFilter2D();
switch (teamSide)
{
case TeamManager.TeamSide.green:
filter.SetLayerMask(redLayerMask);
break;
case TeamManager.TeamSide.red:
filter.SetLayerMask(greenLayerMask);
break;
}
Collider2D[] contacts = new Collider2D[100];
int nrContacts = radarCollider.OverlapCollider(filter, contacts);
if (nrContacts == 0)
{
return;
}
for (int i = 0; i < nrContacts; i++)
{
bogieListed = false;
// Debug.Log("Collider go name: " + contacts[i].gameObject.name);
// check listed bogies for match
for (int j = 0; j < radarBogies.Count; j++)
{
contacts[i].gameObject.GetComponentInChildren <RadarController>().IncomingRWR(gameObject.transform.position, gameObject.transform.parent.gameObject);
// if matched bogie found, update time and distance
if (radarBogies[j].bogieObject != null)
{
if (contacts[i].gameObject == radarBogies[j].bogieObject)
{
radarBogies[j].timeOfContact = Time.timeSinceLevelLoad;
radarBogies[j].sqrDistance = Vector3.SqrMagnitude(contacts[i].transform.position - gameObject.transform.position);
bogieListed = true;
break;
}
}
else if (radarBogies[i].bogieObject == null)
{
radarBogies.RemoveAt(i);
}
}
// if the bogie was not found in the list, add it with all data
if (!bogieListed && contacts[i].gameObject != null)
{
distance = (contacts[i].gameObject.transform.position - gameObject.transform.position).magnitude;
float detectability = 1f;
if (contacts[i].GetComponent <ShipController>() != null)
{
detectability = contacts[i].GetComponent <ShipController>().detectability;
}
else if (contacts[i].GetComponent <StationAI>() != null)
{
detectability = contacts[i].GetComponent <StationAI>().detectability;
}
if (contacts[i].GetComponent <ShipController>())
{
if (contacts[i].GetComponent <ShipController>().detectability *radarRange > distance)
{
radarBogies.Add(new Bogie(
contacts[i].gameObject,
Time.timeSinceLevelLoad,
Vector3.SqrMagnitude(contacts[i].transform.position - gameObject.transform.position)
));
}
}
}
}
}
