public void BuildFace(ModelData data, Vector3 start, Vector3 offset1, Vector3 offset2)
{
int index = data.verts.Count;
Vector3 scale = GetScale();
start.Scale(scale);
offset1.Scale(scale);
offset2.Scale(scale);
if (IsCentered())
{
Vector3 o = data.offset;
o.Scale(scale);
start -= o;
}
data.verts.Add(start);
data.verts.Add(start + offset1);
data.verts.Add(start + offset2);
data.verts.Add(start + offset1 + offset2);
data.tris.Add(index + 0);
data.tris.Add(index + 1);
data.tris.Add(index + 2);
data.tris.Add(index + 3);
data.tris.Add(index + 2);
data.tris.Add(index + 1);
}
public IEnumerator ChooseDestination(float time, Vector3 faceDirection)
{
yield return new WaitForSeconds(time);
isMoving = true;
faceDirection.Scale(new Vector3(Random.Range(-1.0f, 1.0f), 0, Random.Range(-1.0f, 1.0f)));
if (gameObject == alphaLeader) {
faceDirection *= Random.Range(30, 200);
destination = transform.position + faceDirection;
} else {
faceDirection *= Random.Range(30, 100);
destination = alphaLeader.transform.position + faceDirection;
}
NavMeshHit hit;
if (NavMesh.SamplePosition(destination, out hit, 100, 1)) {
destination = hit.position;
agent.SetDestination(destination);
//CreateDestinationSphere(destination);
}
}
// Update is called once per frame
void Update()
{
transform.Rotate (move, Time.deltaTime * speed);
counter++;
if (counter > change_dir) {
counter = 0;
dir = (dir + 1) % 7;
}
switch (dir){
case 0:
dir_ = Vector3.right;
break;
case 1:
dir_ = Vector3.forward;
break;
case 2:
dir_= Vector3.left;
break;
case 3:
dir_ = Vector3.back;
break;
case 4:
dir_ = Vector3.up;
break;
case 5:
dir_= Vector3.right;
break;
case 6:
dir_ = Vector3.down;
break;
}
dir_.Scale (scaler);
move = move + dir_;
move = move.normalized;
}
// Update is called once per frame
void Update()
{
amp.x = Screen.width;
float num = splitNum;
float d = 1.0f / num;
d = Mathf.Clamp01(d);
graphics.Clear();
for(int i = 0; i < num+1; i++){
float x = d * i;
float y = curve.Evaluate(x);
Vector3 pos = new Vector3(x,y,0);
pos.Scale(amp);
Color c = Color.Lerp(Color.black, color, x);
if(i == 0){
graphics.MoveTo(pos, c, thickness);
}else{
graphics.LineTo(pos, c, thickness);
}
}
graphics.Render();
}
public float maxXForceFraction; // = 2
IEnumerator SpawnTarget()
{
while (true)
{
yield return new WaitForSeconds(Random.Range(minSpawnTime, maxSpawnTime));
if (Target != null)
{
GameObject curr = (GameObject)Instantiate(
Target,
new Vector3(Random.Range(-150, 150), -100, 0),
Quaternion.identity
);
Vector3 force = new Vector3();
force.x = curr.transform.position.x <= 0.0f ? 1 : -1;
force.x *= Random.Range(minXForceFraction, maxYForceFraction);
force.y = Random.Range(minYForceFraction, maxXForceFraction);
force.z = 0;
force.Scale(forceScale);
Rigidbody rb = curr.GetComponent<Rigidbody>();
rb.AddForce(force, ForceMode.Impulse);
rb.angularVelocity = new Vector3(0,0,Random.Range(-150, 150));
}
}
}
void translate(Vector3 delta)
{
Vector3 newPos = transform.position;
delta.Scale(parallaxFactor);
newPos = basePlanePos - delta;
transform.position = newPos;
}
//-------------------------------------------------------------------------
public void MoveTo(Vector2 pos, float speed)
{
Vector3 currPos = this.transform.position;
velocity_ = new Vector3(pos.x, pos.y, currPos.z) - currPos;
velocity_.Normalize();
velocity_.Scale(new Vector3(speed, speed, speed));
dest_ = new Vector3(pos.x, pos.y, currPos.z);
isMoving_ = true;
}
void LateUpdate()
{
oldPos = transform.position;
if (BuildTypeData.buildType == BuildType.VITA&&!Input.GetMouseButton(0)){
if ((Input.GetAxisRaw("RHorizontal") > 0.1f || Input.GetAxis("RHorizontal") < -0.1f) ||
Input.GetAxisRaw("RVertical") > 0.1f || Input.GetAxis("RVertical") < -0.1f){
Vector3 inputRightStick = new Vector3(Input.GetAxisRaw("RHorizontal"), Input.GetAxisRaw("RVertical"), 0);
inputRightStick.Scale(new Vector3(( camSizeInUnity / 5f), -((camSizeInUnity / 6f)*0.5625f),0));
targetPos = (cameraTarget.transform.position + inputRightStick);
}else{
targetPos = cameraTarget.transform.position;
}
}else{
//get input and mouse position
Vector3 mouseScreenPos = Input.mousePosition;
int screenWidth = Screen.width;
int screenHeight = Screen.height;
if (mouseScreenPos.x < 0) {
mouseScreenPos.x = 0;
}
else if (mouseScreenPos.x > screenWidth){
mouseScreenPos.x = screenWidth;
}
if (mouseScreenPos.y < 0) {
mouseScreenPos.y = 0;
}
else if (mouseScreenPos.y > screenHeight){
mouseScreenPos.y = screenHeight;
}
Ray mouseRay = Camera.main.ScreenPointToRay(mouseScreenPos);
Vector3 mousePosition = new Vector3(mouseRay.origin.x, mouseRay.origin.y, 0);
Vector2 mousePos2D = new Vector2(mouseRay.origin.x, mouseRay.origin.y);
Vector3 distMouseTarget = mousePosition - cameraTarget.transform.position;
targetPos = (cameraTarget.transform.position + (distMouseTarget / 3));
}
if (cameraFollowX) {
newXPos = Mathf.SmoothDamp(oldPos.x, targetPos.x, ref velocity.x, smoothTime);
}
if (cameraFollowY){
newYPos = Mathf.SmoothDamp(oldPos.y, targetPos.y, ref velocity.y, smoothTime);
}
if(newXPos>maxXpos){
newXPos = maxXpos;
}else if(newXPos<minXpos){
newXPos = minXpos;
}
if(newYPos>maxYpos){
newYPos = maxYpos;
}else if(newYPos<minYpos){
newYPos = minYpos;
}
//Update camera position
newPos = new Vector3(newXPos,newYPos,oldPos.z);
transform.position = newPos;
}
private Vector3 ComputeAverageRotation(List<Vector3> rotations)
{
Vector3 avg = new Vector3();
foreach (var rot in rotations)
{
avg += rot;
}
var scaling = new Vector3(1f / rotations.Count, 1f / rotations.Count, 1f / rotations.Count);
avg.Scale(scaling);
return avg;
}
/// <summary>
/// Performs the move.
/// </summary>
protected virtual void performMove()
{
timesIncremented = 0;
Tile.Map.moveActor(this.gameObject, _path[0].Location);
Vector3 pos = transform.position;
Vector3 goalPos = Tile.transform.position;
velocity = new Vector3(goalPos.x-pos.x, 0, goalPos.z - pos.z);
transform.LookAt(new Vector3(goalPos.x, pos.y, goalPos.z));
velocity.Scale(new Vector3(1/(float)NumberOfIncrements, 0, 1/(float)NumberOfIncrements));
_path.RemoveAt(0);
}
//calibrate rubber bands once
void calibrateRubberBand()
{
rubberBand = GetComponentInParent<LineRenderer> ();
orthogonalSideOffset = Vector3.Cross (-transform.position, Vector3.up);
orthogonalSideOffset.Normalize ();
orthogonalSideOffset.Scale (new Vector3 (0.4f, 0.4f, 0.4f));
rubberBand.SetPosition (0, transform.position + orthogonalSideOffset);
rubberBand.SetPosition (1, transform.position + orthogonalSideOffset/2);
rubberBand.SetPosition (2, transform.position - orthogonalSideOffset/2);
rubberBand.SetPosition (3, transform.position - orthogonalSideOffset);
updateRubberBand ();
}
public void SetGrid0()
{
List<GameObject> out_list = new List<GameObject>();
Vector3 pos = plane_list[0].transform.position;
terrainGen.GetComponent<ProceduralToolkit.Examples.UI.LowPolyTerrainGeneratorUI>().SendPlane(plane_list[2]);
terrainGen.GetComponent<ProceduralToolkit.Examples.UI.LowPolyTerrainGeneratorUI>().SendPlane(plane_list[5]);
terrainGen.GetComponent<ProceduralToolkit.Examples.UI.LowPolyTerrainGeneratorUI>().SendPlane(plane_list[8]);
terrainGen.GetComponent<ProceduralToolkit.Examples.UI.LowPolyTerrainGeneratorUI>().SendPlane(plane_list[7]);
terrainGen.GetComponent<ProceduralToolkit.Examples.UI.LowPolyTerrainGeneratorUI>().SendPlane(plane_list[6]);
plane_list[8] = plane_list[4];
plane_list[4] = plane_list[0];
plane_list[5] = plane_list[1];
plane_list[7] = plane_list[3];
Vector3 dist0 = new Vector3(size_x, 0, size_z);
Vector3 dist1 = new Vector3(size_x, 0, size_z);
Vector3 dist2 = new Vector3(size_x, 0, size_z);
Vector3 dist3 = new Vector3(size_x, 0, size_z);
Vector3 dist4 = new Vector3(size_x, 0, size_z);
dist0.Scale(dir_list[(int)directions.NE]);
dist1.Scale(dir_list[(int)directions.EAST]);
dist2.Scale(dir_list[(int)directions.SE]);
dist3.Scale(dir_list[(int)directions.SOUTH]);
dist4.Scale(dir_list[(int)directions.SW]);
plane_list[6] = SpawnPlane(pos + dist0);
plane_list[3] = SpawnPlane(pos + dist1);
plane_list[0] = SpawnPlane(pos + dist2);
plane_list[1] = SpawnPlane(pos + dist3);
plane_list[2] = SpawnPlane(pos + dist4);
renamePlanes();
StitchRight(plane_list[7], plane_list[6]);
StitchRight(plane_list[4], plane_list[3]);
StitchRight(plane_list[1], plane_list[0]);
StitchRight(plane_list[2], plane_list[1]);
StitchDown(plane_list[6], plane_list[3]);
StitchDown(plane_list[3], plane_list[0]);
StitchDown(plane_list[4], plane_list[1]);
StitchDown(plane_list[5], plane_list[2]);
UpdatePlane(plane_list[7]);
UpdatePlane(plane_list[4]);
UpdatePlane(plane_list[1]);
UpdatePlane(plane_list[2]);
UpdatePlane(plane_list[6]);
UpdatePlane(plane_list[3]);
UpdatePlane(plane_list[5]);
}
public Vector3 GetAverageVelocity()
{
Vector3 averageVelocity = new Vector3();
foreach (Transform t in transform) {
averageVelocity += t.forward * (t.GetComponent<Boid>().maxSpeed+0.1f);
}
int count = transform.childCount;
averageVelocity.Scale(new Vector3(1.0f/count, 1.0f/count, 1.0f/count));
return averageVelocity;
}
public Vector3 GetAveragePosition()
{
Vector3 averagePosition = new Vector3();
foreach (Transform t in transform) {
averagePosition += t.position;
}
int count = transform.childCount;
averagePosition.Scale(new Vector3(1.0f/count, 1.0f/count, 1.0f/count));
return averagePosition;
}
public override Vector3 GetPosition(MBParticle PT)
{
float r = Random.Range(Hollow, 1);
float l = -Random.Range(0, Mathf.PI * 2);
float h = Random.Range(-Mathf.PI/2+Arc*Mathf.PI/2, Mathf.PI / 2);
float ch = Mathf.Cos(h);
Vector3 v = new Vector3(r * Mathf.Cos(l) * ch,
r * Mathf.Sin(h),
r * Mathf.Sin(l) * ch);
v.Scale(Scale);
return v;
}
//MIO TODO: This his written in a hurry. Rewrite the smart way
public void SpawnScore(Vector3 position, int value) {
Transform scorePrefabTransform = (Instantiate(scorePrefab, position, Quaternion.identity) as GameObject).transform;
scorePrefabTransform.parent = transform;
finalPosition = gameCamera.WorldToViewportPoint(position);
finalPosition = scoreCamera.ViewportToWorldPoint(finalPosition);
finalPosition.Scale(worldCoordScaleFactor);
scorePrefabTransform.position = finalPosition;
scorePrefabTransform.localScale = new Vector3(textSize, textSize, 1);
UILabel scoreUILabel = scorePrefabTransform.GetComponentInChildren<UILabel>();
scoreUILabel.text = value.ToString();
Destroy(scorePrefabTransform.gameObject, scorePrefabTransform.animation.clip.length);
}
// Update is called once per frame
void Update()
{
//randomly spawn enemies
if (Random.value < spawnChance){
Vector3 spawnTrans = new Vector3 (Random.Range(-.5f,.5f),Random.Range(-.5f,.5f),Random.Range(-.5f,.5f));
spawnTrans.Scale(spawnArea);
int randomIndex = Random.Range(0,enemySpawns.Length);
Vector3 pos = enemySpawns[randomIndex].transform.position;
//spawn enemy and put it in the right spot
Enemy e = (Enemy)Instantiate(enemyPrefab);
e.transform.position = pos + spawnTrans;
//parent to us (the spawner) so that this object can receive messages on death
e.transform.parent = transform;
}
}
//public bool derp;
//public Vector3 thevec;
//public Color color;
//public AnimationCurve curve;
//public Gradient gradient;
// Use this for initialization
//void Start () {
//
//}
// Update is called once per frame
void Update()
{
//Randomly spawn robot enemies
if(Random.value < spawnChance){
//choose position in a volume centered around local origin
Vector3 pos = new Vector3(Random.Range(-0.5f, 0.5f),Random.Range(-0.5f, 0.5f),Random.Range(-0.5f, 0.5f));
pos.Scale (spawnArea);
//spawn!
GameObject go = (GameObject)Instantiate (enemyPrefab);
go.transform.position = pos + transform.position;
//parent newly instantiated thing to "me" (spawnPoint)
go.transform.parent = transform;
}
}
public override Vector3 CalculateSteering(Vector3 pos)
{
Vector3 steering = new Vector3();
// Calculate steering
if (targetPoint != null) {
steering = new Vector3(pos.x - targetPoint.x, 0, pos.z - targetPoint.z).normalized;
steering.Scale(new Vector3(weight, weight, weight));
}
if (targetObject != null) {
steering = new Vector3(pos.x - targetObject.position.x, 0, pos.z - targetObject.position.z).normalized;
steering.Scale(new Vector3(weight, weight, weight));
}
return steering;
}
void Update()
{
//Randomly spawn enemies
if (Random.value < spawnChance && enemyPrefab)
{
//Pick a position in a box around this object
Vector3 pos = new Vector3(Random.Range(-0.5f, 0.5f), Random.Range(-0.5f, 0.5f), Random.Range(-0.5f, 0.5f));
pos.Scale(spawnArea);
//Spawn the enemy and put them in the right spot
Enemy e = (Enemy)Instantiate(enemyPrefab);
e.transform.position = transform.position + pos;
//Parent them to us, so this object can receive messages on death
e.transform.parent = transform;
}
}
// Update is called once per frame
void Update () {
if (Input.GetMouseButtonDown(0)) {
Ray ray = Camera.main.ScreenPointToRay (Input.mousePosition);
RaycastHit hit;
RaycastHit hit2;
Vector3 movePosition = new Vector3(0,0,0);
if(Physics.Raycast(ray, out hit, 100))
{
Debug.Log(ray.direction);
//Ray newray = new Ray(hit.point - hit.normal * 1000f, hit.normal);
Vector3 reverse = new Vector3(ray.direction.x * -1f, ray.direction.y * -1f, ray.direction.z * -1f);
Debug.Log(reverse);
reverse.Scale(new Vector3(5f, 5f, 5f));
//Debug.Log("Final vector" + reverse);
Vector3 newPosition = new Vector3(hit.point.x + reverse.x, hit.point.y + reverse.y, hit.point.z + reverse.z);
//hit.collider.Raycast(newray, out hit2, 100);
//Debug.Log ("reverse ray direction " + newray.direction);
//ray.direction
//Debug.Log("Current hitpoint: " + hit.point);
//hit.point.Set(hit.point.x - (ray.direction.x * 2f), hit.point.y - (ray.direction.y * 2f), hit.point.z);
//Debug.Log ("new hitpoint: " + hit.point);
/*
GameObject table = GameObject.Find("Table");
if(table != null)
{
float distance = Vector3.Distance(table.transform.GetChild(0).position, this.gameObject.transform.position);
for(int i = 1; i < table.transform.childCount; i++)
{
if(Vector3.Distance(table.transform.GetChild(i).position, this.gameObject.transform.position) < distance)
movePosition = table.transform.GetChild(i).position;
}
}
agent.SetDestination(movePosition);*/
agent.SetDestination (hit.point);
//Debug.Log("Old: " + hit.point);
//Debug.Log("New: " + newPosition);
//agent.SetDestination(newPosition);
}
}
}
public override Vector3 GetPosition(MBParticle PT)
{
float theta=0;//=PT.Parent.Transform.rotation.eulerAngles.z*Mathf.Deg2Rad;
if (!EvenlySpread)
theta = Random.Range(-Arc, Arc);
else if (DistributionPoints > 0) {
theta = -Arc + mDistributionStep * mDistribution++;
if (mDistribution >= DistributionPoints)
mDistribution = 0;
}
float d = Random.Range(Hollow, 1);
Vector3 v = new Vector3(d * -Mathf.Sin(theta),
d * Mathf.Cos(theta),0);
v.Scale(Scale);
return v;
}
public void UpdateWind()
{
if (getParentTarget && parentWind != null) {
wind = parentWind.wind;
localForces = parentWind.localForces;
windStartHeight = parentWind.windStartHeight;
if(getParentEmission)
partiSystem.emissionRate = parentWind.partiSystem.emissionRate;
return;
}
windTime += Time.deltaTime;
if (windTime > windRandomness) {
windTarget = Random.insideUnitSphere;
windTarget.Scale (windStrength);
windTime = 0f;
}
wind = Vector3.Lerp (wind, windTarget, windSmoothness);
}
void SpawnEnemy()
{
//Pick a position in a box around this object
Vector3 pos = new Vector3(Random.Range(-0.5f, 0.5f), Random.Range(-0.5f, 0.5f), Random.Range(-0.5f, 0.5f));
pos.Scale(civilianSpawn.transform.position);
//Spawn the enemy and put them in the right spot
int derp = Random.Range(0, 3);
if(derp == 0)
{
EnemyBehaviour e = (EnemyBehaviour)Instantiate(civilianPrefab);
e.transform.position = transform.position + pos;
//Parent them to us, so this object can receive messages on death
e.transform.parent = transform;
}
if(derp == 1)
{
EnemyBehaviour e = (EnemyBehaviour)Instantiate(robberPrefab);
e.transform.position = transform.position + pos;
//Parent them to us, so this object can receive messages on death
e.transform.parent = transform;
}
if(derp == 2)
{
EnemyBehaviour e = (EnemyBehaviour)Instantiate(copPrefab);
e.transform.position = transform.position + pos;
//Parent them to us, so this object can receive messages on death
e.transform.parent = transform;
}
if(derp == 3)
{
EnemyBehaviour e = (EnemyBehaviour)Instantiate(hostileCopPrefab);
e.transform.position = transform.position + pos;
//Parent them to us, so this object can receive messages on death
e.transform.parent = transform;
}
}
public IEnumerator ChooseDestination(float time, Vector3 faceDirection)
{
yield return new WaitForSeconds(time);
isMoving = true;
faceDirection.Scale(new Vector3(Random.Range(-1.0f, 1.0f), Random.Range(-1.0f, 1.0f), 0));
if (gameObject == alphaLeader) {
faceDirection *= Random.Range(10, 30);
destination = transform.position + faceDirection;
} else {
faceDirection *= Random.Range(30, 100);
destination = alphaLeader.transform.position + faceDirection;
}
destination[1] = 100;
// NavMeshHit hit;
//
// if (NavMesh.SamplePosition(destination, out hit, 100, 1)) {
// destination = hit.position;
// agent.SetDestination(destination);
//
// //CreateDestinationSphere(destination);
// }
RaycastHit hit;
Debug.DrawRay(destination, Vector3.down * 100);
if (Physics.Raycast(destination, Vector3.down, out hit, 100)) {
destination = hit.point;
agent.SetDestination(destination);
}
// if ((new Vector3(-12, transform.position.y, 60) - transform.position).magnitude) {
// } else if ((new Vector3(50, transform.position.y, 65) - transform.position).magnitude) {
// }
// CreateDestinationSphere(destination);
}
IEnumerator SpawnTarget()
{
while (true)
{
yield return new WaitForSeconds(Random.Range(minSpawnTime, maxSpawnTime));
if (Target != null)
{
GameObject curr = (GameObject)Instantiate(
Target,
new Vector3(Random.Range(-150, 150), -100, 0),
new Quaternion(Random.value, Random.value, Random.value, Random.value)
);
Vector3 force = new Vector3();
force.x = curr.transform.position.x <= 0.0f ? 1 : -1;
force.x *= Random.Range(minXForceFraction, 2);
force.y = Random.Range(minYForceFraction, 3);
force.z = 0;
force.Scale(forceScale);
curr.rigidbody.AddForce(force, ForceMode.Impulse);
curr.rigidbody.angularVelocity = new Vector3(Random.Range(-150, 150), 0, 0);
}
}
}
void LateUpdate ()
{
if (Input.GetKeyUp(KeyCode.F1))
{
experimental = !experimental;
}
if (!experimental)
{
transform.position = player.transform.position + offset;
}
else {
transform.position = player.transform.position;
Vector3 playerballvec = new Vector3(target.transform.position.x - player.transform.position.x, target.transform.position.y - player.transform.position.y, target.transform.position.z - player.transform.position.z);
playerballvec.Normalize();
playerballvec.Scale(new Vector3(3, 3, 3));
transform.position = new Vector3(player.transform.position.x - 3*playerballvec.x,
player.transform.position.y - playerballvec.y + 3,
player.transform.position.z - 3*playerballvec.z);
transform.LookAt(target.transform);
}
}
private void Emit()
{
ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams();
Vector3 pos = Vector3.zero;
switch (shape)
{
case KSPParticleEmitter.EmissionShape.Point:
pos = Vector3.zero;
break;
case KSPParticleEmitter.EmissionShape.Line:
pos = new Vector3(Random.Range(-shape1D, shape1D) * 0.5f, 0f, 0f);
break;
case KSPParticleEmitter.EmissionShape.Ellipsoid:
pos = Random.insideUnitSphere;
pos.Scale(shape3D);
break;
case KSPParticleEmitter.EmissionShape.Ellipse:
pos = Random.insideUnitCircle;
pos.x = pos.x * shape2D.x;
pos.z = pos.y * shape2D.y;
pos.y = 0f;
break;
case KSPParticleEmitter.EmissionShape.Sphere:
pos = Random.insideUnitSphere * shape1D;
break;
case KSPParticleEmitter.EmissionShape.Cuboid:
pos = new Vector3(
Random.Range(-shape3D.x, shape3D.x),
Random.Range(-shape3D.y, shape3D.y),
Random.Range(-shape3D.z, shape3D.z));
break;
case KSPParticleEmitter.EmissionShape.Plane:
pos = new Vector3(Random.Range(-shape2D.x, shape2D.x), 0f, Random.Range(-shape2D.y, shape2D.y));
break;
case KSPParticleEmitter.EmissionShape.Ring:
float posFloat = Random.Range(0f, 2f * Mathf.PI);
pos = new Vector3(Mathf.Sin(posFloat) * shape2D.x, 0f, Mathf.Cos(posFloat) * shape2D.y);
break;
}
Vector3 vel;
if (pe.simulationSpace == ParticleSystemSimulationSpace.Local)
{
vel = localVelocity + new Vector3(
Random.Range(-rndVelocity.x, rndVelocity.x),
Random.Range(-rndVelocity.y, rndVelocity.y),
Random.Range(-rndVelocity.z, rndVelocity.z)) +
go.transform.InverseTransformDirection(worldVelocity);
}
else
{
pos = go.transform.TransformPoint(pos);
vel = worldVelocity
+ go.transform.TransformDirection(
localVelocity
+ new Vector3(
Random.Range(-rndVelocity.x, rndVelocity.x),
Random.Range(-rndVelocity.y, rndVelocity.y),
Random.Range(-rndVelocity.z, rndVelocity.z)
)
);
}
float rotation = rndRotation ? Random.value * 360f : 0f;
float angularV = angularVelocity + Random.value * rndAngularVelocity;
emitParams.position = pos;
emitParams.velocity = vel;
emitParams.rotation = rotation;
emitParams.angularVelocity = angularV;
emitParams.startLifetime = Random.Range(minEnergy, maxEnergy);
emitParams.startColor = color;
emitParams.startSize = Random.Range(minSize, maxSize);
pe.Emit(emitParams, 1);
}
//-------------------------------------------------------------------------
/// <summary>
/// Rotates and scales inputVertices and writes the result to the
/// corresponding output array transformedVertices.
/// </summary>
/// <param name="inputVertices">Input vertices.</param>
/// <param name="transformedVertices">Transformed vertices. Has to be of the same size as inputVertices.</param>
void TransformReducedOutline(List<Vector2> inputVertices, Vector2[] transformedVertices) {
// Order of vertex transformation is:
// 1) rotated by initialRotationQuaternion around transformationCenter
// 2) scaled by mVertexScaleAfterInitialRotation
// 3) rotated by mVertexSecondRotationQuaternion around mVertexTransformationCenter
// 4) scaled by mVertexScaleAfterSecondRotation
// 3) translated by mVertexOffset
float scaleX = GetOutputScaleX(false);
float scaleY = GetOutputScaleY();
Vector3 scaleAfterInitialRotation = new Vector3(scaleX, scaleY, 1);
Vector3 scaleAfterSecondRotation = Vector3.one;
float atlasFrameRotation = mAtlasFrameRotation;
if (mRegionIndependentParameters.CustomTex != null) {
scaleAfterInitialRotation.Scale(GetCustomImageScale());
atlasFrameRotation = 0.0f;
}
// In order to rotate well, we need to compensate for the gameobject's
// transform.scale that is applied automatically after all of our transforms.
Vector3 automaticallyAppliedScale = this.transform.localScale;
Vector3 rotationCompensationScaleBefore = new Vector3(automaticallyAppliedScale.x, automaticallyAppliedScale.y, 1.0f);
Vector3 rotationCompensationScaleAfter = new Vector3(1.0f / automaticallyAppliedScale.x, 1.0f / automaticallyAppliedScale.y, 1.0f);
scaleAfterInitialRotation.Scale(rotationCompensationScaleBefore);
scaleAfterSecondRotation.Scale(rotationCompensationScaleAfter);
Vector3 offset = new Vector3(mOutlineOffset.x + mRegionIndependentParameters.CustomOffset.x,
mOutlineOffset.y + mRegionIndependentParameters.CustomOffset.y,
mOutlineOffset.z + mRegionIndependentParameters.CustomOffset.z);
Vector3 transformationCenter = new Vector3(0, 0, 0);
Quaternion initialRotationQuaternion = Quaternion.Euler(0, 0, atlasFrameRotation);
Quaternion secondRotationQuaternion = Quaternion.Euler(0, 0, mRegionIndependentParameters.CustomRotation);
for (int index = 0; index < inputVertices.Count; ++index) {
Vector3 inputVertex = new Vector3(inputVertices[index].x, inputVertices[index].y, 0);
Vector3 transformedVertex = inputVertex - transformationCenter;
// rotate initially
transformedVertex = initialRotationQuaternion * transformedVertex;
// scale
transformedVertex.Scale(scaleAfterInitialRotation);
// rotate a second time
transformedVertex = secondRotationQuaternion * transformedVertex;
// scale
transformedVertex.Scale(scaleAfterSecondRotation);
// translate
transformedVertex += offset;
transformedVertex += transformationCenter;
// apply zLeftHandedMultiplier
transformedVertices[index] = new Vector2(transformedVertex.x, transformedVertex.y);
}
}
private void Update()
{
if (!_lockedCursor && Input.GetMouseButtonDown(0))
{
_lockedCursor = true;
Cursor.lockState = CursorLockMode.Locked;
Cursor.visible = false;
}
else if (_lockedCursor && Input.GetKeyDown(KeyCode.Escape))
{
_lockedCursor = false;
Cursor.lockState = CursorLockMode.None;
Cursor.visible = true;
}
if (_lockedCursor)
{
var cursorDelta = new Vector2(Input.GetAxisRaw("Mouse X"), Input.GetAxisRaw("Mouse Y"));
Yaw += cursorDelta.x * CursorSensitivity.x;
Pitch -= cursorDelta.y * CursorSensitivity.y;
}
Camera.transform.rotation = Quaternion.AngleAxis(Yaw, Vector3.up)
* Quaternion.AngleAxis(Pitch, Vector3.right);
float distance;
Vector3 castFrom;
if (_player.IsInVehicle)
{
CarCameraDistance = Mathf.Clamp(CarCameraDistance - Input.mouseScrollDelta.y, 2.0f, 32.0f);
distance = CarCameraDistance;
castFrom = _player.CurrentVehicle.transform.position;
}
else
{
PlayerCameraDistance = Mathf.Clamp(PlayerCameraDistance - Input.mouseScrollDelta.y, 2.0f, 32.0f);
distance = PlayerCameraDistance;
castFrom = transform.position + Vector3.up * .5f;
}
var castRay = new Ray(castFrom, -Camera.transform.forward);
RaycastHit hitInfo;
if (Physics.SphereCast(castRay, 0.25f, out hitInfo, distance,
-1 ^ (1 << MapObject.BreakableLayer) ^ (1 << Vehicle.Layer)))
{
distance = hitInfo.distance;
}
Camera.transform.position = castRay.GetPoint(distance);
if (Input.GetButtonDown("Use") && _player.IsInVehicle)
{
_player.ExitVehicle();
return;
}
if (_player.IsInVehicle)
{
return;
}
if (!_lockedCursor)
{
return;
}
var inputMove = new Vector3(Input.GetAxis("Horizontal"), 0f, Input.GetAxis("Vertical"));
if (inputMove.sqrMagnitude > 0f)
{
inputMove.Normalize();
if (Input.GetKey(KeyCode.LeftShift))
{
PlayerModel.Running = true;
}
else
{
PlayerModel.Walking = true;
}
}
else
{
PlayerModel.Walking = false;
}
_player.Movement = Vector3.Scale(Camera.transform.TransformVector(inputMove),
new Vector3(1f, 0f, 1f)).normalized;
if (!Input.GetButtonDown("Use"))
{
return;
}
// find any vehicles that have a seat inside the checking radius and sort by closest seat
var vehicles = FindObjectsOfType <Vehicle>()
.Where(x => Vector3.Distance(transform.position, x.FindClosestSeatTransform(transform.position).position) < EnterVehicleRadius)
.OrderBy(x => Vector3.Distance(transform.position, x.FindClosestSeatTransform(transform.position).position)).ToArray();
foreach (var vehicle in vehicles)
{
var seat = vehicle.FindClosestSeat(transform.position);
_player.EnterVehicle(vehicle, seat);
break;
}
}
void SetupMesh(LetterAction letter_action, LetterAction prev_action, float action_progress, AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, float linear_progress, EffectManager effect_manager)
{
// construct current anchor offset vector
m_anchor_offset = letter_action.AnchorOffsetStart;
m_anchor_offset = new Vector3(m_anchor_offset.x * m_width,
letter_action.m_letter_anchor_start == (int)TextfxTextAnchor.BaselineLeft || letter_action.m_letter_anchor_start == (int)TextfxTextAnchor.BaselineCenter || letter_action.m_letter_anchor_start == (int)TextfxTextAnchor.BaselineRight
? 0 // zero because letters are based around the baseline already.
: (effect_manager.IsFontBaseLineSet
? (effect_manager.FontBaseLine + m_y_offset) - (m_anchor_offset.y * -m_height)
: (m_anchor_offset.y * m_height)), // Legacy effect support when baseline isn't already set.
0);
if (letter_action.m_letter_anchor_2_way)
{
m_anchor_offset = letter_action.AnchorOffsetEnd;
m_anchor_offset = Vector3.Lerp(m_anchor_offset,
new Vector3(
m_anchor_offset.x * m_width,
letter_action.m_letter_anchor_end == (int)TextfxTextAnchor.BaselineLeft || letter_action.m_letter_anchor_end == (int)TextfxTextAnchor.BaselineCenter || letter_action.m_letter_anchor_end == (int)TextfxTextAnchor.BaselineRight
? 0 // zero because letters are based around the baseline already.
: (effect_manager.IsFontBaseLineSet
? (effect_manager.FontBaseLine + m_y_offset) - (m_anchor_offset.y * -m_height)
: (m_anchor_offset.y * m_height)), // Legacy effect support when baseline isn't already set.
0),
action_progress);
}
// Calculate Scale Vector
from_vec = letter_action.m_start_scale.GetValue(progression_variables, animate_per);
to_vec = letter_action.m_end_scale.GetValue(progression_variables, animate_per);
if (letter_action.m_scale_axis_ease_data.m_override_default)
{
m_letter_scale = new Vector3(EffectManager.FloatLerp(from_vec.x, to_vec.x, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_x_ease, linear_progress)),
EffectManager.FloatLerp(from_vec.y, to_vec.y, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_y_ease, linear_progress)),
EffectManager.FloatLerp(from_vec.z, to_vec.z, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_z_ease, linear_progress)));
}
else
{
m_letter_scale = EffectManager.Vector3Lerp(
from_vec,
to_vec,
action_progress);
}
// Calculate Rotation
from_vec = letter_action.m_start_euler_rotation.GetValue(progression_variables, animate_per);
to_vec = letter_action.m_end_euler_rotation.GetValue(progression_variables, animate_per);
if (letter_action.m_rotation_axis_ease_data.m_override_default)
{
m_letter_rotation = Quaternion.Euler
(
EffectManager.FloatLerp(from_vec.x, to_vec.x, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_x_ease, linear_progress)),
EffectManager.FloatLerp(from_vec.y, to_vec.y, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_y_ease, linear_progress)),
EffectManager.FloatLerp(from_vec.z, to_vec.z, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_z_ease, linear_progress))
);
}
else
{
m_letter_rotation = Quaternion.Euler(
EffectManager.Vector3Lerp(
from_vec,
to_vec,
action_progress)
);
}
// Calculate Position
if (letter_action.m_start_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX || (letter_action.m_offset_from_last && prev_action != null && prev_action.m_end_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX))
{
from_vec = new Vector3(-m_anchor_offset.x, m_base_offset.y, 0);
}
else if (letter_action.m_start_pos.ForcePositionOverride)
{
from_vec = new Vector3(-m_anchor_offset.x, 0, 0);
}
else
{
from_vec = BaseOffset;
}
from_vec += letter_action.m_start_pos.GetValue(progression_variables, animate_per);
if (letter_action.m_end_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX || (letter_action.m_end_pos.IsOffsetFromLast && letter_action.m_start_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX))
{
to_vec = new Vector3(-m_anchor_offset.x, m_base_offset.y, 0);
}
else if (letter_action.m_end_pos.ForcePositionOverride)
{
to_vec = new Vector3(-m_anchor_offset.x, 0, 0);
}
else
{
to_vec = BaseOffset;
}
to_vec += letter_action.m_end_pos.GetValue(progression_variables, animate_per);
if (letter_action.m_position_axis_ease_data.m_override_default)
{
m_letter_position = new Vector3(EffectManager.FloatLerp(from_vec.x, to_vec.x, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_x_ease, linear_progress)),
EffectManager.FloatLerp(from_vec.y, to_vec.y, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_y_ease, linear_progress)),
EffectManager.FloatLerp(from_vec.z, to_vec.z, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_z_ease, linear_progress)));
}
else
{
m_letter_position = EffectManager.Vector3Lerp(
from_vec,
to_vec,
action_progress);
}
// Calculate letter center position
m_letter_center = new Vector3(m_width / 2, m_height / 2, 0);
m_letter_center -= m_anchor_offset;
m_letter_center = Vector3.Scale(m_letter_center, m_letter_scale);
m_letter_center = m_letter_rotation * m_letter_center;
m_letter_center += m_anchor_offset + m_letter_position;
if (mesh_verts == null || mesh_verts.Length == 0)
{
mesh_verts = new Vector3[4];
}
for (int idx = 0; idx < 4; idx++)
{
mesh_verts[idx] = m_base_vertices[idx];
// normalise vert position to the anchor point before scaling and rotating.
mesh_verts[idx] -= m_anchor_offset;
// Scale verts
mesh_verts[idx] = Vector3.Scale(mesh_verts[idx], m_letter_scale);
// Rotate vert
mesh_verts[idx] = m_letter_rotation * mesh_verts[idx];
mesh_verts[idx] += m_anchor_offset;
// translate vert
mesh_verts[idx] += m_letter_position;
}
m_mesh.vertices = mesh_verts;
// Sort out letters colour
if (letter_action.m_use_gradient_start)
{
start_colour = letter_action.m_start_vertex_colour.GetValue(progression_variables, animate_per);
}
else
{
start_colour = new VertexColour(letter_action.m_start_colour.GetValue(progression_variables, animate_per));
}
if (letter_action.m_use_gradient_end)
{
end_colour = letter_action.m_end_vertex_colour.GetValue(progression_variables, animate_per);
}
else
{
end_colour = new VertexColour(letter_action.m_end_colour.GetValue(progression_variables, animate_per));
}
if (!m_flipped)
{
m_mesh.colors = new Color[] {
Color.Lerp(start_colour.top_right, end_colour.top_right, action_progress),
Color.Lerp(start_colour.top_left, end_colour.top_left, action_progress),
Color.Lerp(start_colour.bottom_left, end_colour.bottom_left, action_progress),
Color.Lerp(start_colour.bottom_right, end_colour.bottom_right, action_progress)
};
}
else
{
m_mesh.colors = new Color[] {
Color.Lerp(start_colour.top_left, end_colour.top_left, action_progress),
Color.Lerp(start_colour.bottom_left, end_colour.bottom_left, action_progress),
Color.Lerp(start_colour.bottom_right, end_colour.bottom_right, action_progress),
Color.Lerp(start_colour.top_right, end_colour.top_right, action_progress)
};
}
}
public static Vector3 GetLocalFace( Vector3 halfExtents, Direction dir )
{
return Vector3.Scale( halfExtents, GetLocalFaceDirection( dir ) );
}
public void BuildMode()
{
if (buildMode)
{
if (currentBuildAsset == null)
{
if (inventory[inventoryCurrentIndex].amount > 0)
{
currentBuildAsset = Instantiate(C.c.data.assetPrefab);
currentBuildAsset.Set(inventory[inventoryCurrentIndex].asset, "", true);
buildPlacementValid = false;
currentBuildAsset.model.GetComponent <MeshRenderer>().material = C.c.data.placingMats[1];
currentBuildCollider = currentBuildAsset.model.AddComponent <BoxCollider>();
currentBuildCollider.isTrigger = true;
}
}
if (currentBuildAsset)
{
RaycastHit hit;
if (Physics.Raycast(cam.transform.position + cam.transform.forward, cam.transform.forward, out hit, 10f))
{
var placementValid = buildPlacementValid;
if (Mathf.Abs(hit.normal.x) < .2f && Mathf.Abs(hit.normal.y) > .9f && Mathf.Abs(hit.normal.z) < .2f)
{
placementValid = true;
}
RaycastHit[] hits;
hits = Physics.BoxCastAll(currentBuildCollider.bounds.center, Vector3.Scale(currentBuildCollider.size, currentBuildAsset.model.transform.localScale) * .48f, Vector3.up, currentBuildAsset.transform.rotation, .01f);
foreach (RaycastHit h in hits)
{
if (h.transform != currentBuildAsset.model.transform && h.transform != transform)
{
placementValid = false;
}
}
if (placementValid)
{
if (!buildPlacementValid)
{
currentBuildAsset.model.GetComponent <MeshRenderer>().material = C.c.data.placingMats[0];
}
buildPlacementValid = true;
}
else
{
if (buildPlacementValid)
{
currentBuildAsset.model.GetComponent <MeshRenderer>().material = C.c.data.placingMats[1];
}
buildPlacementValid = false;
}
var ydiff = currentBuildAsset.transform.position.y - (currentBuildCollider.bounds.center.y - currentBuildCollider.bounds.extents.y);
if (currentBuildAsset.physicsAsset)
{
currentBuildAsset.transform.position = hit.point + Vector3.up * +(ydiff + .05f);
}
else
{
currentBuildAsset.transform.position = hit.point + Vector3.up * ydiff;
}
if (InputManager.RotatePlacement(playerId) != 0)
{
currentBuildAsset.transform.Rotate(0, .7f * InputManager.RotatePlacement(playerId), 0);
if (Input.GetKey(KeyCode.LeftShift))
{
currentBuildAsset.transform.Rotate(0, .7f * InputManager.RotatePlacement(playerId), 0);
}
}
if ((InputManager.PlaceAsset(playerId) || InputManager.JumpInput(playerId)) && buildPlacementValid)
{
currentBuildAsset.placing = false;
currentBuildAsset.Set(currentBuildAsset.data);
if (InputManager.AutoSellWhilePlacing(playerId))
{
currentBuildAsset.ToggleSelling();
}
currentBuildAsset = null;
inventory[inventoryCurrentIndex].amount--;
pui.invRender.UpdateInventoryRender();
C.c.currentShop.UpdateShop();
}
}
}
}
//Start / stop Build Mode
if (InputManager.BuildModeInput(playerId) || (buildMode && InputManager.Cancel(playerId)))
{
buildMode = !buildMode;
pui.modeStatusText.transform.parent.gameObject.SetActive(buildMode);
if (!buildMode)
{
if (currentBuildAsset)
{
Destroy(currentBuildAsset.gameObject);
}
}
}
}
public void Drag()
{
if (!this.mPressed || UICamera.currentScheme == UICamera.ControlScheme.Controller)
{
return;
}
if (base.enabled && NGUITools.GetActive(base.gameObject) && this.mShouldMove)
{
if (this.mDragID == -10)
{
this.mDragID = UICamera.currentTouchID;
}
UICamera.currentTouch.clickNotification = UICamera.ClickNotification.BasedOnDelta;
if (this.smoothDragStart && !this.mDragStarted)
{
this.mDragStarted = true;
this.mDragStartOffset = UICamera.currentTouch.totalDelta;
if (this.onDragStarted != null)
{
this.onDragStarted();
}
}
Ray ray = (!this.smoothDragStart) ? UICamera.currentCamera.ScreenPointToRay(UICamera.currentTouch.pos) : UICamera.currentCamera.ScreenPointToRay(UICamera.currentTouch.pos - this.mDragStartOffset);
float distance = 0f;
if (this.mPlane.Raycast(ray, out distance))
{
Vector3 point = ray.GetPoint(distance);
Vector3 vector = point - this.mLastPos;
this.mLastPos = point;
if (vector.x != 0f || vector.y != 0f || vector.z != 0f)
{
vector = this.mTrans.InverseTransformDirection(vector);
if (this.movement == UIScrollView.Movement.Horizontal)
{
vector.y = 0f;
vector.z = 0f;
}
else if (this.movement == UIScrollView.Movement.Vertical)
{
vector.x = 0f;
vector.z = 0f;
}
else if (this.movement == UIScrollView.Movement.Unrestricted)
{
vector.z = 0f;
}
else
{
vector.Scale(this.customMovement);
}
vector = this.mTrans.TransformDirection(vector);
}
if (this.dragEffect == UIScrollView.DragEffect.None)
{
this.mMomentum = Vector3.zero;
}
else
{
this.mMomentum = Vector3.Lerp(this.mMomentum, this.mMomentum + vector * (0.01f * this.momentumAmount), 0.67f);
}
if (!this.iOSDragEmulation || this.dragEffect != UIScrollView.DragEffect.MomentumAndSpring)
{
this.MoveAbsolute(vector);
}
else
{
Vector3 vector2 = this.mPanel.CalculateConstrainOffset(this.bounds.min, this.bounds.max);
if (this.movement == UIScrollView.Movement.Horizontal)
{
vector2.y = 0f;
}
else if (this.movement == UIScrollView.Movement.Vertical)
{
vector2.x = 0f;
}
else if (this.movement == UIScrollView.Movement.Custom)
{
vector2.x *= this.customMovement.x;
vector2.y *= this.customMovement.y;
}
if (vector2.magnitude > 1f)
{
this.MoveAbsolute(vector * 0.5f);
this.mMomentum *= 0.5f;
}
else
{
this.MoveAbsolute(vector);
}
}
if (this.constrainOnDrag && this.restrictWithinPanel && this.mPanel.clipping != UIDrawCall.Clipping.None && this.dragEffect != UIScrollView.DragEffect.MomentumAndSpring)
{
this.RestrictWithinBounds(true, this.canMoveHorizontally, this.canMoveVertically);
}
}
}
}
public override void PlaySkill(int skillNum, int option)
{
Transform trns = PlayerController.Instance.transform;
Rigidbody2D rb2D = PlayerController.Instance.GetComponent <Rigidbody2D>();
switch (skillNum)
{
case 0:
EffectPool.Instance.StartEffect(GameManager.Instance.effectAnim["BWSpear00"], trns.position + Vector3.Scale(new Vector3(2.5f, 1, 0), trns.localScale), trns.localScale);
if (PlayerController.Instance.controller.m_Grounded)
{
rb2D.velocity = new Vector2(0, 0);
}
else
{
rb2D.velocity = new Vector2(0, 0);
rb2D.gravityScale = 0;
}
break;
case 1:
EffectPool.Instance.StartEffect(GameManager.Instance.effectAnim["BWSpear01"], trns.position + Vector3.Scale(new Vector3(2.5f, 1, 0), trns.localScale), trns.localScale);
if (PlayerController.Instance.controller.m_Grounded)
{
rb2D.velocity = new Vector2(0, 0);
}
else
{
rb2D.velocity = new Vector2(0, 0);
rb2D.gravityScale = 0;
}
break;
}
}
public Vector3 GetSpawnOffset(Vector3 local_bounds_extents) => SpawnOffset.IsZero() ? SpawnOffset : Vector3.Scale(local_bounds_extents, SpawnOffset);
void LegacySetParticle()
{
ParticleEmitter pe = m_pe;
ParticleAnimator pa = m_pa;
ParticleRenderer pr = m_pr;
if (pe == null || pr == null)
{
return;
}
if (m_bLegacyRuntimeScale)
{
Vector3 vecVelScale = Vector3.one * m_fStartSpeedRate;
float fVelScale = m_fStartSpeedRate;
pe.minSize *= m_fStartSizeRate;
pe.maxSize *= m_fStartSizeRate;
pe.minEnergy *= m_fStartLifeTimeRate;
pe.maxEnergy *= m_fStartLifeTimeRate;
pe.minEmission *= m_fStartEmissionRate;
pe.maxEmission *= m_fStartEmissionRate;
pe.worldVelocity = Vector3.Scale(pe.worldVelocity, vecVelScale);
pe.localVelocity = Vector3.Scale(pe.localVelocity, vecVelScale);
pe.rndVelocity = Vector3.Scale(pe.rndVelocity, vecVelScale);
pe.angularVelocity *= fVelScale;
pe.rndAngularVelocity *= fVelScale;
pe.emitterVelocityScale *= fVelScale;
// NgAssembly.LogFieldsPropertis(pe);
if (pa != null)
{
pa.rndForce = Vector3.Scale(pa.rndForce, vecVelScale);
pa.force = Vector3.Scale(pa.force, vecVelScale);
// pa.damping *= fScale;
}
// pr.velocityScale *= fVelScale;
pr.lengthScale *= m_fRenderLengthRate;
}
else
{
Vector3 vecVelScale = (m_bScaleWithTransform ? pe.transform.lossyScale : Vector3.one) * m_fStartSpeedRate;
float fVelScale = (m_bScaleWithTransform ? NcTransformTool.GetTransformScaleMeanValue(pe.transform) : 1) * m_fStartSpeedRate;
float fScale = (m_bScaleWithTransform ? NcTransformTool.GetTransformScaleMeanValue(pe.transform) : 1) * m_fStartSizeRate;
pe.minSize *= fScale;
pe.maxSize *= fScale;
pe.minEnergy *= m_fStartLifeTimeRate;
pe.maxEnergy *= m_fStartLifeTimeRate;
pe.minEmission *= m_fStartEmissionRate;
pe.maxEmission *= m_fStartEmissionRate;
pe.worldVelocity = Vector3.Scale(pe.worldVelocity, vecVelScale);
pe.localVelocity = Vector3.Scale(pe.localVelocity, vecVelScale);
pe.rndVelocity = Vector3.Scale(pe.rndVelocity, vecVelScale);
pe.angularVelocity *= fVelScale;
pe.rndAngularVelocity *= fVelScale;
pe.emitterVelocityScale *= fVelScale;
// NgAssembly.LogFieldsPropertis(pe);
if (pa != null)
{
pa.rndForce = Vector3.Scale(pa.rndForce, vecVelScale);
pa.force = Vector3.Scale(pa.force, vecVelScale);
// pa.damping *= fScale;
}
// pr.velocityScale *= fVelScale;
pr.lengthScale *= m_fRenderLengthRate;
}
}
void Update()
{
float delta = Time.deltaTime;
bool shift = Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift);
float a = hitbox.color.a;
const float hitboxFadeSpeed = 4F;
if (shift && allowInput)
{
a = Mathf.Min(1, a + hitboxFadeSpeed * delta);
}
else
{
a = Mathf.Max(0, a - hitboxFadeSpeed * delta);
}
if (!allowInput)
{
return;
}
if (iframes > 0)
{
iframes -= delta;
if (iframes < 0)
{
gameObject.layer = 10; // Player
sprite.color = new Color32(255, 255, 255, 255);
}
}
float motionX = 0, motionY = 0;
float speed = (shift ? moveSpeedShift : moveSpeed) * delta;
if (Input.GetKey(KeyCode.UpArrow))
{
motionY += 1;
}
if (Input.GetKey(KeyCode.DownArrow))
{
motionY -= 1;
}
if (Input.GetKey(KeyCode.RightArrow))
{
motionX += 1;
}
if (Input.GetKey(KeyCode.LeftArrow))
{
motionX -= 1;
}
Vector3 motion = new Vector3(motionX, motionY, 0);
motion.Normalize();
motion.Scale(new Vector3(speed, speed, 0));
transform.position += motion;
ClampPosition();
hitbox.color = new Color(1F, 1F, 1F, a);
}
protected virtual void Update()
{
if (useProfileHeight)
{
if (InitialPose == null)
{
InitialPose = new OVRPose()
{
position = CameraController.transform.localPosition,
orientation = CameraController.transform.localRotation
};
}
var p = CameraController.transform.localPosition;
p.y = OVRManager.profile.eyeHeight - 0.5f * Controller.height;
p.z = OVRManager.profile.eyeDepth;
CameraController.transform.localPosition = p;
}
else if (InitialPose != null)
{
CameraController.transform.localPosition = InitialPose.Value.position;
CameraController.transform.localRotation = InitialPose.Value.orientation;
InitialPose = null;
}
UpdateMovement();
Vector3 moveDirection = Vector3.zero;
float motorDamp = (1.0f + (Damping * SimulationRate * Time.deltaTime));
MoveThrottle.x /= motorDamp;
MoveThrottle.y = (MoveThrottle.y > 0.0f) ? (MoveThrottle.y / motorDamp) : MoveThrottle.y;
MoveThrottle.z /= motorDamp;
moveDirection += MoveThrottle * SimulationRate * Time.deltaTime;
// Gravity
if (Controller.isGrounded && FallSpeed <= 0)
{
FallSpeed = ((Physics.gravity.y * (GravityModifier * 0.002f)));
}
else
{
FallSpeed += ((Physics.gravity.y * (GravityModifier * 0.002f)) * SimulationRate * Time.deltaTime);
}
moveDirection.y += FallSpeed * SimulationRate * Time.deltaTime;
// Offset correction for uneven ground
float bumpUpOffset = 0.0f;
if (Controller.isGrounded && MoveThrottle.y <= 0.001f)
{
bumpUpOffset = Mathf.Max(Controller.stepOffset, new Vector3(moveDirection.x, 0, moveDirection.z).magnitude);
moveDirection -= bumpUpOffset * Vector3.up;
}
Vector3 predictedXZ = Vector3.Scale((Controller.transform.localPosition + moveDirection), new Vector3(1, 0, 1));
// Move contoller
Controller.Move(moveDirection);
Vector3 actualXZ = Vector3.Scale(Controller.transform.localPosition, new Vector3(1, 0, 1));
if (predictedXZ != actualXZ)
{
MoveThrottle += (actualXZ - predictedXZ) / (SimulationRate * Time.deltaTime);
}
}
public override void ToMesh()
{
int axisDivisions = m_subdivisions;
Mesh m = new Mesh();
m.name = "Cone";
float radius = .5f;
axisDivisions++;
Vector3[] circle = new Vector3[axisDivisions];
for (int i = 0; i < axisDivisions - 1; i++)
{
float theta = ((360f / (axisDivisions - 1)) * i) * Mathf.Deg2Rad;
float x = Mathf.Cos(theta) * radius;
float z = Mathf.Sin(theta) * radius;
circle[i] = new Vector3(x, -.5f, z);
}
circle[axisDivisions - 1] = circle[0];
int vertexCount = (axisDivisions * 2) + 2;
// verts
Vector3[] v = new Vector3[vertexCount];
// Vector3[] nrm = new Vector3[vertexCount];
for (int i = 0; i < axisDivisions; i++)
{
v[i] = circle[i]; // bottom for sides
v[i + axisDivisions] = circle[i]; // bottom for -v.up
}
// circle point
v[vertexCount - 2] = Vector3.up * -.5f;
// cone point
v[vertexCount - 1] = Vector3.up * .5f;
int[] tris = new int[(axisDivisions * 3) * 2];
int n = 0;
int step = axisDivisions * 3;
for (int i = 0; i < axisDivisions - 1; i++)
{
// cone sides
tris[n + 0] = i;
tris[n + 1] = vertexCount - 1;
tris[n + 2] = i + 1;
// // bottom circle
tris[n + step + 0] = i + axisDivisions + 1;
tris[n + step + 1] = vertexCount - 2;
tris[n + step + 2] = i + axisDivisions;
n += 3;
}
//reassign scale
LocalScale.x = Mathf.Abs(LocalScale.x);
LocalScale.y = Mathf.Abs(LocalScale.y);
LocalScale.z = Mathf.Abs(LocalScale.z);
for (int i = 0; i < v.Length; i++)
{
v[i] = Vector3.Scale(v[i], LocalScale);
}
m.vertices = v;
m.triangles = tris;
m.uv = new Vector2[m.vertices.Length];
GetComponent <MeshFilter>().sharedMesh = m;
if (GetComponent <MeshRenderer>().sharedMaterial == null)
{
GetComponent <MeshRenderer>().sharedMaterial = DefaultDiffuse;
}
m.RecalculateNormals();
}
public Vector3 AbsoluteFromRelative(Vector3 p)
{
Vector3 size = bottomRight.transform.position - topLeft.transform.position;
return(bottomRight.transform.position + Vector3.Scale(size, p));
}
void Start()
{
dir = new Vector3(Random.Range(0.0f, 360.0f), Random.Range(0.0f, 360.0f), Random.Range(0.0f, 360.0f)).normalized;
dir.Scale(axis);
dir += baseDir;
}
private void OnDrawGizmos()
{
Gizmos.DrawWireCube(this.transform.position, Vector3.Scale(new Vector3(0.64f, 0.64f, 0.0f), new Vector3(m_Width, 1.0f, 1.0f)));
}
/// <summary>
/// Initialize variables, callbacks and check null references.
/// </summary>
void Start()
{
_controllerConnectionHandler = GetComponent <ControllerConnectionHandler>();
if (!_controllerConnectionHandler.enabled)
{
Debug.LogError("Error ControllerVisualizer starting MLInput, disabling script.");
enabled = false;
return;
}
if (!_controllerModel)
{
Debug.LogError("Error ControllerVisualizer._controllerModel not set, disabling script.");
enabled = false;
return;
}
if (!_trigger)
{
Debug.LogError("Error ControllerVisualizer._trigger not set, disabling script.");
enabled = false;
return;
}
if (!_touchpad)
{
Debug.LogError("Error ControllerVisualizer._touchpad not set, disabling script.");
enabled = false;
return;
}
if (!_homeButton)
{
Debug.LogError("Error ControllerVisualizer._homeButton not set, disabling script.");
enabled = false;
return;
}
if (!_bumperButton)
{
Debug.LogError("Error ControllerVisualizer._bumperButton not set, disabling script.");
enabled = false;
return;
}
if (!_touchIndicatorTransform)
{
Debug.LogError("Error ControllerVisualizer._touchIndicatorTransform not set, disabling script.");
enabled = false;
return;
}
SetVisibility(_controllerConnectionHandler.IsControllerValid());
MLInput.OnControllerButtonUp += HandleOnButtonUp;
MLInput.OnControllerButtonDown += HandleOnButtonDown;
_triggerMaterial = FindMaterial(_trigger);
_touchpadMaterial = FindMaterial(_touchpad);
_homeButtonMaterial = FindMaterial(_homeButton);
_bumperButtonMaterial = FindMaterial(_bumperButton);
// Calculate the radius of the touchpad's mesh
Mesh mesh = _touchpad.GetComponent <MeshFilter>().mesh;
_touchpadRadius = Vector3.Scale(mesh.bounds.extents, _touchpad.transform.lossyScale).x;
//MARK'S CODE:
StepTracker.instance.controller = controllerCollider;
}
protected Vector3 GetPalmCenter()
{
Vector3 offset = PALM_CENTER_OFFSET * Vector3.Scale(GetPalmDirection(), transform.localScale);
return(GetPalmPosition() - offset);
}
protected virtual void Update()
{
if (useProfileData)
{
if (InitialPose == null)
{
// Save the initial pose so it can be recovered if useProfileData
// is turned off later.
InitialPose = new OVRPose()
{
position = CameraRig.transform.localPosition,
orientation = CameraRig.transform.localRotation
};
}
var p = CameraRig.transform.localPosition;
if (OVRManager.instance.trackingOriginType == OVRManager.TrackingOrigin.EyeLevel)
{
p.y = OVRManager.profile.eyeHeight - (0.5f * Controller.height) + Controller.center.y;
}
else if (OVRManager.instance.trackingOriginType == OVRManager.TrackingOrigin.FloorLevel)
{
p.y = -(0.5f * Controller.height) + Controller.center.y;
}
CameraRig.transform.localPosition = p;
}
else if (InitialPose != null)
{
// Return to the initial pose if useProfileData was turned off at runtime
CameraRig.transform.localPosition = InitialPose.Value.position;
CameraRig.transform.localRotation = InitialPose.Value.orientation;
InitialPose = null;
}
UpdateMovement();
Vector3 moveDirection = Vector3.zero;
float motorDamp = (1.0f + (Damping * SimulationRate * Time.deltaTime));
MoveThrottle.x /= motorDamp;
MoveThrottle.y = (MoveThrottle.y > 0.0f) ? (MoveThrottle.y / motorDamp) : MoveThrottle.y;
MoveThrottle.z /= motorDamp;
moveDirection += MoveThrottle * SimulationRate * Time.deltaTime;
// Gravity
if (Controller.isGrounded && FallSpeed <= 0)
{
FallSpeed = ((Physics.gravity.y * (GravityModifier * 0.002f)));
}
else
{
FallSpeed += ((Physics.gravity.y * (GravityModifier * 0.002f)) * SimulationRate * Time.deltaTime);
}
moveDirection.y += FallSpeed * SimulationRate * Time.deltaTime;
// Offset correction for uneven ground
float bumpUpOffset = 0.0f;
if (Controller.isGrounded && MoveThrottle.y <= transform.lossyScale.y * 0.001f)
{
bumpUpOffset = Mathf.Max(Controller.stepOffset, new Vector3(moveDirection.x, 0, moveDirection.z).magnitude);
moveDirection -= bumpUpOffset * Vector3.up;
}
Vector3 predictedXZ = Vector3.Scale((Controller.transform.localPosition + moveDirection), new Vector3(1, 0, 1));
// Move contoller
Controller.Move(moveDirection);
Vector3 actualXZ = Vector3.Scale(Controller.transform.localPosition, new Vector3(1, 0, 1));
if (predictedXZ != actualXZ)
{
MoveThrottle += (actualXZ - predictedXZ) / (SimulationRate * Time.deltaTime);
}
}
// Use this for initialization
void Start()
{
if (Application.isPlaying && uiAnimation != null)
{
return;
}
rect = GetComponent <RectTransform>();
List <UIAnimation> animations = new List <UIAnimation>();
if (moveAnimation)
{
UpdateBehaviour mod = EasyUIAnimatorUtils.GetModifier(moveModifier);
Effect.EffectUpdate eff = EasyUIAnimatorUtils.GetEffect(moveEffect, max[0], bounce[0]);
effectRotation = (randomDirection) ? Vector3.forward * Random.Range(0, 360) : effectRotation;
if (useScreenValues)
{
uiAnimation = UIAnimator.Move(rect, Vector3.Scale(start[0], (Vector3)UIAnimator.InvertedScreenDimension), Vector3.Scale(final[0], (Vector3)UIAnimator.InvertedScreenDimension), duration).SetDelay(delay).SetModifier(mod).SetEffect(eff, Quaternion.Euler(effectRotation));
}
else
{
animations.Add(UIAnimator.Move(rect, start[0], final[0], duration).SetModifier(mod).SetEffect(eff, Quaternion.Euler(effectRotation)));
}
}
if (scaleAnimation)
{
UpdateBehaviour mod = EasyUIAnimatorUtils.GetModifier(scaleModifier);
Effect.EffectUpdate eff = EasyUIAnimatorUtils.GetEffect(scaleEffect, max[1], bounce[1]);
animations.Add(UIAnimator.Scale(rect, start[1], final[1], duration).SetModifier(mod).SetEffect(eff));
}
if (rotationAnimation)
{
UpdateBehaviour mod = EasyUIAnimatorUtils.GetModifier(rotationModifier);
Effect.EffectUpdate eff = EasyUIAnimatorUtils.GetEffect(rotationEffect, max[2], bounce[2]);
if (start[2].x != 0 || start[2].y != 0 || final[2].x != 0 || final[2].y != 0)
{
animations.Add(UIAnimator.Rotate(rect, Quaternion.Euler(start[2]), Quaternion.Euler(final[2]), duration).SetModifier(mod).SetEffect(eff));
}
else
{
animations.Add(UIAnimator.Rotate(rect, start[2].z, final[2].z, duration).SetModifier(mod).SetEffect(eff));
}
}
if (graphicAnimation)
{
UpdateBehaviour mod = EasyUIAnimatorUtils.GetModifier(graphicModifier);
image = GetComponent <Graphic>();
if (!image)
{
Debug.LogError("Please attach an Image/Text component to the gameObject");
}
else
{
animations.Add(UIAnimator.ChangeColor(image, startColor, finalColor, duration).SetDelay(delay).SetModifier(mod));
}
}
if (animations.Count == 0)
{
Debug.Log("No animation");
return;
}
else
{
uiAnimation = new UIGroupAnimation(animations.ToArray()).SetDelay(delay);
}
switch (loop)
{
case Loop.LOOP:
uiAnimation.SetLoop();
break;
case Loop.PING_PONG:
uiAnimation.SetLoop(true);
break;
}
if (disableAfter)
{
uiAnimation.SetCallback(() => { gameObject.SetActive(false); });
}
if (Application.isPlaying)
{
if (playOnStart)
{
Play();
}
}
}
private void UpdateHandles(Foliage2D_Path path2D, GUIStyle iconStyle)
{
Quaternion inv = Quaternion.Inverse(path2D.transform.rotation);
Handles.color = new Color(1, 1, 1, 0);
Vector3 global, tGlobal = Vector3.zero;
handleSelected = false;
for (int i = 0; i < path2D.handlesPosition.Count; i++)
{
// global position of a path point
Vector3 pos = path2D.transform.position + Vector3.Scale(new Vector3(path2D.handlesPosition[i].x, path2D.handlesPosition[i].y, 0), path2D.transform.localScale);
Vector3 tPos = path2D.transform.position + Vector3.Scale(new Vector3(path2D.handleControlsPos[i].x, path2D.handleControlsPos[i].y, 0), path2D.transform.localScale);
bool isSelected = selectedPoints.Contains(i);
if (!handleSelected)
{
handleSelected = selectedPoints.Contains(i);
}
Texture2D tex = null;
tex = isSelected ? texDotSelected : texDot;
if (IsVisible(pos))
{
SetScale(pos, tex, ref iconStyle);
Handles.Label(pos, new GUIContent(tex), iconStyle);
}
if (!path2D.uniformValues && path2D.foliagePathType == Foliage2D_PathType.Smooth && IsVisible(tPos) && selectedPoints.Contains(i))
{
SetScale(tPos, texBlueDot, ref iconStyle);
Handles.Label(tPos, new GUIContent(texBlueDot), iconStyle);
}
global = Handles.FreeMoveHandle(pos, Quaternion.identity, HandleScale(pos), Vector3.zero, Handles.CircleHandleCap);
if (!path2D.uniformValues && path2D.foliagePathType == Foliage2D_PathType.Smooth)
{
tGlobal = Handles.FreeMoveHandle(tPos, Quaternion.identity, HandleScale(tPos), Vector3.zero, Handles.CircleHandleCap);
}
if (global != pos)
{
selectedPoints.Clear();
selectedPoints.Add(i);
isSelected = true;
Vector3 local = inv * (global - path2D.transform.position);
Vector2 relative = new Vector2(
local.x / path2D.transform.localScale.x,
local.y / path2D.transform.localScale.y) - path2D.handlesPosition[i];
path2D.handlesPosition[selectedPoints[0]] += relative;
path2D.handleControlsPos[selectedPoints[0]] += relative;
index = i;
}
if (tGlobal != tPos && !path2D.uniformValues && path2D.foliagePathType == Foliage2D_PathType.Smooth)
{
Vector3 local = inv * (tGlobal - path2D.transform.position);
Vector2 relative = new Vector2(
local.x / path2D.transform.localScale.x,
local.y / path2D.transform.localScale.y) - path2D.handleControlsPos[i];
path2D.handleControlsPos[selectedPoints[0]] += relative;
path2D.nodeTension[i] = -Vector2.Distance(path2D.handleControlsPos[i], path2D.handlesPosition[i]) + 2f;
Vector2 line = path2D.handleControlsPos[i] - path2D.handlesPosition[i];
float angleInDeg = Mathf.Atan2(line.y, line.x) * Mathf.Rad2Deg;
if (angleInDeg > 0)
{
path2D.nodeBias[i] = -4 * angleInDeg / 180f;
}
else
{
path2D.nodeBias[i] = -4 * angleInDeg / 180f;
}
}
// make sure we can add new point at the midpoints!
if (i + 1 < path2D.handlesPosition.Count)
{
int index = i + 1;
Vector3 pos2 = path2D.transform.position + path2D.transform.rotation * Vector3.Scale(new Vector3(path2D.handlesPosition[index].x, path2D.handlesPosition[index].y, 0), path2D.transform.localScale);
Vector3 mid = (pos + pos2) / 2;
float handleScale = HandleScale(mid);
if (Handles.Button(mid, SceneView.lastActiveSceneView.camera.transform.rotation, handleScale, handleScale, Handles.CircleHandleCap))
{
Vector2 pt = inv * new Vector2((mid.x - path2D.transform.position.x) / path2D.transform.localScale.x, (mid.y - path2D.transform.position.y) / path2D.transform.localScale.y);
path2D.handlesPosition.Insert(index, pt);
path2D.handleControlsPos.Insert(index, new Vector2(pt.x + 2f, pt.y));
path2D.nodeTension.Insert(index, 0f);
path2D.nodeBias.Insert(index, 0f);
}
if (IsVisible(mid))
{
SetScale(mid, texDotPlus, ref iconStyle);
Handles.Label(mid, new GUIContent(texDotPlus), iconStyle);
}
}
// check if we want to remove points
if (Event.current.alt && path2D.handlesPosition.Count > 2)
{
float handleScale = HandleScale(pos);
if (IsVisible(pos))
{
SetScale(pos, texMinus, ref iconStyle);
Handles.Label(pos, new GUIContent(texMinus), iconStyle);
}
if (Handles.Button(pos, SceneView.lastActiveSceneView.camera.transform.rotation, handleScale, handleScale, Handles.CircleHandleCap))
{
if (!isSelected)
{
selectedPoints.Clear();
selectedPoints.Add(i);
}
for (int s = 0; s < selectedPoints.Count; s++)
{
path2D.handlesPosition.RemoveAt(selectedPoints[s]);
path2D.handleControlsPos.RemoveAt(selectedPoints[s]);
path2D.nodeTension.RemoveAt(selectedPoints[s]);
path2D.nodeBias.RemoveAt(selectedPoints[s]);
if (selectedPoints[s] <= i)
{
i--;
}
for (int u = 0; u < selectedPoints.Count; u++)
{
if (selectedPoints[u] > selectedPoints[s])
{
selectedPoints[u] -= 1;
}
}
}
selectedPoints.Clear();
GUI.changed = true;
}
}
}
}
public override void UpdateSize( Vector3 localChange, Direction dir )
{
Box box = GetShape<Box>();
box.HalfExtents = box.HalfExtents + Vector3.Scale( GetLocalFaceDirection( dir ), localChange );
}
public static void DrawWireCollider(Collider c)
{
if (c == null)
{
throw new System.ArgumentNullException("c");
}
if (c is BoxCollider)
{
var box = c as BoxCollider;
DrawWireRectoid(box.transform.TransformPoint(box.center), box.transform.rotation, Vector3.Scale(box.size, box.transform.lossyScale));
}
else if (c is SphereCollider)
{
var sphereGeom = com.spacepuppy.Geom.Sphere.FromCollider(c as SphereCollider);
DrawWireSphere(sphereGeom.Center, c.transform.rotation, sphereGeom.Radius);
}
else if (c is CapsuleCollider)
{
var capGeom = com.spacepuppy.Geom.Capsule.FromCollider(c as CapsuleCollider);
DrawWireCapsule(capGeom.Start, capGeom.End, capGeom.Radius);
}
else if (c is CharacterController)
{
var capGeom = com.spacepuppy.Geom.Capsule.FromCollider(c as CharacterController);
DrawWireCapsule(capGeom.Start, capGeom.End, capGeom.Radius);
}
else if (c is MeshCollider)
{
//not supported
throw new System.ArgumentException("Unsupported collider type '" + c.GetType().Name + "'.", "c");
}
else
{
//not supported
throw new System.ArgumentException("Unsupported collider type '" + c.GetType().Name + "'.", "c");
}
}
private void LegacySetParticle()
{
ParticleEmitter pe = this.m_pe;
ParticleAnimator pa = this.m_pa;
ParticleRenderer pr = this.m_pr;
if (pe == null || pr == null)
{
return;
}
if (this.m_bLegacyRuntimeScale)
{
Vector3 vector = Vector3.get_one() * this.m_fStartSpeedRate;
float fStartSpeedRate = this.m_fStartSpeedRate;
ParticleEmitter expr_53 = pe;
expr_53.set_minSize(expr_53.get_minSize() * this.m_fStartSizeRate);
ParticleEmitter expr_66 = pe;
expr_66.set_maxSize(expr_66.get_maxSize() * this.m_fStartSizeRate);
ParticleEmitter expr_79 = pe;
expr_79.set_minEnergy(expr_79.get_minEnergy() * this.m_fStartLifeTimeRate);
ParticleEmitter expr_8C = pe;
expr_8C.set_maxEnergy(expr_8C.get_maxEnergy() * this.m_fStartLifeTimeRate);
ParticleEmitter expr_9F = pe;
expr_9F.set_minEmission(expr_9F.get_minEmission() * this.m_fStartEmissionRate);
ParticleEmitter expr_B2 = pe;
expr_B2.set_maxEmission(expr_B2.get_maxEmission() * this.m_fStartEmissionRate);
pe.set_worldVelocity(Vector3.Scale(pe.get_worldVelocity(), vector));
pe.set_localVelocity(Vector3.Scale(pe.get_localVelocity(), vector));
pe.set_rndVelocity(Vector3.Scale(pe.get_rndVelocity(), vector));
ParticleEmitter expr_FB = pe;
expr_FB.set_angularVelocity(expr_FB.get_angularVelocity() * fStartSpeedRate);
ParticleEmitter expr_10A = pe;
expr_10A.set_rndAngularVelocity(expr_10A.get_rndAngularVelocity() * fStartSpeedRate);
ParticleEmitter expr_119 = pe;
expr_119.set_emitterVelocityScale(expr_119.get_emitterVelocityScale() * fStartSpeedRate);
if (pa != null)
{
pa.set_rndForce(Vector3.Scale(pa.get_rndForce(), vector));
pa.set_force(Vector3.Scale(pa.get_force(), vector));
}
ParticleRenderer expr_158 = pr;
expr_158.set_lengthScale(expr_158.get_lengthScale() * this.m_fRenderLengthRate);
}
else
{
Vector3 vector2 = ((!this.m_bScaleWithTransform) ? Vector3.get_one() : pe.get_transform().get_lossyScale()) * this.m_fStartSpeedRate;
float num = ((!this.m_bScaleWithTransform) ? 1f : NcTransformTool.GetTransformScaleMeanValue(pe.get_transform())) * this.m_fStartSpeedRate;
float num2 = ((!this.m_bScaleWithTransform) ? 1f : NcTransformTool.GetTransformScaleMeanValue(pe.get_transform())) * this.m_fStartSizeRate;
ParticleEmitter expr_1EF = pe;
expr_1EF.set_minSize(expr_1EF.get_minSize() * num2);
ParticleEmitter expr_1FE = pe;
expr_1FE.set_maxSize(expr_1FE.get_maxSize() * num2);
ParticleEmitter expr_20D = pe;
expr_20D.set_minEnergy(expr_20D.get_minEnergy() * this.m_fStartLifeTimeRate);
ParticleEmitter expr_220 = pe;
expr_220.set_maxEnergy(expr_220.get_maxEnergy() * this.m_fStartLifeTimeRate);
ParticleEmitter expr_233 = pe;
expr_233.set_minEmission(expr_233.get_minEmission() * this.m_fStartEmissionRate);
ParticleEmitter expr_246 = pe;
expr_246.set_maxEmission(expr_246.get_maxEmission() * this.m_fStartEmissionRate);
pe.set_worldVelocity(Vector3.Scale(pe.get_worldVelocity(), vector2));
pe.set_localVelocity(Vector3.Scale(pe.get_localVelocity(), vector2));
pe.set_rndVelocity(Vector3.Scale(pe.get_rndVelocity(), vector2));
ParticleEmitter expr_292 = pe;
expr_292.set_angularVelocity(expr_292.get_angularVelocity() * num);
ParticleEmitter expr_2A1 = pe;
expr_2A1.set_rndAngularVelocity(expr_2A1.get_rndAngularVelocity() * num);
ParticleEmitter expr_2B0 = pe;
expr_2B0.set_emitterVelocityScale(expr_2B0.get_emitterVelocityScale() * num);
if (pa != null)
{
pa.set_rndForce(Vector3.Scale(pa.get_rndForce(), vector2));
pa.set_force(Vector3.Scale(pa.get_force(), vector2));
}
ParticleRenderer expr_2F1 = pr;
expr_2F1.set_lengthScale(expr_2F1.get_lengthScale() * this.m_fRenderLengthRate);
}
}
protected void StartPinch()
{
// Only pinch if we're hovering over an object.
if (active_object_ == null)
{
return;
}
HandModel hand_model = GetComponent <HandModel>();
Leap.Utils.IgnoreCollisions(gameObject, active_object_.gameObject, true);
GrabbableObject grabbable = active_object_.GetComponent <GrabbableObject>();
// Setup initial position and rotation conditions.
palm_rotation_ = hand_model.GetPalmRotation();
object_pinch_offset_ = Vector3.zero;
// If we don't center the object, find the closest point in the collider for our grab point.
if (grabbable == null || !grabbable.centerGrabbedObject)
{
Vector3 delta_position = active_object_.transform.position - current_pinch_position_;
Ray pinch_ray = new Ray(current_pinch_position_, delta_position);
RaycastHit pinch_hit;
// If we raycast hits the object, we're outside the collider so grab the hit point.
// If not, we're inside the collider so just use the pinch position.
if (active_object_.Raycast(pinch_ray, out pinch_hit, grabObjectDistance))
{
object_pinch_offset_ = active_object_.transform.position - pinch_hit.point;
}
else
{
object_pinch_offset_ = active_object_.transform.position - current_pinch_position_;
}
}
filtered_pinch_position_ = active_object_.transform.position - object_pinch_offset_;
object_pinch_offset_ = Quaternion.Inverse(active_object_.transform.rotation) *
object_pinch_offset_;
rotation_from_palm_ = Quaternion.Inverse(palm_rotation_) * active_object_.transform.rotation;
// If we can rotate the object quickly, increase max angular velocity for now.
if (grabbable == null || grabbable.rotateQuickly)
{
last_max_angular_velocity_ = active_object_.GetComponent <Rigidbody>().maxAngularVelocity;
active_object_.GetComponent <Rigidbody>().maxAngularVelocity = Mathf.Infinity;
}
if (grabbable != null)
{
// Notify grabbable object that it was grabbed.
grabbable.OnGrab();
if (grabbable.useAxisAlignment)
{
// If this option is enabled we only want to align the object axis with the palm axis
// so we'll cancel out any rotation about the aligned axis.
Vector3 palm_vector = grabbable.rightHandAxis;
if (hand_model.GetLeapHand().IsLeft)
{
palm_vector = Vector3.Scale(palm_vector, new Vector3(-1, 1, 1));
}
Vector3 axis_in_palm = rotation_from_palm_ * grabbable.objectAxis;
Quaternion axis_correction = Quaternion.FromToRotation(axis_in_palm, palm_vector);
if (Vector3.Dot(axis_in_palm, palm_vector) < 0)
{
axis_correction = Quaternion.FromToRotation(axis_in_palm, -palm_vector);
}
rotation_from_palm_ = axis_correction * rotation_from_palm_;
}
}
}
private void Update()
{
transform.localScale = new Vector3(
_parentRectTransform.sizeDelta.x / _bounds.size.x,
_parentRectTransform.sizeDelta.y / _bounds.size.y,
1f);
transform.localScale = Vector3.Scale(transform.localScale, _scaleMultiplier);
switch (_cornerAchor)
{
case Anchor2D.None:
break;
case Anchor2D.UpperLeft:
transform.localPosition = new Vector3(
(-_parentRectTransform.sizeDelta.x / 2) + _offset.x,
(_parentRectTransform.sizeDelta.y / 2) + _offset.z,
_offset.z);
break;
case Anchor2D.Upper:
transform.localPosition = new Vector3(
_offset.x,
(_parentRectTransform.sizeDelta.y / 2) + _offset.y,
_offset.z);
break;
case Anchor2D.UpperRight:
transform.localPosition = new Vector3(
(_parentRectTransform.sizeDelta.x / 2) + _offset.x,
(_parentRectTransform.sizeDelta.y / 2) + _offset.y,
_offset.z);
break;
case Anchor2D.Left:
transform.localPosition = new Vector3(
(-_parentRectTransform.sizeDelta.x / 2) + _offset.x,
_offset.y,
_offset.z);
break;
case Anchor2D.Center:
transform.localPosition = new Vector3(
_offset.x,
_offset.y,
_offset.z);
break;
case Anchor2D.Right:
transform.localPosition = new Vector3(
(_parentRectTransform.sizeDelta.x / 2) + _offset.x,
_offset.y,
_offset.z);
break;
case Anchor2D.Lowerleft:
transform.localPosition = new Vector3(
(-_parentRectTransform.sizeDelta.x / 2) + _offset.x,
(-_parentRectTransform.sizeDelta.y / 2) + _offset.y,
_offset.z);
break;
case Anchor2D.Lower:
transform.localPosition = new Vector3(
_offset.x,
(-_parentRectTransform.sizeDelta.y / 2) + _offset.y,
_offset.z);
break;
case Anchor2D.LowerRight:
transform.localPosition = new Vector3(
(_parentRectTransform.sizeDelta.x / 2) + _offset.x,
(-_parentRectTransform.sizeDelta.y / 2) + _offset.y,
_offset.z);
break;
}
}
// Update is called once per frame
void Update()
{
CollisionReaction();
max = Vector3.Scale(bounds.max, transform.localScale) + transform.position;
min = Vector3.Scale(bounds.min, transform.localScale) + transform.position;
}
public void JumpTo(GameObject gao)
{
if (UnitySettings.IsRaymapGame)
{
return;
}
Vector3? center = null, size = null;
BasePersoBehaviour bpb = gao.GetComponent <BasePersoBehaviour>();
if (bpb != null)
{
switch (bpb)
{
case PersoBehaviour pb:
//print(pb.perso.SuperObject.boundingVolume.Center + " - " + pb.perso.SuperObject.boundingVolume.Size);
center = (pb.perso.SuperObject != null && pb.perso.SuperObject.boundingVolume != null) ? (pb.transform.position + pb.perso.SuperObject.boundingVolume.Center) : pb.transform.position;
size = (pb.perso.SuperObject != null && pb.perso.SuperObject.boundingVolume != null) ? Vector3.Scale(pb.perso.SuperObject.boundingVolume.Size, pb.transform.lossyScale) : pb.transform.lossyScale;
break;
case ROMPersoBehaviour rpb:
center = rpb.transform.position;
size = rpb.transform.lossyScale;
break;
case PS1PersoBehaviour ppb:
center = ppb.transform.position;
size = ppb.transform.lossyScale;
break;
}
}
else
{
SuperObjectComponent sc = gao.GetComponent <SuperObjectComponent>();
if (sc != null)
{
if (sc.so != null)
{
center = (gao.transform.position + sc.so.boundingVolume.Center);
size = Vector3.Scale(sc.so.boundingVolume.Size, gao.transform.lossyScale);
}
else
{
center = gao.transform.position;
size = gao.transform.lossyScale;
}
}
}
if (center.HasValue)
{
float objectSize = Mathf.Min(5f, Mathf.Max(size.Value.x, size.Value.y, size.Value.z));
bool orthographic = cam.orthographic;
if (orthographic)
{
targetOrthoSize = objectSize * 2f * 1.5f;
Vector3 target = cam.transform.InverseTransformPoint(center.Value);
targetPos = cam.transform.TransformPoint(new Vector3(target.x, target.y, 0f));
}
else
{
float cameraDistance = 4.0f; // Constant factor
float cameraView = 2.0f * Mathf.Tan(0.5f * Mathf.Deg2Rad * cam.fieldOfView); // Visible height 1 meter in front
float distance = cameraDistance * objectSize / cameraView; // Combined wanted distance from the object
distance += objectSize; // Estimated offset from the center to the outside of the object * 2
/*transform.position = center.Value + -transform.right * distance;
* transform.LookAt(center.Value, Vector3.up);*/
//transform.LookAt(center.Value, Vector3.up);
//transform.position = center.Value + Vector3.Normalize(transform.position - center.Value) * distance;
targetPos = center.Value + Vector3.Normalize(transform.position - center.Value) * distance;
if (center.Value - transform.position != Vector3.zero)
{
targetRot = Quaternion.LookRotation(center.Value - transform.position, Vector3.up);
}
}
}
}
void Update()
{
// Get look input
var dx = Input.GetAxis("Look Horizontal " + playerIndex) * control;
var dy = Input.GetAxis("Look Vertical " + playerIndex) * control;
var dz = Input.GetAxis("Look Roll " + playerIndex) * control;
dx *= dx * Mathf.Sign(dx);
dy *= dy * Mathf.Sign(dy);
dz *= dz * Mathf.Sign(dz);
dx += spinOutVector.x * spinOutFactor;
dy += spinOutVector.y * spinOutFactor;
dz += spinOutVector.z * spinOutFactor;
spinOutFactor = Mathf.Max(spinOutFactor - 0.25F, 0);
// Change the target look orientation based on the user's camera control input
// and slowly interpolate this parent object's rotation to it based on the lookDrag
var s = lookSpeed * Time.deltaTime * (2F + moveBoost) / 3F;
lookTarg *= Quaternion.AngleAxis(dx * s, -Vector3.up);
lookTarg *= Quaternion.AngleAxis(dy * s, -Vector3.forward);
lookTarg *= Quaternion.AngleAxis(dz * s, -Vector3.right);
transform.localRotation = Quaternion.Slerp(transform.localRotation, lookTarg, lookDrag);
// Change the ship's look orientation as well
s = shipLookSpeed;
var shipLookTarg = Quaternion.identity;
shipLookTarg *= Quaternion.AngleAxis(dx * s, -Vector3.up);
shipLookTarg *= Quaternion.AngleAxis(dy * s, -Vector3.forward);
shipLookTarg *= Quaternion.AngleAxis(dz * s, -Vector3.right);
shipLook = Quaternion.Slerp(shipLook, shipLookTarg, shipLookDrag);
// Finally, set the position and rotation of the ship model
// This includes a little bit of permutation for when the ship is idle
s = Mathf.Max(0, 1 - body.velocity.magnitude * 0.05F);
float hOff = playerIndex * 5F;
var rotHover = Quaternion.identity;
rotHover *= Quaternion.Euler(Mathf.Sin(Time.time * 2F + hOff) * 2 * s, 0, 0);
rotHover *= Quaternion.Euler(0, Mathf.Cos(Time.time * 1.5F + hOff) * 3 * s, 0);
rotHover *= Quaternion.Euler(0, 0, Mathf.Sin(Time.time * 2.5F + hOff) * s);
var posHover = Vector3.zero;
posHover.x += Mathf.Cos(Time.time * 1.5F + hOff) * 0.03F * s;
posHover.y += Mathf.Sin(Time.time * 2.5F + hOff) * 0.03F * s;
posHover.z += Mathf.Cos(Time.time * 2F + hOff) * 0.015F * s;
model.localPosition = posHover;
model.rotation = body.rotation;
model.rotation *= shipLook;
model.rotation *= Quaternion.Euler(0, turn, 0);
model.rotation *= Quaternion.Euler(roll + moveBoostRoll, 0, 0);
model.rotation *= modelRot;
model.rotation *= rotHover;
model.rotation *= Quaternion.Euler(spinOutFactor * 30, spinOutFactor * 30, spinOutFactor * 30);
// Slowly center the camera over time
camPos = Vector3.Lerp(camPos, camTargPos, camDrag * Time.deltaTime);
camRot = Quaternion.Slerp(camRot, camTargRot, camDrag * Time.deltaTime);
cam.transform.localPosition = camPos + new Vector3(rumble * 2F, -rumble * 0.25F, 0);
Vector3 jitter = Random.insideUnitSphere;
jitter.Scale(new Vector3(rumble * 0.075F, rumble * 0.075F, rumble * 0.075F));
cam.transform.localPosition += jitter;
cam.transform.localRotation = camRot;
// Rotate the armature
armatureBase.rotation = Quaternion.identity;
armature[0].rotation = model.rotation * Quaternion.Euler(270, 180, 0);
for (int i = 1; i < armature.Length; i++)
{
float speed = 1 + body.velocity.magnitude * 0.2F;
Quaternion permutation = Quaternion.Euler(Mathf.Sin(Time.time * 3F + i * 2) * speed,
Mathf.Cos(Time.time * 4F + i * 5) * speed * 2,
Mathf.Sin(Time.time * 5F + i * 7) * speed * 2);
if (armature[i].name.Contains("_"))
{
permutation *= Quaternion.Euler(0, dy * -20, dx * -20);
permutation *= Quaternion.Euler(0, 0, Mathf.DeltaAngle(turn, turnTarg));
}
armature[i].rotation = model.rotation * armatureRots[i] * permutation;
}
// Point the arrow
arrow.pointAt(game.getCheckpointPos(playerIndex), transform.localRotation * Vector3.up);
}
private void scrollChildControls( Vector3 delta )
{
try
{
scrolling = true;
delta = delta.Scale( 1, -1, 1 );
for( int i = 0; i < controls.Count; i++ )
{
var child = controls[ i ];
child.Position = ( child.Position - delta ).RoundToInt();
}
}
finally
{
scrolling = false;
}
}
void ApplyTransform()
{
// Position and rotation.
var p = position.Vector * position.Scalar;
var r = Quaternion.AngleAxis(rotation.Scalar, rotation.Vector);
if (position.mode != TransformMode.Off)
{
if (useDifferentials)
{
if (useLocalCoordinate)
{
transform.localPosition += p - previousPosition;
}
else
{
transform.position += p - previousPosition;
}
}
else
{
if (useLocalCoordinate)
{
transform.localPosition = p;
}
else
{
transform.position = p;
}
}
}
if (rotation.mode != TransformMode.Off)
{
if (useDifferentials)
{
var dr = r * Quaternion.Inverse(previousRotation);
if (useLocalCoordinate)
{
transform.localRotation = dr * transform.localRotation;
}
else
{
transform.rotation = dr * transform.rotation;
}
}
else
{
if (useLocalCoordinate)
{
transform.localRotation = r;
}
else
{
transform.rotation = r;
}
}
}
previousPosition = p;
previousRotation = r;
// Scale.
if (scale.mode != TransformMode.Off)
{
var so = useDifferentials ? initialScale : Vector3.one;
var sc = Vector3.one + scale.Vector * (scale.Scalar - 1);
transform.localScale = Vector3.Scale(so, sc);
}
}
// Update is called once per frame
void Update()
{
if (!IsDead)
{
// Interact with the item
if (mInteractItem != null && Input.GetKeyDown(KeyCode.F))
{
// Common interact method
mInteractItem.OnInteract();
// TODO: Check to move this logic to a better location
if (mInteractItem is InventoryItemBase)
{
Inventory.AddItem(mInteractItem as InventoryItemBase);
(mInteractItem as InventoryItemBase).OnPickup();
}
Hud.CloseMessagePanel();
mInteractItem = null;
}
// Execute action with item
if (mCurrentItem != null && Input.GetMouseButtonDown(0))
{
// TODO: Logic which action to execute has to come from the particular item
_animator.SetTrigger("attack_1");
}
// Get Input for axis
float h = Input.GetAxis("Horizontal");
float v = Input.GetAxis("Vertical");
// Calculate the forward vector
Vector3 camForward_Dir = Vector3.Scale(Camera.main.transform.forward, new Vector3(1, 0, 1)).normalized;
Vector3 move = v * camForward_Dir + h * Camera.main.transform.right;
if (move.magnitude > 1f)
{
move.Normalize();
}
// Calculate the rotation for the player
move = transform.InverseTransformDirection(move);
// Get Euler angles
float turnAmount = Mathf.Atan2(move.x, move.z);
transform.Rotate(0, turnAmount * RotationSpeed * Time.deltaTime, 0);
if (_characterController.isGrounded)
{
_animator.SetBool("run", move.magnitude > 0);
_moveDirection = transform.forward * move.magnitude;
_moveDirection *= Speed;
}
_moveDirection.y -= Gravity * Time.deltaTime;
_characterController.Move(_moveDirection * Time.deltaTime);
}
}
private static Transform CreateModelFrom(
Core_Voxel.Result.VoxelNode vNode, Transform parent, Vector3 pivot,
ref List <Mesh> meshs, ref Dictionary <Texture2D, Material> materialsMap,
bool isRig, bool withAvatar
)
{
Quaternion rot = vNode.Rotation;
Vector3 pivotFixOffset = rot * pivot;
Vector3 fixedModelSize = rot * vNode.Size.ToVector3();
pivotFixOffset.Scale(fixedModelSize);
Vector3 scaleFix = rot * (0.5f * (Vector3.one - vNode.Scale.ToVector3()));
scaleFix.Scale(fixedModelSize);
pivotFixOffset -= scaleFix;
Vector3 fixedMvPos = vNode.Position.ToVector3();
fixedMvPos.x += Mathf.RoundToInt(fixedModelSize.x % 2f) * 0.5f;
fixedMvPos.y += Mathf.RoundToInt(fixedModelSize.y % 2f) * 0.5f;
fixedMvPos.z += Mathf.RoundToInt(fixedModelSize.z % 2f) * 0.5f;
var root = new GameObject().transform;
root.SetParent(parent);
root.localRotation = vNode.Rotation;
root.localScale = vNode.Scale.ToVector3();
root.gameObject.SetActive(vNode.Active);
if (vNode.Model != null)
{
root.name = !string.IsNullOrEmpty(vNode.Name) ? vNode.Name : GetIndexedName("Model", parent.childCount - 1);
root.localPosition = (fixedMvPos - 0.5f * fixedModelSize + pivotFixOffset) * ModelScale;
// Empty Check
bool isEmpty = true;
var uMesh = vNode.Model;
if (uMesh.Count > 0)
{
for (int i = 0; i < uMesh.Count; i++)
{
if (uMesh[i].vertexCount > 0)
{
isEmpty = false;
break;
}
}
}
if (!isEmpty)
{
// Add Assets
Texture2D texture = vNode.Texture;
if (!texture)
{
texture = new Texture2D(4, 4);
}
Material mat = new Material(TheShader)
{
mainTexture = texture
};
materialsMap.Add(texture, mat);
// Add Mesh To
if (vNode.Model.Count == 1)
{
var mesh = vNode.Model[0];
if (!meshs.Contains(mesh))
{
meshs.Add(mesh);
}
AddMeshTo(mesh, root, mat, isRig);
}
else
{
for (int i = 0; i < vNode.Model.Count; i++)
{
var target = new GameObject("m_" + i.ToString()).transform;
target.SetParent(root);
target.SetAsLastSibling();
target.localPosition = Vector3.zero;
target.localRotation = Quaternion.identity;
target.localScale = Vector3.one;
var mesh = vNode.Model[i];
if (!meshs.Contains(mesh))
{
meshs.Add(mesh);
}
AddMeshTo(mesh, target, mat, false);
}
}
}
}
else if (vNode.Children != null && vNode.Children.Length > 0)
{
// Sub Objects
root.name = !string.IsNullOrEmpty(vNode.Name) ? vNode.Name : "Container";
root.localPosition = vNode.Position.ToVector3() * ModelScale;
for (int i = 0; i < vNode.Children.Length; i++)
{
CreateModelFrom(vNode.Children[i], root, pivot, ref meshs, ref materialsMap, isRig, withAvatar);
}
}
return(root);
}
