/*------------------------------------------------------------------------------------------------------------------ * -- FUNCTION: calculateMH * -- * -- DATE: January 11, 2018 * -- * -- DESIGNER: Michael Goll * -- * -- PROGRAMMER: Michael Goll * -- * -- NOTES: * -- Calls the physics helper function that calculates the MH values for all the objects and * -- stores them in the appropriate data array. * ----------------------------------------------------------------------------------------------------------------------*/ private void calculateMH() { mh_boat = PhysicsCalculator.calculateMH(h_boat, mass_boat); mh_pilot = PhysicsCalculator.calculateMH(h_pilot, mass_pilot); mh_cannon = PhysicsCalculator.calculateMH(h_cannon, mass_cannon); mh_com = PhysicsCalculator.calculateCombined(mh_boat, mh_pilot, mh_cannon); }
/*------------------------------------------------------------------------------------------------------------------ * -- FUNCTION: calculateMH * -- * -- DATE: January 11, 2018 * -- * -- DESIGNER: Michael Goll * -- * -- PROGRAMMER: Michael Goll * -- * -- NOTES: * -- Calls the physics helper function that calculates the moment of inertia for all the objects and * -- stores them in the appropriate data array. * ----------------------------------------------------------------------------------------------------------------------*/ private void calculateMomentOfInertia() { moi_boat = PhysicsCalculator.calculateMOI(boat.getMass(), boat.getXDim(), boat.getZDim()); moi_pilot = PhysicsCalculator.calculateMOI(pilot.getMass(), pilot.getXDim(), pilot.getZDim()); moi_cannon = PhysicsCalculator.calculateMOI(cannon.getMass(), cannon.getXDim(), cannon.getZDim()); moi_com = PhysicsCalculator.calculateCombined(moi_boat, moi_pilot, moi_cannon); }
// Use this for initialization void Start() { numUpdates = 0; range = PhysicsCalculator.calculateRange(boat, target); moving = true; gunBallSpawned = false; initial = true; lastMarker = numUpdates; buffer = 3; fixedTime = Time.fixedDeltaTime; //calculate theta angle = PhysicsCalculator.calculateTheta(range, gunBallVelocity); //calculate the total time totalTime = PhysicsCalculator.calculateProjTime(range, gunBallVelocity, angle); //change angle to degrees angle = angle * 180 / Mathf.PI; angleText.text = "Angle: " + angle + " degrees"; //calculate Vx oldVx = PhysicsCalculator.calculateXVelocity(gunBallVelocity, angle); //calculate Vy oldVy = PhysicsCalculator.calculateYVelocity(gunBallVelocity, angle); }
/*------------------------------------------------------------------------------------------------------------------ * -- FUNCTION: calculateInertiaTotals * -- * -- DATE: January 11, 2018 * -- * -- DESIGNER: Michael Goll * -- * -- PROGRAMMER: Michael Goll * -- * -- NOTES: * -- Calls the physics helper function that calculates the inertia totals for all the objects and * -- stores them in the appropriate data array. * ----------------------------------------------------------------------------------------------------------------------*/ private void calculateInertiaTotals() { it_boat = PhysicsCalculator.calculateInertiaTotal(moi_boat, mh_boat); it_pilot = PhysicsCalculator.calculateInertiaTotal(moi_pilot, mh_pilot); it_cannon = PhysicsCalculator.calculateInertiaTotal(moi_cannon, mh_cannon); it_com = PhysicsCalculator.calculateCombined(it_boat, it_pilot, it_cannon); }
public void CollisionCalibration() { Vector3 totalNormalForce = Vector3.zero; int noOfCycles = 0; RaycastHit hit = rayCaster.GetCollisionData(velocity, 0); do { //Add one cycle noOfCycles++; //Make adjustments to normalforce Vector3 normalForce = MeasureNormalForce(); velocity += normalForce; totalNormalForce += normalForce; //Look for new collisions hit = rayCaster.GetCollisionData(velocity, 0); }while (hit.collider != null && noOfCycles < 1000); velocity = PhysicsCalculator.CalculateFriction(velocity, totalNormalForce, staticFrictionCo); if (hit.collider == null) { transform.position += velocity * Time.deltaTime; } }
/*------------------------------------------------------------------------------------------------------------------ * -- FUNCTION: calculateComValues * -- * -- DATE: January 11, 2018 * -- * -- DESIGNER: Michael Goll * -- * -- PROGRAMMER: Michael Goll * -- * -- NOTES: * -- Calls the physics helper function that calculates the center of mass the whole object and * -- stores them in the appropriate data array. * ----------------------------------------------------------------------------------------------------------------------*/ private void calculateComValues() { comX = PhysicsCalculator.calculateComX(mass_boat, boat.getX(), mass_pilot, pilot.getX(), mass_cannon, cannon.getX(), mass_com); comZ = PhysicsCalculator.calculateComZ(mass_boat, boat.getZ(), mass_pilot, pilot.getZ(), mass_cannon, cannon.getZ(), mass_com); comFloats[4] = comX; comFloats[5] = comZ; }
public Vector3 MeasureNormalForce() { Vector3 normalForce = Vector3.zero; RaycastHit hit = rayCaster.GetCollisionData(velocity, 0); normalForce = PhysicsCalculator.CalculateNormalForce(velocity, hit); return(normalForce); }
// Use this for initialization private void Start() { _rigidBody = GetComponent <Rigidbody>(); var coefficientofFriction = GetComponent <Collider>().material.dynamicFriction; var forceApplied = PhysicsCalculator.CalculateFlatForceRequired() }
// Use this for initialization void Start() { numUpdates = 0; moving = true; gunBallSpawned = false; initial = true; lastMarker = numUpdates; buffer = 5; fixedTime = Time.fixedDeltaTime; oldVz = gunBallVelocity; range = PhysicsCalculator.calculateRange(boat, target); xDifference = PhysicsCalculator.calculateXDifference(boat, target); collided = false; if (xDifference != 0) { // gamma = PhysicsCalculator.calculateGamma(xDifference, PhysicsCalculator.calculateRange(boat, target)); // gammaDegrees = PhysicsCalculator.toDegrees(gamma); // angle = PhysicsCalculator.calculateAngle(ACCELERATION, xDifference, range, gunBallVelocity); // angleAdjusted = (180 - PhysicsCalculator.toDegrees(angle)) / 2; // angle = PhysicsCalculator.toDegrees(angle) / 2; // oldVz = PhysicsCalculator.calculateGammaVelocity(gunBallVelocity, Mathf.Cos(gamma), Mathf.Sin(angleAdjusted * Mathf.PI / 180)); // oldVy = PhysicsCalculator.calculateGammaYVelocity(gunBallVelocity, angleAdjusted); // oldVx = PhysicsCalculator.calculateGammaVelocity(gunBallVelocity, Mathf.Sin(gamma), Mathf.Sin(angleAdjusted * Mathf.PI / 180)); } else { //calculate theta angle = PhysicsCalculator.calculateAngle(ACCELERATION, xDifference, range, gunBallVelocity); //change angle to degrees angle = PhysicsCalculator.toDegrees(angle) / 2; //calculate Vx oldVx = PhysicsCalculator.calculateXVelocity(gunBallVelocity, angle); //calculate Vy oldVy = PhysicsCalculator.calculateYVelocity(gunBallVelocity, angle); } //---------------- Lab #8 Additions ---------------- tau = PhysicsCalculator.calculateTau(projMass, dragCoefficient); windVelocity = 2.0f; windCoefficient = 0.1f; //---------------- Lab #9 Additions ---------------- jImpulse = PhysicsCalculator.calculateJImpulse((gunBallVelocity - targetVelocity), e, projMass, targetMass); momentumInitial.x = PhysicsCalculator.calculateMomentum(projMass, gunBallVelocity); momentumInitial.y = PhysicsCalculator.calculateMomentum(targetMass, targetVelocity); momentumInitial.z = momentumInitial.x + momentumInitial.y; }
void FixedUpdate() { if (moving && gunBallSpawned) { if (initial) { initial = false; timeBeg = Time.time; //rotates the cannon by the calculated angle boat.transform.rotation = Quaternion.Euler(-angle, 0, 0); } angle = PhysicsCalculator.calculateTheta(range, gunBallVelocity) * 180 / Mathf.PI; newVx = PhysicsCalculator.calculateVelocity(oldVx, 0, fixedTime); newVy = PhysicsCalculator.calculateVelocity(oldVy, ACCELERATION, fixedTime); //update positions accordingly newDx = PhysicsCalculator.calculateDistance(currentDx, 0, newVx, fixedTime); newDy = PhysicsCalculator.calculateDistance(currentDy, ACCELERATION, newVy, fixedTime); if (gunball.transform.position.y - target.transform.position.y <= 0.05 && numUpdates > 0) { moving = false; timeText.text = "Time: " + totalTime + " seconds"; } else { yDisplacement = newVy * fixedTime; zDisplacement = newVx * fixedTime; gunball.transform.position = new Vector3(gunball.transform.position.x, gunball.transform.position.y + yDisplacement, gunball.transform.position.z + zDisplacement); if (lastMarker + buffer < numUpdates) { lastMarker = numUpdates; Object.Instantiate(flightMarker, new Vector3(gunball.transform.position.x, gunball.transform.position.y + yDisplacement, gunball.transform.position.z + zDisplacement), Quaternion.identity); } } } if (moving && gunBallSpawned) { //update UI initialVelText.text = "Init. Velocity: " + gunBallVelocity + " m/s"; rangeText.text = "Range: " + range + " m"; timeText.text = "Time: " + (Time.time - timeBeg) + " seconds"; updatesText.text = "Updates: " + (numUpdates + 1) + " frames"; gunBallText.text = "Gunball Z: " + gunball.transform.position.z + " m"; numUpdates++; oldVx = newVx; oldVy = newVy; currentDx = newDx; currentDy = newDy; } }
/*------------------------------------------------------------------------------------------------------------------ * -- FUNCTION: calculateH * -- * -- DATE: January 11, 2018 * -- * -- DESIGNER: Michael Goll * -- * -- PROGRAMMER: Michael Goll * -- * -- NOTES: * -- Calls the physics helper function that calculates the H values for all the objects and * -- stores them in the appropriate data array. * ----------------------------------------------------------------------------------------------------------------------*/ private void calculateH() { h_boat = PhysicsCalculator.calculateRotationPoint(boat.getX(), boat.getZ(), comX, comZ); h_pilot = PhysicsCalculator.calculateRotationPoint(pilot.getX(), pilot.getZ(), comX, comZ); h_cannon = PhysicsCalculator.calculateRotationPoint(cannon.getX(), cannon.getZ(), comX, comZ); boatFloats[2] = h_boat; pilotFloats[2] = h_pilot; cannonFloats[2] = h_cannon; }
public void AddForces() { //Calculate velocity, add gravity Vector3 gravity = PhysicsCalculator.CalculateGravity(gravitationalForce); velocity = PhysicsCalculator.ApplyAcceleration(velocity, direction, acceleration); velocity += gravity; //Add Air resistance velocity = PhysicsCalculator.AddAirResistance(velocity, airResistance); }
/*------------------------------------------------------------------------------------------------------------------ * -- FUNCTION: calculateInertiaTotals * -- * -- DATE: January 11, 2018 * -- * -- DESIGNER: Michael Goll * -- * -- PROGRAMMER: Michael Goll * -- * -- NOTES: * -- Calls the physics helper function that calculates the inertia totals for all the objects and * -- stores them in the appropriate data array. * ----------------------------------------------------------------------------------------------------------------------*/ private void calculateInertiaTotals() { it_boat = PhysicsCalculator.calculateInertiaTotal(moi_boat, mh_boat); it_pilot = PhysicsCalculator.calculateInertiaTotal(moi_pilot, mh_pilot); it_cannon = PhysicsCalculator.calculateInertiaTotal(moi_cannon, mh_cannon); it_com = PhysicsCalculator.calculateCombined(it_boat, it_pilot, it_cannon); boatFloats[8] = it_boat; pilotFloats[8] = it_pilot; cannonFloats[8] = it_cannon; comFloats[8] = it_com; }
/*------------------------------------------------------------------------------------------------------------------ * -- FUNCTION: calculateMH * -- * -- DATE: January 11, 2018 * -- * -- DESIGNER: Michael Goll * -- * -- PROGRAMMER: Michael Goll * -- * -- NOTES: * -- Calls the physics helper function that calculates the MH values for all the objects and * -- stores them in the appropriate data array. * ----------------------------------------------------------------------------------------------------------------------*/ private void calculateMH() { mh_boat = PhysicsCalculator.calculateMH(h_boat, mass_boat); mh_pilot = PhysicsCalculator.calculateMH(h_pilot, mass_pilot); mh_cannon = PhysicsCalculator.calculateMH(h_cannon, mass_cannon); mh_com = PhysicsCalculator.calculateCombined(mh_boat, mh_pilot, mh_cannon); boatFloats[3] = mh_boat; pilotFloats[3] = mh_pilot; cannonFloats[3] = mh_cannon; comFloats[3] = mh_com; }
public void pause() { moving = !moving; //react to the collision oldVx = PhysicsCalculator.calculateRecoilVelocity(jImpulse, projMass, gunBallVelocity); gunBallVelocityFinal = oldVx; targetVelocity = PhysicsCalculator.calculateRecoilVelocity(-jImpulse, targetMass, targetVelocity); momentumFinal.x = PhysicsCalculator.calculateMomentum(projMass, oldVx); momentumFinal.y = PhysicsCalculator.calculateMomentum(targetMass, targetVelocity); momentumFinal.z = momentumFinal.x + momentumFinal.y; }
/*------------------------------------------------------------------------------------------------------------------ * -- FUNCTION: Start * -- * -- DATE: January 11, 2018 * -- * -- DESIGNER: Michael Goll * -- * -- PROGRAMMER: Michael Goll * -- * -- NOTES: * -- Initializes the various objects to call member functions. * -- Initializes the canvas controller to update the HUD. * -- Initializes the data arrays. * ----------------------------------------------------------------------------------------------------------------------*/ void Start() { //------- LAB #6 Additions ------- moving = false; initial = true; numUpdates = 0; fixedTime = Time.fixedDeltaTime; //calculate different acceleration directions thrust.x = PhysicsCalculator.calculateXThrust(force, angle); thrust.z = PhysicsCalculator.calculateZThrust(force, angle); thrustAngle.x = PhysicsCalculator.calculateXThrust(angularForce, angle); thrustAngle.z = PhysicsCalculator.calculateZThrust(angularForce, angle); }
// Use this for initialization void Start() { numUpdates = 0; currentD = 0; oldV = velocity; moving = true; if (useDrag) { dragConstant = PhysicsCalculator.calculateDragConstant(acceleration, velocity); } distance = PhysicsCalculator.calculateDistance(0, acceleration, velocity, time); dt = PhysicsCalculator.calculateDragTime(dragConstant, distance, velocity); }
void Start() { numUpdates = 0; moving = false; gunBallSpawned = false; initial = true; collided = false; lastMarker = numUpdates; buffer = 3; fixedTime = Time.fixedDeltaTime; //---------------- Lab #11 Additions ---------------- moi1 = PhysicsCalculator.calculateMOI(projMass); moi2 = PhysicsCalculator.calculateMOI(targetMass); }
void FixedUpdate() { //calculate what frame it is t = numUpdates * Time.deltaTime; if (moving) { if (useDrag) { newD = PhysicsCalculator.calculateDistanceDrag(currentD, oldV, Time.fixedDeltaTime, dragConstant); newV = PhysicsCalculator.calculateVelocityDrag(oldV, acceleration, Time.fixedDeltaTime, dragConstant); if (t >= dt) { moving = false; } } else { newD = PhysicsCalculator.calculateDistance(currentD, acceleration, oldV, Time.fixedDeltaTime); newV = PhysicsCalculator.calculateVelocity(oldV, acceleration, Time.fixedDeltaTime); if (t >= time) { moving = false; } } timeText.text = "Time: " + t + " seconds"; frameText.text = "Frame: " + numUpdates + " frames"; velocityText.text = "Velocity: " + oldV + " m/s"; distanceText.text = "Distance: " + currentD + " m"; } //need to recheck if moving before going to next frame. //moving could be changed to false before it reaches here so need to recheck. if (moving) { boat.transform.Translate(Vector3.forward * oldV * Time.deltaTime); currentD = newD; oldV = newV; numUpdates++; } }
void FixedUpdate() { if (moving) { //Calculate tau dynamically to account for mass changes tau = PhysicsCalculator.calculateTau(mass_com, dragCoefficient); //Calculate the boat's velocity for its forward motion vMax = PhysicsCalculator.calculteTerminalVelocity(force, dragCoefficient); newVz = PhysicsCalculator.calculateVelocityWithDrag(vMax, dragCoefficient, oldVz, fixedTime, mass_com); newDz = PhysicsCalculator.calculatePositionWithDrag(oldDz, force, dragCoefficient, fixedTime, mass_com, oldVz); //Calculate the linear movement acceleration with drag accelerationWithDrag = PhysicsCalculator.calculateAccelerationWithDrag(force, dragCoefficient, oldVz, mass_com); //Calculate the boat's velocity and acceleration with drag for its angular motion oMax = PhysicsCalculator.calculateTerminalAngularVelocity(turnForce, dragCoefficient); omega = PhysicsCalculator.calculateAngularVelocityWithDrag(oMax, dragCoefficient, oldOmega, fixedTime, mass_com); //Update the boat's position totalBoat.transform.Translate(newVx * fixedTime, 0, newVz * fixedTime); totalBoat.transform.Rotate(0, Mathf.Rad2Deg * (omega * fixedTime), 0, Space.Self); } if (moving) { numUpdates++; //update UI timeText.text = "Time: " + ((numUpdates) * fixedTime) + " seconds"; posText.text = "Velocity: " + newVz + "m/s"; angDText.text = "Acceleration " + accelerationWithDrag + " m/s^2"; disText.text = "Distance: " + newDz + " m"; oldDx = newDx; oldVx = newVx; oldDz = newDz; oldVz = newVz; oldOmega = omega; } }
// Use this for initialization void Start() { numUpdates = 0; range = PhysicsCalculator.calculateRange(boat, target); moving = true; gunBallSpawned = false; initial = true; lastMarker = numUpdates; buffer = 3; fixedTime = Time.fixedDeltaTime; xDifference = PhysicsCalculator.calculateXDifference(boat, target); if (xDifference != 0) { gamma = PhysicsCalculator.calculateGamma(xDifference, PhysicsCalculator.calculateRange(boat, target)); gammaDegrees = PhysicsCalculator.toDegrees(gamma); angle = PhysicsCalculator.calculateAngle(ACCELERATION, xDifference, range, gunBallVelocity); angleAdjusted = (180 - PhysicsCalculator.toDegrees(angle)) / 2; angle = PhysicsCalculator.toDegrees(angle) / 2; oldVz = PhysicsCalculator.calculateGammaVelocity(gunBallVelocity, Mathf.Cos(gamma), Mathf.Sin(angleAdjusted * Mathf.PI / 180)); oldVy = PhysicsCalculator.calculateGammaYVelocity(gunBallVelocity, angleAdjusted); oldVx = PhysicsCalculator.calculateGammaVelocity(gunBallVelocity, Mathf.Sin(gamma), Mathf.Sin(angleAdjusted * Mathf.PI / 180)); } else { //calculate theta angle = PhysicsCalculator.calculateTheta(range, gunBallVelocity); //change angle to degrees angle = angle * 180 / Mathf.PI; //calculate Vx oldVx = PhysicsCalculator.calculateXVelocity(gunBallVelocity, angle); //calculate Vy oldVy = PhysicsCalculator.calculateYVelocity(gunBallVelocity, angle); } }
/*------------------------------------------------------------------------------------------------------------------ * -- FUNCTION: Update * -- * -- DATE: January 11, 2018 * -- * -- DESIGNER: Michael Goll * -- * -- PROGRAMMER: Michael Goll * -- * -- NOTES: * -- Calls helper functions that calculate various attributes. * -- Calls helper functions to load data arrays used to display the various attributes to the user. * -- Updates the COM Point material to move the com point shader around. * ----------------------------------------------------------------------------------------------------------------------*/ void Update() { mass_boat = boat.getMass(); mass_pilot = pilot.getMass(); mass_cannon = cannon.getMass(); mass_com = PhysicsCalculator.calculateCombined(mass_boat, mass_pilot, mass_cannon); boatFloats[0] = mass_boat; pilotFloats[0] = mass_pilot; cannonFloats[0] = mass_cannon; comFloats[0] = mass_com; loadBoatFloats(); loadPilotFloats(); loadCannonFloats(); calculateMomentOfInertia(); calculateComValues(); calculateH(); calculateMH(); calculateInertiaTotals(); comPoint.SetVector("_COMPosition", new Vector3(comX, 0, comZ)); }
void FixedUpdate() { if (moving && gunBallSpawned) { if (initial) { initial = false; if (xDifference == 0) { //rotates the cannon by the calculated angle boat.transform.rotation = Quaternion.Euler(-angle, 0, 0); } else { //gamma/alpha rotation of the cannon boat.transform.rotation = Quaternion.Euler(-angle, PhysicsCalculator.toDegrees(gamma), 0); } } angle = PhysicsCalculator.calculateTheta(range, gunBallVelocity) * 180 / Mathf.PI; //run lab 4 // newVx = PhysicsCalculator.calculateVelocity(oldVx, 0, fixedTime); // newVy = PhysicsCalculator.calculateYVelocityGamma(oldVy, -ACCELERATION, fixedTime); newVz = PhysicsCalculator.calculateVelocity(oldVz, 0, fixedTime); // newDx = PhysicsCalculator.calculateXPosition(currentDx, oldVx, angle, gamma, fixedTime); // newDy = PhysicsCalculator.calculateYPosition(currentDy, oldVy, -ACCELERATION, fixedTime); // newDz = PhysicsCalculator.calculateZPosition(oldDz, oldVz, angle, PhysicsCalculator.toDegrees(gamma), fixedTime); if (Mathf.Abs(gunball.transform.position.z - target.transform.position.z) < 1 && numUpdates > 0 && !collided) { pause(); timeText.text = "Time: " + ((numUpdates + 1) * fixedTime) + " seconds"; } else { if (xDifference == 0) { gunball.transform.Translate(gunball.transform.position.x, gunball.transform.position.y, newVx * fixedTime); } else { // //handles any quadrant case // if (target.transform.position.x < boat.transform.position.x && target.transform.position.z < boat.transform.position.z) { // gunball.transform.Translate(-newVx * fixedTime, newVy * fixedTime, -newVz * fixedTime); // } else if (target.transform.position.x < boat.transform.position.x) { // gunball.transform.Translate(-newVx * fixedTime, newVy * fixedTime, newVz * fixedTime); // } else if (target.transform.position.z < boat.transform.position.z) { // gunball.transform.Translate(newVx * fixedTime, newVy * fixedTime, -newVz * fixedTime); // } else { // gunball.transform.Translate(newVx * fixedTime, newVy * fixedTime, newVz * fixedTime); // } if (!collided) { gunball.transform.Translate(gunball.transform.position.x, gunball.transform.position.y, gunBallVelocity * fixedTime); target.transform.Translate(0, 0, targetVelocity * fixedTime); } else { gunball.transform.Translate(bulletXFinal * fixedTime, gunball.transform.position.y, bulletZfinal * fixedTime); target.transform.Translate(targetXFinal * fixedTime, target.transform.position.y, targetZfinal * fixedTime); } } if (lastMarker + buffer < numUpdates) { lastMarker = numUpdates; Object.Instantiate(flightMarker, new Vector3(gunball.transform.position.x, gunball.transform.position.y + yDisplacement, gunball.transform.position.z + zDisplacement), Quaternion.identity); } } } if (moving && gunBallSpawned) { numUpdates++; //update UI posText.text = "Masses (Ball/Target): " + projMass + "kg, " + targetMass + "kg"; timeText.text = "Time: " + ((numUpdates + 1) * fixedTime) + " seconds"; updatesText.text = "Updates: " + (numUpdates + 1) + " frames"; oldVx = newVx; oldVz = newVz; currentDx = newDx; currentDy = newDy; oldDz = newDz; } }
public void pause() { moving = !moving; collided = true; R1.x = gunball.transform.position.x; R1.y = gunball.transform.position.y; R1.z = gunball.transform.position.z; R2.x = target.transform.position.x; R2.y = target.transform.position.y; R2.z = target.transform.position.z; P.z = target.transform.position.z - 0.5f; P.x = gunball.transform.position.x + (target.transform.position.x - gunball.transform.position.x) / 2; //reposition the cube gunball.transform.position = new Vector3(gunball.transform.position.x, gunball.transform.position.y, target.transform.position.z - 1); //Lab #10 normals.x = target.transform.position.x - gunball.transform.position.x; normals.z = target.transform.position.z - gunball.transform.position.z; //lab #11 additions lowCaseR1 = PhysicsCalculator.calculateSubtractVector(P, gunball.transform.position); lowCaseR2 = PhysicsCalculator.calculateSubtractVector(P, target.transform.position); //hacky fix :) normals.x = 0; tangentials.z = normals.x; //-------------------------------- jImpulse = PhysicsCalculator.calculateJImpulse((gunBallVelocity - targetVelocity), e, projMass, targetMass, normals, lowCaseR1, lowCaseR2, moi1, moi2); omegaBallF = -(omegaBallI + Vector3.Cross(lowCaseR1, (normals * jImpulse)) / moi1); omegaTargetF = omegaTargetI + Vector3.Cross(lowCaseR2, (normals * jImpulse)) / moi2; //Lab #10 jNormal = (jImpulse * normals.z) + (0 * normals.x); //react to the collision gunBallVelocityFinal = PhysicsCalculator.calculateRecoilVelocity(jNormal, projMass, gunBallVelocity); targetVelocityFinal = PhysicsCalculator.calculateRecoilVelocity(-jNormal, targetMass, targetVelocity); tangentials.z = normals.x * -1; tangentials.x = normals.z; bulletinitialNormal = (gunBallVelocity * normals.z) + (0 * normals.x); bulletinitialTang = (gunBallVelocity * tangentials.z) + (0 * tangentials.x); targetinitialNormal = (targetVelocity * normals.z) + (0 * normals.x); targetinitialTang = (targetVelocity * tangentials.z) + (0 * tangentials.z); //final normals bulletZfinalNormal = (jNormal / projMass + bulletinitialNormal) * normals.z; bulletZfinalTang = (bulletinitialTang * tangentials.z); targetZfinalNormal = ((-jNormal) / targetMass + targetinitialNormal) * normals.z; targetZfinalTang = (targetinitialTang * tangentials.z); //z velocities bulletZfinal = bulletZfinalNormal + bulletZfinalTang; targetZfinal = targetZfinalNormal + targetZfinalTang; bulletXfinalNormal = (jNormal / projMass + bulletinitialNormal) * normals.x; bulletXfinalTang = (bulletinitialTang * tangentials.x); targetXfinalNormal = ((-jNormal) / targetMass + targetinitialNormal) * normals.x; targetXfinalTang = targetinitialTang * tangentials.x; //x velocities bulletXFinal = bulletXfinalNormal + bulletXfinalTang; targetXFinal = targetXfinalNormal + targetXfinalTang; //bullet, target, final //momentum momentumInitialZ.x = projMass * gunBallVelocity; momentumInitialZ.y = targetMass * targetVelocity; momentumInitialZ.z = momentumInitialZ.x + momentumInitialZ.y; momentumFinalZ.x = projMass * bulletZfinal; momentumFinalZ.y = targetMass * targetZfinal; momentumFinalZ.z = momentumFinalZ.x + momentumFinalZ.y; momentumInitialX.x = 0f; momentumInitialX.y = 0f; momentumInitialX.z = momentumInitialX.x + momentumInitialX.y; momentumFinalX.x = projMass * bulletXFinal; momentumFinalX.y = targetMass * targetXFinal; momentumFinalX.z = momentumFinalX.x + momentumFinalX.y; //energy energyInitialZ.x = 0.5f * projMass * gunBallVelocity * gunBallVelocity; energyInitialZ.y = 0.5f * targetMass * targetVelocity * targetVelocity; energyInitialZ.z = energyInitialZ.x + energyInitialZ.y; energyFinalZ.x = 0.5f * projMass * bulletZfinal * bulletZfinal; energyFinalZ.y = 0.5f * targetMass * targetZfinal * targetZfinal; energyFinalZ.z = energyFinalZ.x + energyFinalZ.y; energyInitialX.x = 0.5f * projMass * 0.0f * 0.0f; energyInitialX.y = 0.5f * targetMass * 0.0f * 0.0f; energyInitialX.z = energyInitialX.x + energyInitialX.y; energyFinalX.x = 0.5f * projMass * bulletXFinal * bulletXFinal; energyFinalX.y = 0.5f * targetMass * targetXFinal * targetXFinal; energyFinalX.z = energyFinalX.x + energyFinalX.y; //rotational energy rotEnergy.x = (0.5f * moi1 * omegaBallF.y * omegaBallF.y); rotEnergy.y = (0.5f * moi2 * omegaTargetF.y * omegaTargetF.y); rotEnergy.z = rotEnergy.x + rotEnergy.y; totalEnergy = energyFinalZ.z + (0.5f * moi1 * omegaBallF.y * omegaBallF.y) + (0.5f * moi2 * omegaTargetF.y * omegaTargetF.y); //gunball momentum values Vector3 gunballInitialMomentum = new Vector3(momentumInitialX.x, 0.0f, momentumInitialZ.x); //nothing happening in x, hence why it's 0 Vector3 gunballFinalMomentum = new Vector3(0.0f, 0.0f, momentumFinalZ.x); //target momentum values Vector3 targetInitialMomentum = new Vector3(momentumInitialX.y, 0.0f, momentumInitialZ.y); //nothing happening in x, hence why it's 0 Vector3 targetFinalMomentum = new Vector3(0.0f, 0.0f, momentumFinalZ.y); LInitial = PhysicsCalculator.calculateAngularMomentum(lowCaseR1, lowCaseR2, gunballInitialMomentum, targetInitialMomentum); LFinal1 = Vector3.Cross(lowCaseR1, gunballFinalMomentum) + (moi1 * omegaBallF); LFinal2 = Vector3.Cross(lowCaseR2, targetFinalMomentum) + (moi2 * omegaTargetF); LFinalTotal = LFinal1 + LFinal2; }
void FixedUpdate() { if (moving && gunBallSpawned) { if (initial) { initial = false; if (xDifference == 0) { //rotates the cannon by the calculated angle boat.transform.rotation = Quaternion.Euler(-angle, 0, 0); } else { //gamma/alpha rotation of the cannon boat.transform.rotation = Quaternion.Euler(-angle, PhysicsCalculator.toDegrees(gamma), 0); } } angle = PhysicsCalculator.calculateTheta(range, gunBallVelocity) * 180 / Mathf.PI; newVx = PhysicsCalculator.calculateXVelocityWithWind(fixedTime, tau, oldVx, windCoefficient, windVelocity, gamma, dragCoefficient); newVy = PhysicsCalculator.calculateYVelocityWithWind(dragCoefficient, fixedTime, projMass, oldVy); newVz = PhysicsCalculator.calculateZVelocityWithWind(fixedTime, tau, oldVz, windCoefficient, windVelocity, gamma, dragCoefficient); newDx = PhysicsCalculator.calculateXPositionWithWind(currentDx, oldVx, tau, fixedTime, windCoefficient, windVelocity, dragCoefficient, gamma); newDy = PhysicsCalculator.calculateYPositionWithWind(currentDy, oldVy, tau, fixedTime); newDz = PhysicsCalculator.calculateZPositionWithWind(oldDz, oldVz, tau, fixedTime, windVelocity, gamma, windCoefficient, dragCoefficient); if (gunball.transform.position.y <= 0.05 && numUpdates > 0) { moving = false; timeText.text = "Time: " + ((numUpdates + 1) * fixedTime) + " seconds"; } else { if (xDifference == 0) { if (target.transform.position.z > boat.transform.position.z) { gunball.transform.Translate(gunball.transform.position.x, newVy * fixedTime, newVx * fixedTime); } else { gunball.transform.Translate(gunball.transform.position.x, newVy * fixedTime, -newVx * fixedTime); } } else { //handles any quadrant case if (target.transform.position.x < boat.transform.position.x && target.transform.position.z < boat.transform.position.z) { gunball.transform.Translate(-newVx * fixedTime, newVy * fixedTime, -newVz * fixedTime); } else if (target.transform.position.x < boat.transform.position.x) { gunball.transform.Translate(-newVx * fixedTime, newVy * fixedTime, newVz * fixedTime); } else if (target.transform.position.z < boat.transform.position.z) { gunball.transform.Translate(newVx * fixedTime, newVy * fixedTime, -newVz * fixedTime); } else { gunball.transform.Translate(newVx * fixedTime, newVy * fixedTime, newVz * fixedTime); } } if (lastMarker + buffer < numUpdates) { lastMarker = numUpdates; Object.Instantiate(flightMarker, new Vector3(gunball.transform.position.x, gunball.transform.position.y + yDisplacement, gunball.transform.position.z + zDisplacement), Quaternion.identity); } } } if (moving && gunBallSpawned) { numUpdates++; //update UI posText.text = "Position: " + gunball.transform.position.x + ", " + gunball.transform.position.y + ", " + gunball.transform.position.z; timeText.text = "Time: " + ((numUpdates + 1) * fixedTime) + " seconds"; updatesText.text = "Updates: " + (numUpdates + 1) + " frames"; oldVx = newVx; oldVy = newVy; oldVz = newVz; currentDx = newDx; currentDy = newDy; oldDz = newDz; } }
void FixedUpdate() { if (moving) { if (numUpdates == 100 && !dynamicControls) { moving = false; } //calculate the new distances and velocities newDx = PhysicsCalculator.calculateDistance(oldDx, acceleration.x, oldVx, fixedTime); newVx = PhysicsCalculator.calculateVelocity(oldVx, acceleration.x, fixedTime); newDz = PhysicsCalculator.calculateDistance(oldDz, acceleration.z, oldVz, Time.fixedDeltaTime); newVz = PhysicsCalculator.calculateVelocity(oldVz, acceleration.z, Time.fixedDeltaTime); if (rotLeft) { temp1 = accelerationL; } if (rotRight) { temp1 = accelerationR; } angularVelocity = oldAngularVelocity + (temp1 * fixedTime); angularDisplacement += Mathf.Abs(angularVelocity * fixedTime); distanceX += newVx * fixedTime; distanceZ += newVz * fixedTime; //------- LAB #7 Additions ------- tau = PhysicsCalculator.calculateTau(mass_com, dragCoefficient); vMax = PhysicsCalculator.calculteTerminalVelocity(force, dragCoefficient); newVz = PhysicsCalculator.calculateVelocityWithDrag(vMax, dragCoefficient, oldVz, fixedTime, mass_com); newDz = PhysicsCalculator.calculatePositionWithDrag(oldDz, force, dragCoefficient, fixedTime, mass_com, oldVz); accelerationWithDrag = PhysicsCalculator.calculateAccelerationWithDrag(force, dragCoefficient, oldVz, mass_com); totalBoat.transform.Translate(newVx * fixedTime, 0, newVz * fixedTime); } if (moving) { numUpdates++; //update UI timeText.text = "Time: " + ((numUpdates) * fixedTime) + " seconds, " + (numUpdates) + " updates"; posText.text = "Velocity: " + newVz + "m/s"; angDText.text = "Acceleration " + accelerationWithDrag + " m/s^2"; disText.text = "Distance: " + newDz + " m"; oldDx = newDx; oldVx = newVx; oldDz = newDz; oldVz = newVz; oldAngularVelocity = angularVelocity; } else { v_final = oldVz; } }
/*------------------------------------------------------------------------------------------------------------------ * -- FUNCTION: Update * -- * -- DATE: January 11, 2018 * -- * -- DESIGNER: Michael Goll * -- * -- PROGRAMMER: Michael Goll * -- * -- NOTES: * -- Calls helper functions that calculate various attributes. * -- Calls helper functions to load data arrays used to display the various attributes to the user. * -- Updates the COM Point material to move the com point shader around. * ----------------------------------------------------------------------------------------------------------------------*/ void Update() { //------- LAB #6 Additions ------- // acceleration = PhysicsCalculator.calculateAccelerationFromThrust(force, mass_com); if (Input.GetKeyDown(KeyCode.Space)) { moving = !moving; } if (Input.GetKeyDown(KeyCode.W)) { force = 30000; moving = true; } if (Input.GetKeyUp(KeyCode.W) && dynamicControls) { force = 0; } if (Input.GetKeyDown(KeyCode.Q)) { rotLeft = true; rotRight = false; } if (Input.GetKeyDown(KeyCode.E)) { rotRight = true; rotLeft = false; } if (initial) { //------- LAB #1 Originals ------- pilot = p.GetComponent <Pilot>(); boat = b.GetComponent <Boat>(); cannon = c.GetComponent <Cannon>(); mass_boat = boat.getMass(); mass_pilot = pilot.getMass(); mass_cannon = cannon.getMass(); mass_com = PhysicsCalculator.calculateCombined(mass_boat, mass_pilot, mass_cannon); calculateMomentOfInertia(); calculateComValues(); calculateH(); calculateMH(); calculateInertiaTotals(); comPoint.SetVector("_COMPosition", new Vector3(comX, 0, comZ)); //------- LAB #6 Additions ------- acceleration.x = PhysicsCalculator.calculateAccelerationFromThrust(thrust.x, mass_com); acceleration.z = PhysicsCalculator.calculateAccelerationFromThrust(thrust.z, mass_com); rLeft.x = 2 - comX; rLeft.y = 0; rLeft.z = -4 - comZ; rRight.x = -2 - comX; rRight.y = 0; rRight.z = -4 - comZ; torqueL = PhysicsCalculator.calculateCrossProd(new Vector3(thrustAngle.x, 0, thrustAngle.z), rLeft); torqueR = PhysicsCalculator.calculateCrossProd(new Vector3(thrustAngle.x, 0, thrustAngle.z), rRight); accelerationL = PhysicsCalculator.calculateAngularAcceleration(torqueL.y, it_com); accelerationR = PhysicsCalculator.calculateAngularAcceleration(torqueR.y, it_com); initial = false; } }
/*------------------------------------------------------------------------------------------------------------------ * -- FUNCTION: Update * -- * -- DATE: January 11, 2018 * -- * -- DESIGNER: Michael Goll * -- * -- PROGRAMMER: Michael Goll * -- * -- NOTES: * -- Calls helper functions that calculate various attributes. * -- Calls helper functions to load data arrays used to display the various attributes to the user. * -- Updates the COM Point material to move the com point shader around. * ----------------------------------------------------------------------------------------------------------------------*/ void Update() { //Pause/unpause simulation if (Input.GetKeyDown(KeyCode.Space)) { moving = !moving; } //Forward Thrust if (Input.GetKeyDown(KeyCode.W)) { force = 4000; } //Release forward thrust if (Input.GetKeyUp(KeyCode.W)) { force = 0; } //Left torque if (Input.GetKeyDown(KeyCode.Q)) { rotLeft = true; rotRight = false; turnForce = -1000; } //Right torque if (Input.GetKeyDown(KeyCode.E)) { rotRight = true; rotLeft = false; turnForce = 1000; } //Release directional torque if (Input.GetKeyUp(KeyCode.E) || Input.GetKeyUp(KeyCode.Q)) { rotRight = false; rotLeft = false; turnForce = 0; } if (initial) { //Initialize objects to access attributes pilot = p.GetComponent <Pilot>(); boat = b.GetComponent <Boat>(); cannon = c.GetComponent <Cannon>(); mass_boat = boat.getMass(); mass_pilot = pilot.getMass(); mass_cannon = cannon.getMass(); mass_com = PhysicsCalculator.calculateCombined(mass_boat, mass_pilot, mass_cannon); calculateMomentOfInertia(); calculateComValues(); calculateH(); calculateMH(); calculateInertiaTotals(); comPoint.SetVector("_COMPosition", new Vector3(comX, 0, comZ)); initial = false; } }
public void Jump() { { velocity = PhysicsCalculator.CalculateJump(velocity, JumpMagnitude); } }
public void pause() { moving = !moving; collided = true; float x = Mathf.Abs(gunball.transform.position.x - target.transform.position.x); float z = Mathf.Sqrt(1 - Mathf.Pow(x, 2)); gunball.transform.position = new Vector3(gunball.transform.position.x, gunball.transform.position.y, target.transform.position.z - z); //react to the collision gunBallVelocityFinal = PhysicsCalculator.calculateRecoilVelocity(jImpulse, projMass, gunBallVelocity); targetVelocityFinal = PhysicsCalculator.calculateRecoilVelocity(-jImpulse, targetMass, targetVelocity); //Lab #10 normals.x = target.transform.position.x - gunball.transform.position.x; normals.z = target.transform.position.z - gunball.transform.position.z; jNormal = (jImpulse * normals.z) + (0 * normals.x); tangentials.z = normals.x * -1; tangentials.x = normals.z; bulletinitialNormal = (gunBallVelocity * normals.z) + (0 * normals.x); bulletinitialTang = (gunBallVelocity * tangentials.z) + (0 * tangentials.x); targetinitialNormal = (targetVelocity * normals.z) + (0 * normals.x); targetinitialTang = (targetVelocity * tangentials.z) + (0 * tangentials.z); bulletZfinalNormal = (jNormal / projMass + bulletinitialNormal) * normals.z; bulletZfinalTang = (bulletinitialTang * tangentials.z); targetZfinalNormal = ((-jNormal) / targetMass + targetinitialNormal) * normals.z; targetZfinalTang = (targetinitialTang * tangentials.z); //z velocities bulletZfinal = bulletZfinalNormal + bulletZfinalTang; targetZfinal = targetZfinalNormal + targetZfinalTang; bulletXfinalNormal = (jNormal / projMass + bulletinitialNormal) * normals.x; bulletXfinalTang = (bulletinitialTang * tangentials.x); targetXfinalNormal = ((-jNormal) / targetMass + targetinitialNormal) * normals.x; targetXfinalTang = targetinitialTang * tangentials.x; //x velocities bulletXFinal = bulletXfinalNormal + bulletXfinalTang; targetXFinal = targetXfinalNormal + targetXfinalTang; //bullet, target, final //momentum momentumInitialZ.x = projMass * gunBallVelocity; momentumInitialZ.y = targetMass * targetVelocity; momentumInitialZ.z = momentumInitialZ.x + momentumInitialZ.y; momentumFinalZ.x = projMass * bulletZfinal; momentumFinalZ.y = targetMass * targetZfinal; momentumFinalZ.z = momentumFinalZ.x + momentumFinalZ.y; momentumInitialX.x = 0f; momentumInitialX.y = 0f; momentumInitialX.z = momentumInitialX.x + momentumInitialX.y; momentumFinalX.x = projMass * bulletXFinal; momentumFinalX.y = targetMass * targetXFinal; momentumFinalX.z = momentumFinalX.x + momentumFinalX.y; //energy energyInitialZ.x = 0.5f * projMass * gunBallVelocity * gunBallVelocity; energyInitialZ.y = 0.5f * targetMass * targetVelocity * targetVelocity; energyInitialZ.z = energyInitialZ.x + energyInitialZ.y; energyFinalZ.x = 0.5f * projMass * bulletZfinal * bulletZfinal; energyFinalZ.y = 0.5f * targetMass * targetZfinal * targetZfinal; energyFinalZ.z = energyFinalZ.x + energyFinalZ.y; energyInitialX.x = 0.5f * projMass * 0.0f * 0.0f; energyInitialX.y = 0.5f * targetMass * 0.0f * 0.0f; energyInitialX.z = energyInitialX.x + energyInitialX.y; energyFinalX.x = 0.5f * projMass * bulletXFinal * bulletXFinal; energyFinalX.y = 0.5f * targetMass * targetXFinal * targetXFinal; energyFinalX.z = energyFinalX.x + energyFinalX.y; totalEnergy = energyFinalX.z + energyFinalZ.z; }