public void InitializeRotated(int rotation)
{
rotation = rotation % 4;
items = new ItemEntity[inputBuffer];
int countBelts = 0;
int countMachines = 0;
ContactFilter2D filter = new ContactFilter2D();
filter.useLayerMask = true;
filter.layerMask = 1 << LayerMask.NameToLayer("ConveyorBelt");
ContactFilter2D machineFilter = new ContactFilter2D();
machineFilter.useLayerMask = true;
machineFilter.layerMask = 1 << LayerMask.NameToLayer("Damageable");
Collider2D[] resultsBelts = new Collider2D[3];
Collider2D[] resultsMachines = new Collider2D[3];
switch (rotation)
{
case 0: //east output
outputOrientation = ConveyorBelt.OutputOrientation.East;
countBelts = Physics2D.OverlapBox(this.transform.position, new Vector2(2, 0.25f), 0, filter, resultsBelts);
countMachines = Physics2D.OverlapBox(this.transform.position, new Vector2(2, 0.25f), 0, machineFilter, resultsMachines);
for (int i = 0; i < countBelts; i++)
{
if (resultsBelts[i].gameObject == this.gameObject)
{
continue;
}
if (resultsBelts[i].transform.position.x < this.transform.position.x)
{
IBeltElement temp = resultsBelts[i].GetComponent <IBeltElement>();
if (temp.GetOutputOrientation() == ConveyorBelt.OutputOrientation.East)
{
inputBelt = temp;
temp.SetNextBeltElement(this);
}
}
else if (resultsBelts[i].transform.position.x > this.transform.position.x)
{
IBeltElement temp = resultsBelts[i].GetComponent <IBeltElement>();
if (temp.CanConnectToBeltElement(this))
{
outputBelt = temp;
outputBelt.SetPrevBeltElement(this);
}
}
}
for (int i = 0; i < countMachines; i++)
{
if (resultsMachines[i].transform.position.x < this.transform.position.x)
{
resultsMachines[i].gameObject.TryGetComponent(out inputInventory);
}
else if (resultsMachines[i].transform.position.x > this.transform.position.x)
{
resultsMachines[i].gameObject.TryGetComponent(out outputInventory);
}
}
break;
case 1: //north output
outputOrientation = ConveyorBelt.OutputOrientation.North;
countBelts = Physics2D.OverlapBox(this.transform.position, new Vector2(0.25f, 2), 0, filter, resultsBelts);
countMachines = Physics2D.OverlapBox(this.transform.position, new Vector2(0.25f, 2), 0, machineFilter, resultsMachines);
for (int i = 0; i < countBelts; i++)
{
if (resultsBelts[i].gameObject == this.gameObject)
{
continue;
}
if (resultsBelts[i].transform.position.y < this.transform.position.y)
{
IBeltElement temp = resultsBelts[i].GetComponent <IBeltElement>();
if (temp.GetOutputOrientation() == ConveyorBelt.OutputOrientation.North)
{
inputBelt = temp;
temp.SetNextBeltElement(this);
}
}
else if (resultsBelts[i].transform.position.y > this.transform.position.y)
{
IBeltElement temp = resultsBelts[i].GetComponent <IBeltElement>();
if (temp.CanConnectToBeltElement(this))
{
outputBelt = temp;
outputBelt.SetPrevBeltElement(this);
}
}
}
for (int i = 0; i < countMachines; i++)
{
if (resultsMachines[i].transform.position.y < this.transform.position.y)
{
resultsMachines[i].gameObject.TryGetComponent(out inputInventory);
}
else if (resultsMachines[i].transform.position.y > this.transform.position.y)
{
resultsMachines[i].gameObject.TryGetComponent(out outputInventory);
}
}
break;
case 2: //west output
outputOrientation = ConveyorBelt.OutputOrientation.West;
countBelts = Physics2D.OverlapBox(this.transform.position, new Vector2(2, 0.25f), 0, filter, resultsBelts);
countMachines = Physics2D.OverlapBox(this.transform.position, new Vector2(2, 0.25f), 0, machineFilter, resultsMachines);
for (int i = 0; i < countBelts; i++)
{
if (resultsBelts[i].gameObject == this.gameObject)
{
continue;
}
if (resultsBelts[i].transform.position.x > this.transform.position.x)
{
IBeltElement temp = resultsBelts[i].GetComponent <IBeltElement>();
if (temp.GetOutputOrientation() == ConveyorBelt.OutputOrientation.West)
{
inputBelt = temp;
temp.SetNextBeltElement(this);
}
}
else if (resultsBelts[i].transform.position.x < this.transform.position.x)
{
IBeltElement temp = resultsBelts[i].GetComponent <IBeltElement>();
if (temp.CanConnectToBeltElement(this))
{
outputBelt = temp;
outputBelt.SetPrevBeltElement(this);
}
}
}
for (int i = 0; i < countMachines; i++)
{
if (resultsMachines[i].transform.position.x > this.transform.position.x)
{
resultsMachines[i].gameObject.TryGetComponent(out inputInventory);
}
else if (resultsMachines[i].transform.position.x < this.transform.position.x)
{
resultsMachines[i].gameObject.TryGetComponent(out outputInventory);
}
}
break;
default:
case 3: //south output
outputOrientation = ConveyorBelt.OutputOrientation.South;
countBelts = Physics2D.OverlapBox(this.transform.position, new Vector2(0.25f, 2), 0, filter, resultsBelts);
countMachines = Physics2D.OverlapBox(this.transform.position, new Vector2(0.25f, 2), 0, machineFilter, resultsMachines);
for (int i = 0; i < countBelts; i++)
{
if (resultsBelts[i].gameObject == this.gameObject)
{
continue;
}
if (resultsBelts[i].transform.position.y > this.transform.position.y)
{
IBeltElement temp = resultsBelts[i].GetComponent <IBeltElement>();
if (temp.GetOutputOrientation() == ConveyorBelt.OutputOrientation.South)
{
inputBelt = temp;
temp.SetNextBeltElement(this);
}
}
else if (resultsBelts[i].transform.position.y < this.transform.position.y)
{
IBeltElement temp = resultsBelts[i].GetComponent <IBeltElement>();
if (temp.CanConnectToBeltElement(this))
{
outputBelt = temp;
outputBelt.SetPrevBeltElement(this);
}
}
}
for (int i = 0; i < countMachines; i++)
{
if (resultsMachines[i].transform.position.y > this.transform.position.y)
{
resultsMachines[i].gameObject.TryGetComponent(out inputInventory);
}
else if (resultsMachines[i].transform.position.y < this.transform.position.y)
{
resultsMachines[i].gameObject.TryGetComponent(out outputInventory);
}
}
break;
}
this.GetComponent <SpriteRenderer>().sprite = AnimationPropertiesPool.Instance.rotatedSpriteProperties[rotateSpritePropertyId].sprites[rotation];
}
public void CheckForIntercepts()
{
//Description: If arm is available, this method checks for (and identifies) any intercepts with enemies
//Validations & Initializations:
if (!equipped)
{
return; //Do not check for intercepts if arm is not currently equipped
}
List <Collider2D> overlaps = new List <Collider2D>(); //Initialize list to store overlapping colliders
ContactFilter2D filter = new ContactFilter2D(); //Initialize contact filter for intercept collider
//Set Collider Filter:
filter.useDepth = false; //Set filter to ignore depth
filter.useTriggers = true; //Set filter to use trigger colliders
filter.SetLayerMask(LayerMask.GetMask("InterceptionFields")); //Set filter to mask out all colliders other than interception fields
//Check Current Overlaps:
reachField.OverlapCollider(filter, overlaps); //Populate list of current interception field overlaps
//Compare With Known Intercepts:
for (int x = 0; x < intercepts.Count; x++) //Iterate through list of known intercepts...
{
//Initializations & Validations:
Intercept thisIntercept = intercepts[x]; //Get shorthand for this intercept
Collider2D interceptCollider = thisIntercept.collider; //Get known collider from intercept
bool foundCollider = false; //Initialize marker to track whether or not intercept could find its collider
//Check for Continuity:
for (int y = 0; y < overlaps.Count; y++) //Iterate through list of found colliders...
{
if (overlaps[y] == interceptCollider) //If collider matches that of this intercept...
{
foundCollider = true; //Indicate that this intercept continues to be valid
overlaps.RemoveAt(y); //Remove collider from list of potential new intercepts
break; //Break loop and continue to next task
}
}
//Update or Remove Intercept:
if (foundCollider) //UPDATE intercept, as collider was found successfully:
{
UpdateIntercept(thisIntercept); //Update intercept data
}
else //REMOVE intercept, as collider can no longer be found:
{
thisIntercept.enemy.intercepted = false; //Indicate that enemy is no longer intercepted
player.intercepts.Remove(thisIntercept); //Remove this intercept from player list
intercepts.RemoveAt(x); //Remove this intercept from this arm's list
}
}
//Create New Intercepts:
for (int x = 0; x < overlaps.Count; x++) //For each unclaimed overlap...
{
//Initializations & Validations:
NPC_Enemy interceptedEnemy = overlaps[x].GetComponentInParent <NPC_Enemy>(); //Get enemy controller from overlap collider
if (interceptedEnemy == null)
{
return; //Skip function if target does not have enemy controller
}
if (interceptedEnemy.intercepted)
{
return; //Skip function if target has already been intercepted by other arm
}
//Generate Intercept Core:
Intercept newIntercept = new Intercept(); //Initialize new intercept
newIntercept.enemy = interceptedEnemy; //Set intercept enemy
newIntercept.collider = overlaps[x]; //Set intercept collider
newIntercept.arm = this; //Set intercept arm
//Get Intercept Data:
UpdateIntercept(newIntercept); //Now that intercept has necessary core data, run an initial update
//Intercept Generation Cleanup:
intercepts.Add(newIntercept); //Add new intercept to this arm's list of interceptions
player.intercepts.Add(newIntercept); //Add new intercept to player's list of interceptions
interceptedEnemy.intercepted = true; //Indicate to enemycontroller that it has been intercepted
}
//..Xx Sub-Methods xX...............................................................................
void UpdateIntercept(Intercept intercept)
{
//Description: Updates intercept data based on relationship between player and intercepted enemy
//Initializations & Validations:
Vector2 enemyVel = intercept.enemy.velocity; //Get enemy velocity vector
Vector2 armVel = localVelocity; //Get arm velocity vector
//Find Intercept Vector:
intercept.vector = -(enemyVel + armVel); //Add velocity vectors to get vector of interception
Vector2 correctedVector = intercept.vector.Rotate(player.transform.rotation.z); //Get interception vector relative to absolute rotation of player
//Cleanup:
intercept.duration += Time.fixedDeltaTime; //Update duration (CheckIntercepts should be run during FixedUpdate)
//..Xx Debuggers xX.................................................................................
//Debug.DrawLine(grabPoint.position, grabPoint.position + interceptVector.V3());
}
}
private void Awake()
{
movementContactFilter = BuildContactFilter2DForLayer(LayerMask.LayerToName(gameObject.layer));
playerRigidBody2D = GetComponent <Rigidbody2D>();
}
void Interact()
{
BoxCollider2D boxCollider2D = GetComponent <BoxCollider2D>();
ContactFilter2D contactFilter2D = new ContactFilter2D();
contactFilter2D.layerMask = playerMask;
Collider2D[] colliders = new Collider2D[1];
int collisionCount = boxCollider2D.OverlapCollider(contactFilter2D, colliders);
if (collisionCount > 0)
{
Collider2D collider = colliders[0];
GameObject playerObj = collider.gameObject;
PlayerController playerController = playerObj.GetComponent <PlayerController>();
Inventory inventory = playerObj.GetComponent <Inventory>();
switch (boxType)
{
case BoxType.head:
if (controller.isHoldingPart)
{
inventory.heads[controller.currentHeldObject.GetComponent <BotHead>().headType]++;
Destroy(controller.GivePart());
}
else
{
assetList.BuildHeadList(inventory.heads);
assetList.gameObject.SetActive(assetList.Valid());
}
break;
case BoxType.body:
if (controller.isHoldingPart)
{
inventory.bodies[controller.currentHeldObject.GetComponent <BotBody>().robotType]++;
Destroy(controller.GivePart());
}
else
{
assetList.BuildBodyList(inventory.bodies);
assetList.gameObject.SetActive(assetList.Valid());
}
break;
case BoxType.arms:
if (controller.isHoldingPart)
{
inventory.arms[controller.currentHeldObject.GetComponent <BotArm>().armType]++;
Destroy(controller.GivePart());
}
else
{
assetList.BuildArmsList(inventory.arms);
assetList.gameObject.SetActive(assetList.Valid());
}
break;
case BoxType.legs:
if (controller.isHoldingPart)
{
inventory.legs[controller.currentHeldObject.GetComponent <BotLeg>().legType]++;
Destroy(controller.GivePart());
}
else
{
assetList.BuildLegsList(inventory.legs);
assetList.gameObject.SetActive(assetList.Valid());
}
break;
case BoxType.recycle:
// TODO
if (playerController.isHoldingPart)
{
//inventory.binItems.Add(playerController.currentHeldObject);
Scrap++;
Destroy(playerController.GivePart());
}
break;
default:
break;
}
}
}
private void UpdateProjectiles(float tick)
{
ActiveProjectileCount = 0;
ContactFilter2D contactFilter = new ContactFilter2D
{
layerMask = LayerMask,
useTriggers = false,
useLayerMask = true
};
ProjectileManager projectileManager = ProjectileManager.Instance;
//Update camera planes if needed
if (CullProjectilesOutsideCameraBounds)
{
GeometryUtility.CalculateFrustumPlanes(Camera, Planes);
}
// loop through all active projectile data
for (int i = 0; i < Projectiles.Nodes.Length; i++)
{
if (Projectiles.Nodes[i].Active)
{
Projectiles.Nodes[i].Item.TimeToLive -= tick;
// Projectile is active
if (Projectiles.Nodes[i].Item.TimeToLive > 0)
{
// apply acceleration
//Projectiles.Nodes[i].Item.Velocity *= (1 + Projectiles.Nodes[i].Item.Acceleration * tick);
// apply gravity
//Projectiles.Nodes[i].Item.Velocity += Projectiles.Nodes[i].Item.Gravity * tick;
Projectiles.Nodes[i].Item.UpdateVelocity(tick);
// calculate where projectile will be at the end of this frame
Vector2 deltaPosition = Projectiles.Nodes[i].Item.Velocity * tick;
float distance = deltaPosition.magnitude;
// If flag set - return projectiles that are no longer in view
if (CullProjectilesOutsideCameraBounds)
{
Bounds bounds = new Bounds(Projectiles.Nodes[i].Item.Position, new Vector3(Projectiles.Nodes[i].Item.Scale, Projectiles.Nodes[i].Item.Scale, Projectiles.Nodes[i].Item.Scale));
if (!GeometryUtility.TestPlanesAABB(Planes, bounds))
{
Projectiles.Nodes[i].Item.TimeToLive = -1;
Projectiles.Return(Projectiles.Nodes[i].NodeIndex);
}
}
int result = -1;
if (CollisionDetection == CollisionDetectionType.Raycast)
{
result = Physics2D.Raycast(Projectiles.Nodes[i].Item.Position, deltaPosition, contactFilter, RaycastHitBuffer, distance);
}
else if (CollisionDetection == CollisionDetectionType.CircleCast)
{
result = Physics2D.CircleCast(Projectiles.Nodes[i].Item.Position, Projectiles.Nodes[i].Item.Scale / 2f, Projectiles.Nodes[i].Item.Velocity, contactFilter, RaycastHitBuffer, distance);
if (result > 0 && RaycastHitBuffer[0].distance == 0)
{
result = -1;
}
}
if (result > 0)
{
// Put whatever hit code you want here such as damage events
ProjectileHitEvent(RaycastHitBuffer);
// Collision was detected, should we bounce off or destroy the projectile?
if (BounceOffSurfaces)
{
// rudementary bounce -- will work well on static surfaces
Projectiles.Nodes[i].Item.Velocity = Vector2.Reflect(Projectiles.Nodes[i].Item.Velocity, RaycastHitBuffer[0].normal);
// what fraction of the distance do we still have to move this frame?
float leakedFraction = 1f - RaycastHitBuffer[0].distance / distance;
deltaPosition = Projectiles.Nodes[i].Item.Velocity * tick * leakedFraction;
Projectiles.Nodes[i].Item.Position = RaycastHitBuffer[0].centroid + deltaPosition;
Projectiles.Nodes[i].Item.Color = Color.Evaluate(1 - Projectiles.Nodes[i].Item.TimeToLive / TimeToLive);
// Absorbs energy from bounce
Projectiles.Nodes[i].Item.Velocity = new Vector2(Mathf.Lerp(Projectiles.Nodes[i].Item.Velocity.x, 0, BounceAbsorbtion.x), Mathf.Lerp(Projectiles.Nodes[i].Item.Velocity.y, 0, BounceAbsorbtion.y));
projectileManager.UpdateBufferData(ActiveProjectileCount, ProjectileType, Projectiles.Nodes[i].Item);
ActiveProjectileCount++;
}
else
{
Projectiles.Nodes[i].Item.TimeToLive = -1;
Projectiles.Return(Projectiles.Nodes[i].NodeIndex);
}
}
else
{
//No collision -move projectile
Projectiles.Nodes[i].Item.Position += deltaPosition;
Projectiles.Nodes[i].Item.Color = Color.Evaluate(1 - Projectiles.Nodes[i].Item.TimeToLive / TimeToLive);
projectileManager.UpdateBufferData(ActiveProjectileCount, ProjectileType, Projectiles.Nodes[i].Item);
ActiveProjectileCount++;
}
}
else
{
// End of life - return to pool
Projectiles.Return(Projectiles.Nodes[i].NodeIndex);
}
}
}
}
// Start is called before the first frame update
void Start()
{
collider_filter = collider_filter.NoFilter();
double_parent = transform.parent.transform.parent.gameObject;
weapon_attack = double_parent.GetComponent <ProjectileAttack>();
}
public bool CastColider(ContactFilter2D filter)
{
return(partColider.OverlapCollider(filter, new Collider2D[2]) > 0);
}
// Update is called once per frame
void Update()
{
// collect inputs
float x = Input.GetAxis("Horizontal");
float y = Input.GetAxis("Vertical");
// don't care about negative y values
if (y < 0)
{
y = 0;
}
float fire = Input.GetAxis("Jump");
//float slow = Input.GetAxis("Fire2");
// if the player is holding down w, fire all engines
foreach (GameObject engine in engines)
{
Rigidbody2D rb = engine.GetComponent <Rigidbody2D>();
rb.AddForce(rotate(new Vector2(0, y * accScaleFactor), rb.rotation));
}
// if the player is turning, fire all controls
foreach (GameObject control in controls)
{
Rigidbody2D rb = control.GetComponent <Rigidbody2D>();
rb.AddForce(rotate(new Vector2(x * turnScaleFactor, 0), rb.rotation));
}
// if the player is shooting, fire the guns
if (fire > 0 && shotTimer > shotTime)
{
shotTimer = 0;
foreach (GameObject gun in guns)
{
// recoil the gun
Rigidbody2D rb = gun.GetComponent <Rigidbody2D>();
rb.AddForce(rotate(new Vector2(0, -recoilStrength * fire), rb.rotation));
// shoot the shot
var shot = Instantiate(Shot, rb.position + rotate(new Vector2(0, 1.28f), rb.rotation), gun.transform.rotation) as GameObject;
shot.GetComponent <Rigidbody2D>().AddForce(rotate(new Vector2(0, shotSpeed * 20), rb.rotation));
}
}
// check if the player has clicked on a cell
if (Input.GetMouseButtonDown(0))
{
// raycast to find the cell
//Ray2D ray = Camera.main.ScreenPointToRay(Input.mousePosition);
ContactFilter2D cf2d = new ContactFilter2D(); cf2d.maxDepth = -5; cf2d.minDepth = 5;
RaycastHit2D[] hit = new RaycastHit2D[16];
if (Physics2D.Raycast(new Vector2(Camera.main.ScreenToWorldPoint(Input.mousePosition).x,
Camera.main.ScreenToWorldPoint(Input.mousePosition).y),
Vector2.zero,
cf2d, hit)
> 0)
{
if (hit != null && (
hit[0].transform.CompareTag("Control") ||
hit[0].transform.CompareTag("Engine") ||
hit[0].transform.CompareTag("Gun") ||
hit[0].transform.CompareTag("Structure")))
{
// remove its joints if it has any on the player
if (hit[0].transform.parent == null)
{
// set it to be selected
hit[0].transform.gameObject.GetComponent <Rigidbody2D>().velocity = Vector2.zero;
hit[0].transform.gameObject.BroadcastMessage("SetSelected", true);
selectedGO = hit[0].transform.gameObject;
}
else if (hit[0].transform.parent.tag != "Enemy")
{
foreach (RelativeJoint2D joint in hit[0].transform.GetComponents <RelativeJoint2D>())
{
joint.connectedBody = joint.attachedRigidbody;
}
// remove others' joints if they are connected to it
if (hit[0].transform.parent && !hit[0].transform.parent.name.Equals("Debris"))
{
foreach (Transform child in hit[0].transform.parent)
{
foreach (RelativeJoint2D joint in child.GetComponents <RelativeJoint2D>())
{
if (joint.connectedBody.Equals(hit[0].transform.GetComponent <Rigidbody2D>()))
{
joint.connectedBody = joint.attachedRigidbody;
}
}
}
}
// set it to be selected
hit[0].transform.gameObject.GetComponent <Rigidbody2D>().velocity = Vector2.zero;
hit[0].transform.gameObject.BroadcastMessage("SetSelected", true);
selectedGO = hit[0].transform.gameObject;
}
}
}
}
// check if the player has released the cell from their click
if (Input.GetMouseButtonUp(0))
{
if (selectedGO != emptyGO)
{
selectedGO.BroadcastMessage("SetSelected", false);
selectedGO.BroadcastMessage("ReleaseSelected");
selectedGO = emptyGO;
}
}
counter += Time.deltaTime;
shotTimer += Time.deltaTime;
}
// Update is called once per frame
void Update()
{
// left click
if (Input.GetMouseButtonDown(0))
{
int maxSize = 228;
Vector2 ray = Camera.main.ScreenToWorldPoint(Input.mousePosition);
RaycastHit2D[] hit = new RaycastHit2D[maxSize];
ContactFilter2D filter = new ContactFilter2D();
filter.useLayerMask = false;
int cnt = Physics2D.Raycast(ray, Vector2.zero, filter, hit);
cnt = Min(cnt, maxSize);
int maxLayer = 0; //default
for (int i = 0; i < cnt; ++i)
{
maxLayer = Max(maxLayer, hit[i].transform.gameObject.layer);
}
for (int i = 0; i < cnt; ++i)
{
if (hit[i].transform.gameObject.layer == maxLayer)
{
if (hit[i].transform.tag == "button")
{
hit[i].transform.gameObject.GetComponent <Button>().OnMouseDownBut();
}
if (hit[i].transform.tag == "changer")
{
hit[i].transform.gameObject.GetComponent <Changer>().OnMouseDownChanger();
}
if (hit[i].transform.tag == "slider")
{
hit[i].transform.gameObject.GetComponent <Slider>().OnMouseDownSlider();
}
if (hit[i].transform.tag == "scroller")
{
hit[i].transform.gameObject.GetComponent <Scroller>().OnMouseDownScroller();
}
if (hit[i].transform.tag == "background")
{
// GameObject click = Instantiate<GameObject>(Resources.Load<GameObject>("Click effect"));
// click.transform.position = Camera.main.ScreenToWorldPoint(Input.mousePosition);
// click.transform.position += new Vector3(0, 0, 10);
}
}
}
}
// left click
if (Input.GetMouseButtonUp(0))
{
Vector2 ray = Camera.main.ScreenToWorldPoint(Input.mousePosition);
RaycastHit2D[] hit = new RaycastHit2D[228];
ContactFilter2D filter = new ContactFilter2D();
filter.useLayerMask = false;
int cnt = Physics2D.Raycast(ray, Vector2.zero, filter, hit);
int maxLayer = 0; //default
for (int i = 0; i < cnt && i < 228; ++i)
{
maxLayer = Max(maxLayer, hit[i].transform.gameObject.layer);
}
for (int i = 0; i < cnt; ++i)
{
if (hit[i].transform.gameObject.layer == maxLayer)
{
if (hit[i].transform.tag == "button")
{
hit[i].transform.gameObject.GetComponent <Button>().OnMouseUpBut();
}
if (hit[i].transform.tag == "changer")
{
hit[i].transform.gameObject.GetComponent <Changer>().OnMouseUpChanger(1);
}
if (hit[i].transform.tag == "toggle")
{
hit[i].transform.gameObject.GetComponent <Toggle>().OnMouseUpToggle();
}
if (hit[i].transform.tag == "inputtext")
{
hit[i].transform.gameObject.GetComponent <InputText>().OnMouseUpInput();
}
}
}
}
// right click
if (Input.GetMouseButtonDown(1))
{
Vector2 ray = Camera.main.ScreenToWorldPoint(Input.mousePosition);
RaycastHit2D[] hit = new RaycastHit2D[228];
ContactFilter2D filter = new ContactFilter2D();
filter.useLayerMask = false;
int cnt = Physics2D.Raycast(ray, Vector2.zero, filter, hit);
int maxLayer = 0; //default
for (int i = 0; i < cnt && i < 228; ++i)
{
maxLayer = Max(maxLayer, hit[i].transform.gameObject.layer);
}
for (int i = 0; i < cnt; ++i)
{
if (hit[i].transform.gameObject.layer == maxLayer)
{
if (hit[i].transform.tag == "changer")
{
hit[i].transform.gameObject.GetComponent <Changer>().OnMouseDownChanger();
}
}
}
}
// right click
if (Input.GetMouseButtonUp(1))
{
Vector2 ray = Camera.main.ScreenToWorldPoint(Input.mousePosition);
RaycastHit2D[] hit = new RaycastHit2D[228];
ContactFilter2D filter = new ContactFilter2D();
filter.useLayerMask = false;
int cnt = Physics2D.Raycast(ray, Vector2.zero, filter, hit);
int maxLayer = 0; //default
for (int i = 0; i < cnt && i < 228; ++i)
{
maxLayer = Max(maxLayer, hit[i].transform.gameObject.layer);
}
for (int i = 0; i < cnt; ++i)
{
if (hit[i].transform.gameObject.layer == maxLayer)
{
if (hit[i].transform.tag == "changer")
{
hit[i].transform.gameObject.GetComponent <Changer>().OnMouseUpChanger(-1);
}
}
}
}
}
private static bool checkCollision(Collider2D collider, Vector2 direction, float distance, ContactFilter2D filter)
{
if (collider != null)
{
return(collider.Cast(direction, filter, _holdingRaycast, distance, true) > 0);
}
return(false);
}
/// <summary>
/// Fires a single shot from the weapon
/// </summary>
public void FireOneShot()
{
if (!this.isFiring)
{
this.isFiring = true;
// pew pew
AudioManager.Instance.PlayOneShot(AudioClipName.Laser, 1.0f);
// raycast horizontally away from the weapon, in the direction the weapon is facing.
var direction = transform.TransformDirection(Vector3.right);
// ray will be cast until it hits the first structural object (e.g. platform, wall etc.)
// count the first 10 hits of the ray (assume we won't have more than 10 objects in a row)
RaycastHit2D[] hits = new RaycastHit2D[10];
// only interested in hits with creatures (layer = "Obstacle") and
// structural objects, such as platforms or walls (layer = "Structural")
ContactFilter2D contactFilter = new ContactFilter2D();
LayerMask mask = LayerMask.GetMask(new string[] { "Obstacle", "Structural" });
contactFilter.SetLayerMask(mask);
contactFilter.useLayerMask = true; // enable the layer mask
contactFilter.useTriggers = true; // include colliders that are triggers
int hitCount = Physics2D.Raycast(transform.position, direction, contactFilter, hits, 20f);
// if we hit objects
if (hitCount > 0)
{
// iterate over each object
for (int i = 0; i < hitCount; i++)
{
RaycastHit2D hit = hits[i];
// If we hit a structural object, this is our target (where the laser beam stops)
// For the purposes of hilarity, the maid is treated as a structural object.
if (hit.transform.CompareTag(GameConstants.WALL) ||
hit.transform.CompareTag(GameConstants.PLATFORM) ||
hit.transform.CompareTag(GameConstants.DOOR) ||
hit.collider.CompareTag(GameConstants.MAID)) // here we test the specific collider because the maid has several
{
FireLaser(hit.transform.position.x);
// maid swears when hit by the laser
if (hit.collider.CompareTag(GameConstants.MAID))
{
hit.collider.SendMessageUpwards("Swear");
}
break;
}
else if (hit.transform.CompareTag(GameConstants.OBSTACLE))
{
// creatures exploded when hit by the laser
hit.collider.SendMessageUpwards("Explode");
}
}
}
}
}
protected virtual void OnKinematicStayTd(ContactFilter2D contactFilter)
{
}
void Awake()
{
pegColl = GetComponent <Collider2D>();
pegSprite = GetComponent <SpriteRenderer>();
contactFilter = new ContactFilter2D();
}
public void CheckForInventory()
{
int countMachines;
ContactFilter2D machineFilter = new ContactFilter2D();
machineFilter.useLayerMask = true;
machineFilter.layerMask = 1 << LayerMask.NameToLayer("Damageable");
Collider2D[] resultsMachines = new Collider2D[3];
switch (outputOrientation)
{
case ConveyorBelt.OutputOrientation.East:
countMachines = Physics2D.OverlapBox(this.transform.position, new Vector2(2, 0.25f), 0, machineFilter, resultsMachines);
for (int i = 0; i < countMachines; i++)
{
if (resultsMachines[i].transform.position.x < this.transform.position.x)
{
resultsMachines[i].gameObject.TryGetComponent(out inputInventory);
}
else if (resultsMachines[i].transform.position.x > this.transform.position.x)
{
resultsMachines[i].gameObject.TryGetComponent(out outputInventory);
}
}
break;
case ConveyorBelt.OutputOrientation.North:
countMachines = Physics2D.OverlapBox(this.transform.position, new Vector2(0.25f, 2), 0, machineFilter, resultsMachines);
for (int i = 0; i < countMachines; i++)
{
if (resultsMachines[i].transform.position.y < this.transform.position.y)
{
resultsMachines[i].gameObject.TryGetComponent(out inputInventory);
}
else if (resultsMachines[i].transform.position.y > this.transform.position.y)
{
resultsMachines[i].gameObject.TryGetComponent(out outputInventory);
}
}
break;
case ConveyorBelt.OutputOrientation.West:
countMachines = Physics2D.OverlapBox(this.transform.position, new Vector2(2, 0.25f), 0, machineFilter, resultsMachines);
for (int i = 0; i < countMachines; i++)
{
if (resultsMachines[i].transform.position.x > this.transform.position.x)
{
resultsMachines[i].gameObject.TryGetComponent(out inputInventory);
}
else if (resultsMachines[i].transform.position.x < this.transform.position.x)
{
resultsMachines[i].gameObject.TryGetComponent(out outputInventory);
}
}
break;
default:
case ConveyorBelt.OutputOrientation.South:
countMachines = Physics2D.OverlapBox(this.transform.position, new Vector2(0.25f, 2), 0, machineFilter, resultsMachines);
for (int i = 0; i < countMachines; i++)
{
if (resultsMachines[i].transform.position.y > this.transform.position.y)
{
resultsMachines[i].gameObject.TryGetComponent(out inputInventory);
}
else if (resultsMachines[i].transform.position.y < this.transform.position.y)
{
resultsMachines[i].gameObject.TryGetComponent(out outputInventory);
}
}
break;
}
}
void OnEnable()
{
contactFilter = new ContactFilter2D();
contactFilter.SetLayerMask(damageMask);
contactFilter.useTriggers = true;
}
// Sets the laser objects up so they appear to be bouncing around.
void Update()
{
// The origin and direction of the ray.
Vector2 o = transform.position, d = transform.right;
// Whether or not each ray should be visible.
bool visible = true;
foreach (GameObject laser in lasers)
{
// If the laser object should be visible (the laser is "still going")
if (visible)
{
// Make it visible
laser.SetActive(true);
Util.SetLayerRecursively(laser, gameObject.layer);
// Find the intersection between the ray and the layer that the emitter resides in.
ContactFilter2D cf = new ContactFilter2D();
// Only check on the same layer.
cf.SetLayerMask(1 << gameObject.layer);
// Don't check for triggers.
cf.useTriggers = false;
// Only get the first hit.
RaycastHit2D[] results = new RaycastHit2D[1];
int count = Physics2D.Raycast(o, d, cf, results, maxDistance);
// If the ray hit something.
if (count > 0)
{
RaycastHit2D hit = results[0];
// Make the laser object face the direction of the ray.
laser.transform.position = (o + hit.point) * 0.5f;
Vector3 localScale = laser.transform.localScale;
Vector3 scale = new Vector3(
Vector2.Distance(o, hit.point),
localScale.y,
localScale.z);
float angle = Vector2.SignedAngle(laser.transform.right, d);
laser.transform.Rotate(Vector3.forward, angle);
laser.transform.localScale = scale;
// Determine whether a laser redirection is available in the hit object. (Reflection or refraction)
LaserAffector affector = hit.collider.gameObject.GetComponent <LaserAffector>();
// If so, redirect the laser.
if (affector != null)
{
Ray2D newRay = affector.RedirectLaser(new Ray2D(o, d), hit);
if (newRay.direction.magnitude == 0)
{
visible = false;
continue;
}
o = newRay.origin;
d = newRay.direction;
//}
}
// Otherwise, set the following laser objects to invisible.
else
{
visible = false;
}
}
// If nothing was hit, i.e. the lazer is shot into the empty sky.
else
{
// Draw it with length infiniteRenderSize.
laser.transform.position = (o + d * infiniteRenderSize * 0.5f);
Vector3 localScale = laser.transform.localScale;
Vector3 scale = new Vector3(
infiniteRenderSize,
localScale.y,
localScale.z);
float angle = Vector2.SignedAngle(laser.transform.right, d);
laser.transform.Rotate(Vector3.forward, angle);
laser.transform.localScale = scale;
// Don't draw the following lasers.
visible = false;
}
}
else
{
laser.SetActive(false);
}
}
}
private void FixedUpdate()
{
//if (foundStoppingPos == false)
//{
if (!hasLanded && lookingForStoppingPos == false)
{
myRigidbody.velocity = new Vector2(myRigidbody.velocity.x, myRigidbody.velocity.y - (gravity * Time.fixedDeltaTime));
TrackDistance();
}
//}
if (hasLanded)
{
//set the player collider to be on grid
playerCollider.transform.position = Movement.RoundVectorToPoint5s(transform.position);
}
if (lookingForStoppingPos == true && hasLanded == false)
{
if (Vector3.Distance(transform.position, automatedMovementPositions[autoMovementIndex]) > 0.05f)
{
percent += Time.deltaTime / timeToReachTarget;
float curvePercentX = 0;
float curvePercentY = 0;
float animatedxPos = 0;
float animatedYPos = 0;
// Calculate the curve transition of both the x and y movement
curvePercentX = horizontalEase.Evaluate(percent);
animatedxPos = Mathf.Lerp(automatedMovementPositions[autoMovementIndex - 1].x, automatedMovementPositions[autoMovementIndex].x, curvePercentX);
//print(animatedxPos);
if (autoMovementIndex < halfautoIndex)
{
//print("goodbye");
curvePercentY = verticalRiseEase.Evaluate(percent);
animatedYPos = Mathf.Lerp(automatedMovementPositions[autoMovementIndex - 1].y, automatedMovementPositions[autoMovementIndex].y, curvePercentY);
}
if (autoMovementIndex >= halfautoIndex)
{
//print("hello");
curvePercentY = verticalRunEase.Evaluate(percent);
animatedYPos = Mathf.Lerp(automatedMovementPositions[autoMovementIndex - 1].y, automatedMovementPositions[autoMovementIndex].y, curvePercentY);
}
//transform.position Vector3.Lerp(automatedMovementPositions[autoMovementIndex - 1], automatedMovementPositions[autoMovementIndex], percent);
transform.position = new Vector2(animatedxPos, animatedYPos);
// When reach any point but the end of the animaiton
if (Vector3.Distance(transform.position, automatedMovementPositions[autoMovementIndex]) <= 0.05f && autoMovementIndex < automatedMovementPositions.Count - 1)
{
percent = 0;
transform.position = automatedMovementPositions[autoMovementIndex];
autoMovementIndex++;
}
// REACH END POINT
else if (Vector3.Distance(transform.position, automatedMovementPositions[autoMovementIndex]) <= 0.05f && autoMovementIndex == automatedMovementPositions.Count - 1)
{
// Figure out if the camper is dropped or not
int randomNumber = Random.Range(0, 20 + 1);
if (randomNumber > 0) // STAYS AT SPOT
{
foundStoppingPos = true;
percent = 0;
myRigidbody.isKinematic = true;
myRigidbody.velocity = Vector3.zero;
transform.position = automatedMovementPositions[autoMovementIndex];
hasLanded = true;
}
else if (randomNumber == 0) // MISSES SPOT
{
foundStoppingPos = true;
hasLanded = true;
percent = 0;
//myRigidbody.velocity = Vector3.zero;
transform.position = automatedMovementPositions[autoMovementIndex];
RestorePhysics();
// Add a physics push to make the fall seem more believable
myRigidbody.AddForce((automatedMovementPositions[autoMovementIndex] - automatedMovementPositions[autoMovementIndex - 1]).normalized * 5, ForceMode2D.Impulse);
myRigidbody.AddTorque(2, ForceMode2D.Impulse);
}
}
}
//if (atMidPoint == false) // Beginning -> Midpoint
//{
// percent += Time.deltaTime / timeToReachTarget;
// transform.position = Vector3.Lerp(startPosition, midPosition, percent);
// // Reached the mid Point
// if (Vector3.Distance(transform.position, midPosition) < 0.05f)
// {
// atMidPoint = true;
// percent = 0;
// transform.position = midPosition;
// }
//}
//else if (atMidPoint == true) // Midpoint -> Endpoint
//{
// percent += Time.deltaTime / timeToReachTarget;
// transform.position = Vector3.Lerp(midPosition, stopPosition, percent);
// // Reached the end Point
// if (Vector3.Distance(transform.position, stopPosition) < 0.05f)
// {
// int randomNumber = Random.Range(0, 10 + 1);
// if (randomNumber > 0)
// {
// foundStoppingPos = true;
// percent = 0;
// myRigidbody.isKinematic = true;
// myRigidbody.velocity = Vector3.zero;
// transform.position = stopPosition;
// hasLanded = true;
// }
// else if (randomNumber == 0)
// {
// foundStoppingPos = true;
// percent = 0;
// //myRigidbody.velocity = Vector3.zero;
// transform.position = stopPosition;
// RestorePhysics();
// // Add a physics push to make the fall seem more believable
// myRigidbody.AddForce((stopPosition - midPosition).normalized * 5, ForceMode2D.Impulse);
// }
// }
//}
//if (Vector3.Distance(transform.position, stopPosition) < 0.7f)
//{
// foundStoppingPos = true;
// myRigidbody.isKinematic = true;
// myRigidbody.velocity = Vector3.zero;
// transform.position = stopPosition;
// hasLanded = true;
//}
}
if (!hasDoneClipCheck)
{
ContactFilter2D filter = new ContactFilter2D();
filter.NoFilter();
Collider2D[] results = new Collider2D[10];
worldCollider.OverlapCollider(filter, results);
foreach (Collider2D eachCol in results)
{
//if you are at all touching a boi on spawn, change layers
if (eachCol && eachCol.GetComponentInParent <DetachedPiece>() && eachCol.transform.root != transform.root)
{
worldCollider.gameObject.layer = 16;
//print("set to no clip layer");
break;
}
}
hasDoneClipCheck = true;
}
else
{
if (worldCollider.gameObject.layer == 16 && !worldCollider.IsTouchingLayers(Physics2D.AllLayers))
{
worldCollider.gameObject.layer = LayerMask.NameToLayer("Heart");
//print("returned to normal layer");
}
}
}
private void Update()
{
stateTime += Time.deltaTime;
if (Time.frameCount % 60 == 0)
{
PlayerCheck(); //check slow
}
if (state == (int)States.IDLE)
{
if (stateTime > idleTime)
{
StartWalking();
}
}
if (state == (int)States.WALK)
{
float xSpeed = left ? -1.5f : 1.5f;
if (rb.velocity.magnitude < 0.1 && stateTime > 0.1f && jumped == false)
{
jumped = true;
rb.AddForce(new Vector3(0, 7, 0), ForceMode2D.Impulse);
}
Vector3 newVel = new Vector3(xSpeed, rb.velocity.y, 0);
rb.velocity = newVel;
if (stateTime > walkTime)
{
StartIdling();
}
}
if (state == (int)States.CHASE)
{
left = player.transform.position.x < transform.position.x;
float xSpeed = left ? -3 : 3;
jumpTime -= Time.deltaTime;
damageTime -= Time.deltaTime;
shootTime -= Time.deltaTime;
if (shootTime < 0)
{
AudioSource.PlayClipAtPoint(shoot, transform.position);
Vector3 direction = (player.transform.position - transform.position).normalized;
//float mag = (player.transform.position - transform.position).magnitude;
GameObject a = Instantiate(arrow, new Vector3(transform.position.x - 0.5f, transform.position.y + 0.5f, 0), Quaternion.identity);
a.GetComponent <ArrowAI>().Init(direction * 20.0f);
shootTime = shootSeconds;
}
if (player.transform.position.y - transform.position.y > 3 && jumpTime < 0)
{
List <Collider2D> overlaps = new List <Collider2D>();
ContactFilter2D filter = new ContactFilter2D();
filter.SetLayerMask(~(1 << 9));
if (groundCollider.OverlapCollider(filter, overlaps) > 0)
{
rb.AddForce(new Vector3(0, 7, 0), ForceMode2D.Impulse);
jumpTime = 2;
}
}
Vector3 newVel = new Vector3(xSpeed, rb.velocity.y, 0);
rb.velocity = newVel;
if (stateTime > walkTime)
{
StartIdling();
}
}
}
// Start is called before the first frame update
void Start()
{
contactFilter = new ContactFilter2D();
contactFilter.SetLayerMask(damageMask);
inventory = GameObject.Find("Canvas");
}
// Use this for initialization
void Start()
{
_rigidBody = GetComponent <Rigidbody2D>();
_collider2D = GetComponent <Collider2D>();
_noFilter = new ContactFilter2D().NoFilter();
}
private void Poof(Vector3 currPos)
{
if (!startPoofAnimation)
{
isTeleporting = true;
isPoofing = true;
KeyCode directionKey = 0;
Vector2 poofDir = Vector2.zero;
if (Input.GetKey(rightMove))
{
directionKey = KeyCode.D;
//currPos.x = currPos.x + mTeleportDistance;
poofDir.x += 1;
startPoofTimer = true;
}
if (Input.GetKey(leftMove))
{
directionKey = KeyCode.A;
poofDir.x += -1;
//currPos.x = currPos.x - mTeleportDistance;
startPoofTimer = true;
}
if (Input.GetKey(KeyCode.W))
{
poofDir.y += 1;
directionKey = KeyCode.W;
// currPos.y = currPos.y + mTeleportDistance;
startPoofTimer = true;
}
if (Input.GetKey(KeyCode.S))
{
poofDir.y += -1;
directionKey = KeyCode.S;
//currPos.y = currPos.y - mTeleportDistance;
startPoofTimer = true;
}
if (poofDir.x != 0 && poofDir.y != 0)
{
float poofModifier = Mathf.Sqrt(2) / 2;
poofDir.x *= poofModifier;
poofDir.y *= poofModifier;
}
poofDir *= mTeleportDistance;
currPos.x += poofDir.x;
currPos.y += poofDir.y + 0.05f;
GetComponent <SpriteRenderer>().enabled = false;
Vector3 positionPreTeleport = transform.position;
transform.position = currPos;
ContactFilter2D platformFilter = new ContactFilter2D();
platformFilter.useLayerMask = true;
LayerMask platformLayer = LayerMask.GetMask("Platforms");
platformFilter.SetLayerMask(platformLayer);
Collider2D[] results = new Collider2D[5];
results[0] = null;
GetComponent <Rigidbody2D>().OverlapCollider(platformFilter, results);
//bool top, bottom, left, right = false;
if (results[0] != null)
{
//float halfWidth = GetComponent<BoxCollider2D>().size.x / 2;
//float halfHeight = GetComponent<BoxCollider2D>().size.y / 2;
//float playerMinX = transform.position.x - halfWidth;
//float playerMinY = transform.position.y - halfHeight;
//float playerMaxX = transform.position.x + halfWidth;
//float playerMaxY = transform.position.y + halfHeight;
//float boxWidth = results[0].transform.localScale.x / 2;
//float boxHeight = results[0].transform.localScale.y / 2;
//float boxMinX = results[0].transform.position.x - boxWidth;
//float boxMinY = results[0].transform.position.y - boxHeight;
//float boxMaxX = results[0].transform.position.x + boxWidth;
//float boxMaxY = results[0].transform.position.y + boxHeight;
//Vector3 vel = GetComponent<Rigidbody2D>().velocity;
//float maxVel = Mathf.Max(Mathf.Abs(vel.x), Mathf.Abs(vel.y));
//Vector3 newPos = transform.position;
//if (directionKey == KeyCode.D || directionKey == KeyCode.A)
//{
// if (directionKey == KeyCode.D)
// {
// newPos.x = boxMinX - 0.5f;
// }
// else
// {
// newPos.x = boxMaxX + 0.5f;
// }
// //GetComponent<BoxCollider2D>().size.y;
//}
//else
//{
// if (directionKey == KeyCode.W)
// {
// newPos.y = boxMinY - 0.5f;
// }
// else
// {
// newPos.y = boxMaxY + 0.5f;
// }
//}
Vector3 toOldLocation = positionPreTeleport - currPos;
toOldLocation = 0.25f * toOldLocation.normalized;
Vector3 newPos = currPos;
bool overlapping = true;
int loopCount = 0;
Vector3 playerMax, playerMin, objectMax, objectMin;
Vector3 objectPos = results[0].transform.position;
while (overlapping)
{
playerMax = GetComponent <Collider2D>().bounds.max;
objectMax = results[0].GetComponent <Collider2D>().bounds.max;
playerMin = GetComponent <Collider2D>().bounds.min;
objectMin = results[0].GetComponent <Collider2D>().bounds.min;
if ((playerMin.x <= objectMax.x && playerMax.x >= objectMin.x) && (playerMin.y <= objectMax.y && playerMax.y >= objectMin.y))
{
newPos += toOldLocation;
transform.position = newPos;
}
else
{
overlapping = false;
}
}
poofPosition = newPos; // positionPreTeleport;
}
else
{
poofPosition = currPos;
}
anim.SetBool("StartPoof", true);
GetComponent <SpriteRenderer>().enabled = true;
startPoofAnimation = true;
mFreeze = true;
transform.position = positionPreTeleport;
}
else
{
transform.position = poofPosition;
GetComponent <SpriteRenderer>().enabled = false;
mPoofTime = 0;
startPoofAnimation = false;
startPoofTimer = true;
}
}
void Update()
{
if (kills >= 100)
{
win();
}
if (Input.GetButtonDown("Restart"))
{
restart();
}
if (Input.GetButtonDown("Pause"))
{
playing = !playing;
}
if (!playing)
{
return;
}
if (slowmotion > 0)
{
slowmotion -= Time.deltaTime;
Time.timeScale = 0.4f;
}
else
{
Time.timeScale = 1f;
}
imunity -= Time.deltaTime;
//Helth calcuations
if (hp > maxHP)
{
hp = maxHP;
}
if (hp <= 0)
{
hp = 0;
die();
}
if (hp > 0 && dead)
{
dead = false;
slowmotion = 0;
finalChance.enabled = false;
}
healtBar.sizeDelta = new Vector2((hp) / (maxHP) * (200f - 23f) + 23f, 50);
healtBar.anchoredPosition = new Vector2((hp) / (maxHP) * (200f - 23f) + 23f, -25);
if (isDead())
{
xSpeed = 0;
anim.SetBool("Dead", true);
playing = false;
foreach (GameObject go in GameObject.FindGameObjectsWithTag("Enemy"))
{
Destroy(go);
}
return;
}
hp -= Time.deltaTime;
//Move
xSpeed = playerSpeed * Input.GetAxis("Horizontal");
if (xSpeed < -deadZone)
{
transform.localScale = new Vector3(-6, transform.localScale.y, transform.localScale.z);
anim.SetBool("Walking", true);
}
else if (xSpeed > deadZone)
{
transform.localScale = new Vector3(6, transform.localScale.y, transform.localScale.z);
anim.SetBool("Walking", true);
}
else
{
anim.SetBool("Walking", false);
}
if (forceDirection)
{
if (gunRight)
{
transform.localScale = new Vector3(6, transform.localScale.y, transform.localScale.z);
}
else
{
transform.localScale = new Vector3(-6, transform.localScale.y, transform.localScale.z);
}
}
//Jump
if (Input.GetButton("Jump") && (grounded || heldDown < 10))
{
heldDown++;
velocity.y = jumpSpeed;
}
else if (!Input.GetButton("Jump") && !grounded)
{
heldDown = 10;
}
//Jump animation
if (grounded)
{
heldDown = 0;
anim.SetBool("InAir", false);
}
else
{
anim.SetBool("InAir", true);
}
//Sword
if (Input.GetMouseButtonDown(0) && swordCooldown < 0)
{
swordCooldown = 0.5f;
GetComponent <AudioSource>().clip = attackSound;
GetComponent <AudioSource>().Play();
anim.SetBool("Attack", true);
}
else
{
anim.SetBool("Attack", false);
}
//Gun
if (Input.GetMouseButtonDown(1) && cooldown < 0)
{
GetComponent <AudioSource>().clip = shootSound;
GetComponent <AudioSource>().Play();
cooldown = 0.4f;
Vector3 direction = Camera.main.ScreenToWorldPoint(Input.mousePosition) - gun.position;
direction.Normalize();
RaycastHit2D[] hitInfos = Physics2D.RaycastAll(gun.position, direction, 20);
gunRight = direction.x > 0;
GameObject line = new GameObject();
line.transform.position = gun.position;
line.AddComponent <LineRenderer>();
LineRenderer lr = line.GetComponent <LineRenderer>();
lr.material = new Material(Shader.Find("Particles/Alpha Blended Premultiply"));
lr.startColor = Color.red;
lr.endColor = Color.red;
lr.startWidth = 0.1f;
lr.endWidth = 0.1f;
lr.SetPosition(0, gun.position);
lr.SetPosition(1, direction.normalized * 20f + gun.position);
GameObject.Destroy(line, 0.1f);
for (int i = 0; i < hitInfos.Length; i++)
{
RaycastHit2D hitInfo = hitInfos[i];
if (hitInfo && hitInfo.transform.gameObject.layer == LayerMask.NameToLayer("Enemy"))
{
EnemyAI enemy = hitInfo.transform.GetComponent <EnemyAI>();
if (enemy != null)
{
enemy.stunTimer = 2;
}
}
}
anim.SetBool("Shoot", true);
}
else
{
anim.SetBool("Shoot", false);
}
//Teleport
if (Input.GetMouseButtonDown(2) && cooldown < 0)
{
cooldown = 0.4f;
Vector3 pos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
Transform collider = transform.Find("Teleport");
collider.position = pos + transform.position;
ContactFilter2D cf = new ContactFilter2D();
cf.NoFilter();
collider.GetComponent <Collider2D>().enabled = true;
Collider2D[] cols = new Collider2D[16];
if (collider.GetComponent <Collider2D>().OverlapCollider(cf, cols) == 0)
{
transform.position = pos;
GetComponent <AudioSource>().clip = teleportSound;
GetComponent <AudioSource>().Play();
}
collider.GetComponent <Collider2D>().enabled = false;
if (slowmotion < 0.4f)
{
slowmotion = 0.4f;
}
}
cooldown -= Time.deltaTime;
swordCooldown -= Time.deltaTime;
}
// Start is called before the first frame update
void Start()
{
contactFilter = new ContactFilter2D();
contactFilter.SetLayerMask(damageMask);
}
protected virtual void Awake()
{
boxCollider = GetComponent <BoxCollider2D>();
colliders = new Collider2D[10];
obstacleFilter = new ContactFilter2D();
}
IEnumerator PoisonDebuff()
{
// slows enemy
myEnemy.rb.velocity *= .1f;
// UPGRADE POISON 0 FAST KILL
if (EnhancementManager.instance.upgrades["Poison"].upgrade[0])
{
yield return(new WaitForSeconds(1));
}
else
{
yield return(new WaitForSeconds(2));
}
// UPGRADE POISON 1 SINGLE SPREAD
if (EnhancementManager.instance.upgrades["Poison"].upgrade[1])
{
if (Random.value < .5f)
{
ContactFilter2D cf = new ContactFilter2D();
cf.layerMask = 1 << 8;
Collider2D[] res = new Collider2D[20];
Physics2D.OverlapCircle(transform.position, 1, cf, res);
foreach (Collider2D c in res)
{
if (c == null)
{
break;
}
try
{
GameObject infected = c.gameObject;
GameObject debuff = infected.transform.Find("Debuff").gameObject;
// go next if already infected
if (debuff.transform.Find("PoisonDebuff") != null)
{
continue;
}
// gets guarantee infection
else
{
Instantiate(poisonConnect, debuff.transform).transform.localPosition = Vector3.zero;
infected.GetComponentInChildren <PoisonConnect>().source = transform.parent.gameObject;
Instantiate(gameObject, debuff.transform).transform.localPosition = Vector3.zero;
break;
}
}
catch
{
}
}
}
}
// UPGRADE POISON 2 CIRCLE SPREAD S
if (EnhancementManager.instance.upgrades["Poison"].upgrade[2])
{
if (Random.value < .25f)
{
ContactFilter2D cf = new ContactFilter2D();
cf.layerMask = 1 << 8;
Collider2D[] res = new Collider2D[20];
Physics2D.OverlapCircle(transform.position, .75f, cf, res);
foreach (Collider2D c in res)
{
if (c == null)
{
break;
}
try
{
GameObject infected = c.gameObject;
GameObject debuff = infected.transform.Find("Debuff").gameObject;
Instantiate(poisonConnect, debuff.transform).transform.localPosition = Vector3.zero;
infected.GetComponentInChildren <PoisonConnect>().source = transform.parent.gameObject;
Instantiate(gameObject, debuff.transform).transform.localPosition = Vector3.zero;
}
catch
{
}
}
}
}
// UPGRADE POISON 3 CIRCLE SPREAD L
if (EnhancementManager.instance.upgrades["Poison"].upgrade[3])
{
if (Random.value < .10f)
{
ContactFilter2D cf = new ContactFilter2D();
cf.layerMask = 1 << 8;
Collider2D[] res = new Collider2D[20];
Physics2D.OverlapCircle(transform.position, 1.25f, cf, res);
foreach (Collider2D c in res)
{
if (c == null)
{
break;
}
try
{
GameObject infected = c.gameObject;
GameObject debuff = infected.transform.Find("Debuff").gameObject;
Instantiate(poisonConnect, debuff.transform).transform.localPosition = Vector3.zero;
infected.GetComponentInChildren <PoisonConnect>().source = transform.parent.gameObject;
Instantiate(gameObject, debuff.transform).transform.localPosition = Vector3.zero;
}
catch
{
}
}
}
}
// kills enemy
Destroy(gameObject);
myEnemy.Die("Poison");
}
/**
* Initialize the player when it is started.
*/
private void Start()
{
groundHits = new RaycastHit2D[16];
groundFilter = GetGroundContactFilter2D();
}
public void teleport()
{
a.PlaySound("dash");
trail.emitting = true;
Vector2 startp = mainCode.trs.position;
trail.AddPosition(mainCode.trs.position);
mainCode.trs.position += Vector3.right * mainCode.movSen * 1f;
tptm = tpCd;
Vector2 dir = new Vector2(Mathf.RoundToInt(mainCode.axis), Mathf.RoundToInt(mainCode.ayis));
dir.Normalize();
Vector2 siz = this.gameObject.GetComponent <CapsuleCollider2D>().size;
Vector2 ofs = this.gameObject.GetComponent <CapsuleCollider2D>().offset;
Vector2 final;
GameObject in_portal = Instantiate(Tp, mainCode.trs.position, mainCode.trs.rotation);
in_portal.GetComponent <SpriteRenderer>().color = new Color(0.15f, 0.4f, 0.33f, 1);
CapsuleCollider2D col = this.gameObject.GetComponent <CapsuleCollider2D>();
List <RaycastHit2D> touchingpoints = new List <RaycastHit2D>();
ContactFilter2D c = new ContactFilter2D();
c.SetLayerMask(LayerMask.GetMask("solid"));
if (dir == Vector2.zero)
{
dir = mainCode.movSen * Vector2.right;
}
int dest = col.Raycast(dir, c, touchingpoints, teleportRange);
if (dest > 0)
{
Debug.Log(c.IsFilteringLayerMask(touchingpoints[0].transform.gameObject));
final = touchingpoints[0].point - dir;
}
else
{
final = (Vector2)mainCode.trs.position + (dir * teleportRange);
}
trail.AddPosition(final);
Debug.DrawLine(mainCode.trs.position, final, Color.red, 5);
ext_portal = Instantiate(Tp, final, mainCode.trs.rotation);
ext_portal.GetComponent <SpriteRenderer>().color = new Color(0f, 1f, 0.57f, 1);
mainCode.flytime = 0;
mainCode.trs.position = final;
trail.AddPosition(final);
if (swordtrail.emitting)
{
c.SetLayerMask(LayerMask.GetMask("hitable"));
col.Raycast(-dir, c, touchingpoints, teleportRange);
foreach (RaycastHit2D targ in touchingpoints)
{
if (targ)
{
if (targ.collider.gameObject.tag.Equals("hitable"))
{
var hited = targ.transform.gameObject.GetComponent <CombatEnemy>();
hited.takedamage(mainCode.attackdmg, mainCode.knockback);
}
if (targ.collider.gameObject.tag.Equals("Boss"))
{
var hited = targ.collider.gameObject.GetComponent <HitableParts>();
if (hited)
{
hited.takedamage(mainCode.attackdmg);
}
else
{
var bhited = targ.collider.gameObject.GetComponent <InfectedNKBehavior>();
bhited.bossCore.takedamage(mainCode.attackdmg);
}
}
}
}
}
//trail.emitting = false;
}
IEnumerator BouncingSpriteLerp(SO_SpriteBounce sBSO)
{
// Grab the variables and values from the sprite bounce Scriptable Object.
float moveDist = sBSO.MoveDist;
float radius = sBSO.radius;
ContactFilter2D contactFilter = sBSO.contactFilter;
float startSpeed = sBSO.StartSpeed;
float slidePercentOfDist = sBSO.slidePercentOfDist;
int bounces = sBSO.Bounces;
float bounceHeight = sBSO.BounceHeight;
AnimationCurve bounceCurve = sBSO.bounceCurve;
float heightLossMult = sBSO.heightLossMult;
float targetZRotation = sBSO.Rotation;
// Movement Variables.
Vector2 curMainPos = spriteToMoveTrans.position;
Vector2 startPos = spriteToMoveTrans.position;
Vector2 endPos = startPos + (direction * moveDist);
//Raycast variables.
Vector2 prevDirection = direction;
Vector2 prevHitPos = startPos;
float distLeft = moveDist;
float distUsed = 0f;
bool checkCollisions = true;
List <Vector2> hitPositions = new List <Vector2>();
List <float> hitDistPercentAdded = new List <float>();
List <float> hitDistPercent = new List <float>();
// Fire reflecting raycasts to determine the object's trajectory.
while (checkCollisions)
{
RaycastHit2D rayHit = Physics2D.CircleCast(prevHitPos, radius - testReduce, prevDirection, distLeft, contactFilter.layerMask);
if (rayHit.collider != null)
{
Debug.DrawLine(prevHitPos, rayHit.centroid, Color.red, 5f);
float distanceToCol = (rayHit.centroid - prevHitPos).magnitude;
// Calculate the new maximum moveDist left.
distLeft -= distanceToCol;
distUsed += distanceToCol;
prevHitPos = rayHit.centroid;
// Add the moveDist traveled so far on 1 to a list, to know when to change direction.
hitDistPercent.Add(distanceToCol / moveDist);
hitDistPercentAdded.Add(distUsed / moveDist);
// Store the hit position to know where to move to next.
hitPositions.Add(rayHit.centroid);
// Get the reflected direction and fire a raycast with a length of the moveDist left to see if we hit anything else.
Vector2 reflectDir = Vector2.Reflect(prevDirection, rayHit.normal).normalized;
prevDirection = reflectDir;
testReduce += testReduce;
}
else
{
checkCollisions = false;
// If the ray dosnt hit anything calculate the last position and add it to the list.
hitPositions.Add(prevHitPos + (prevDirection * distLeft));
hitDistPercent.Add(distLeft / moveDist);
hitDistPercentAdded.Add(1f);
Debug.DrawLine(prevHitPos, prevHitPos + (prevDirection * distLeft), Color.red, 5f);
}
yield return(null);
}
// Start moving the object.
bool movementDone = false;
int curTarget = 0;
curSpeed = startSpeed;
// Bounce variables.
int bounceCount = 0;
float bounceTimer = 0f;
float slideDist = slidePercentOfDist * moveDist;
//print(slideDist);
float bounceSegDur = ((moveDist - slideDist) / bounces) / curSpeed;
float yPos = 0f;
float baseYPos = spriteToBounceTrans.localPosition.y;
float startY = 0f;
float curBounceHeight = bounceHeight;
float endY = curBounceHeight;
bool bouncing = true;
// Rotation variables.
bool rotating = true;
float moveDuration = (moveDist - (slideDist * 0.5f)) / curSpeed;
float rotationDelta = targetZRotation / moveDuration;
Vector3 targetRotation = new Vector3(spriteToBounceTrans.eulerAngles.x, spriteToBounceTrans.eulerAngles.y, targetZRotation);
float zRotation;
//float rotationDelta =
// Move the object.
while (!movementDone)
{
spriteToMoveTrans.position = Vector2.MoveTowards(spriteToMoveTrans.position, hitPositions[curTarget], curSpeed * Time.deltaTime);
if (((Vector2)spriteToMoveTrans.position - hitPositions[curTarget]).magnitude <= 0.001f)
{
curTarget++;
if (curTarget >= hitPositions.Count)
{
movementDone = true;
}
}
// Bounce the object.
if (bouncing)
{
bounceTimer += Time.deltaTime / bounceSegDur;
yPos = Mathf.Lerp(startY, endY, bounceCurve.Evaluate(bounceTimer));
//print(yPos);
if (bounceTimer >= 1f || movementDone)
{
curBounceHeight *= heightLossMult;
endY = curBounceHeight;
//print(curBounceHeight);
bounceSegDur = ((moveDist - slideDist) / bounces) / curSpeed;
bounceCount++;
bounceTimer = 0f;
yPos = 0f;
//print(bounceCount);
if (bounceCount >= bounces)
{
bouncing = false;
//print(bouncing);
}
}
spriteToBounceTrans.localPosition = new Vector3(spriteToBounceTrans.localPosition.x, baseYPos + yPos, spriteToBounceTrans.localPosition.z);
}
// Rotate the object.
if (rotating)
{
zRotation = Mathf.MoveTowards(spriteToBounceTrans.eulerAngles.z, targetZRotation, rotationDelta * Time.deltaTime);
spriteToBounceTrans.eulerAngles = new Vector3(0f, 0f, zRotation);
}
yield return(null);
}
spriteR.sortingOrder = -1;
}
private void explorePath(MoveAction move, Vector2 target, PathAction parent, PriorityQueue front, Hashtable map, ContactFilter2D filter)
{
RaycastHit2D[] hits = new RaycastHit2D[1];
Vector2 newPos = centerVector(parent.pos + move.dir.normalized * move.dist);
//Debug.Log(parent.pos + " -> " + newPos);
if (!map.Contains(newPos))
{
if (MoveSets.checkMove(move.type, parent.pos, move, filter))
{
PathAction newAct = new PathAction(newPos, parent, move, target);
map.Add(newPos, newAct);
front.Push(newAct);
}
}
else
{
//check if should update value in frontier
if (MoveSets.checkMove(move.type, parent.pos, move, filter) /*Physics2D.Raycast(parent.pos, move.dir, filter, hits, move.dist+.1f) <= 0*/)
{
PathAction oldAct = (PathAction)map[newPos];
if (parent.dist + move.dist < oldAct.dist)
{
oldAct.move = move;
oldAct.parent = parent;
front.Update(oldAct, parent.dist + move.dist);
}
}
}
}
private void Update()
{
stateTime += Time.deltaTime;
if (Time.frameCount % 60 == 0)
{
PlayerCheck(); //check slow
}
if (state == (int)States.IDLE)
{
if (stateTime > idleTime)
{
StartWalking();
}
}
if (state == (int)States.WALK)
{
float xSpeed = left ? -3 : 3;
if (rb.velocity.magnitude < 0.1 && stateTime > 0.1f && jumped == false)
{
jumped = true;
rb.AddForce(new Vector3(0, 10, 0), ForceMode2D.Impulse);
}
Vector3 newVel = new Vector3(xSpeed, rb.velocity.y, 0);
rb.velocity = newVel;
if (stateTime > walkTime)
{
StartIdling();
}
}
if (state == (int)States.CHASE)
{
left = player.transform.position.x < transform.position.x;
float xSpeed = left ? -4 : 4;
jumpTime -= Time.deltaTime;
damageTime -= Time.deltaTime;
//if(damageTime < 0)
//{
// player.transform.position - transform.position).magniude
//}
if (player.transform.position.y - transform.position.y > 3 && jumpTime < 0)
{
List <Collider2D> overlaps = new List <Collider2D>();
ContactFilter2D filter = new ContactFilter2D();
filter.SetLayerMask(~(1 << 9));
if (groundCollider.OverlapCollider(filter, overlaps) > 0)
{
rb.AddForce(new Vector3(0, 10, 0), ForceMode2D.Impulse);
jumpTime = 2;
}
}
Vector3 newVel = new Vector3(xSpeed, rb.velocity.y, 0);
// Set velocity with added external velocity
rb.velocity = newVel + (Vector3)ExternalVelocity;
if (stateTime > walkTime)
{
StartIdling();
}
}
}
