// Update is called once per frame
void Update()
{
moveDirection = new Vector3(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"), 0.0f);
moveDirection *= speed;
if((alus.transform.localPosition.x > maxX && Input.GetAxis("Horizontal") > 0 ) || (alus.transform.localPosition.x < minX && Input.GetAxis("Horizontal") < 0 )){
moveDirection.Set(0,moveDirection.y,moveDirection.z);
}
if( (alus.transform.localPosition.y < -15 && Input.GetAxis("Vertical") < 0) ||(alus.transform.localPosition.y > 40 && Input.GetAxis("Vertical") > 0)) {
moveDirection.Set(moveDirection.x,0,moveDirection.z);
}
playerController.Move(moveDirection * Time.deltaTime);
float rotation = rotationSpeed *Input.GetAxis("Horizontal");
if((alus.transform.rotation.y < (maxRotation/10) && Input.GetAxis("Horizontal") < 0) || (alus.transform.rotation.y > (-maxRotation/10) && Input.GetAxis("Horizontal") > 0)){
rotation = rotationSpeed *Input.GetAxis("Horizontal");
alus.transform.Rotate(new Vector3(0,-rotation,0));
}
if(Input.GetAxis("Horizontal") == 0){
if(alus.transform.rotation.y > 0 ){
rotation = rotationSpeed * -1;
}else{
rotation = rotationSpeed;
}
alus.transform.Rotate(new Vector3(0,rotation,0));
}
// alus.transform.rotation.y > -0.50
}
// Update is called once per frame
void Update()
{
moveDirection = new Vector3(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"), 0.0f);
moveDirection *= speed;
if((alus.transform.localPosition.x > maxX && Input.GetAxis("Horizontal") > 0 ) || (alus.transform.localPosition.x < minX && Input.GetAxis("Horizontal") < 0 )){
moveDirection.Set(0,moveDirection.y,moveDirection.z);
}
if( (alus.transform.localPosition.y < -15 && Input.GetAxis("Vertical") < 0) ||(alus.transform.localPosition.y > 21 && Input.GetAxis("Vertical") > 0)) {
moveDirection.Set(moveDirection.x,0,moveDirection.z);
}
//gameObject.transform.position = gameObject.transform.position + moveDirection*Time.deltaTime*1.5f;
playerController.Move(moveDirection * Time.deltaTime*1.5f);
float rotation = rotationSpeed *Input.GetAxis("Horizontal");
if((alus.transform.rotation.y < (maxRotation/10) && Input.GetAxis("Horizontal") < 0) || (alus.transform.rotation.y > (-maxRotation/10) && Input.GetAxis("Horizontal") > 0)){
rotation = rotationSpeed *Input.GetAxis("Horizontal");
alus.transform.Rotate(new Vector3(0,-rotation,0));
}
if(Input.GetAxis("Horizontal") == 0){
if(alus.transform.rotation.y > 0 ){
rotation = rotationSpeed * -1;
}else{
rotation = rotationSpeed;
}
alus.transform.Rotate(new Vector3(0,rotation,0));
}
if (Input.GetButton("Fire2")){
BroadcastMessage("ActivatePowerup");
}
if (Input.GetButtonDown("Menu")){
if(!paused){
BroadcastMessage("Shooting");
Application.LoadLevelAdditive(0);
Time.timeScale = 0;
hpBar.SetActive(false);
paused = true;
}else{
ResumeGame();
}
}
// alus.transform.rotation.y > -0.50
}
public static Vector3 RandomVector3(float max_x,float max_y, float max_z)
{
System.Random rand = new System.Random();
Vector3 newVect = new Vector3();
newVect.Set ((float)rand.NextDouble()*max_x,(float)rand.NextDouble()*max_y,(float)rand.NextDouble()*max_z );
return newVect;
}
// Use this for initialization
void Start()
{
// playerEntered = false;
// notClosed = true;
// callFurther = true;
// angle = 0;
Vector3 position = new Vector3(init_radius, init_radius, 0);
// init_angle = 0;
// int hide = (int)Random.Range(0,6);
for(int i=0; i<6; i++)
{
float xPos = init_radius*Mathf.Cos(Mathf.Deg2Rad*init_angle);
float yPos = init_radius*Mathf.Sin(Mathf.Deg2Rad*init_angle);
int index = (int)Random.Range(0,level_segments.Length);
position.Set(xPos,yPos,0);
GameObject child = (GameObject)Instantiate(level_segments[index],position, Quaternion.identity);
child.transform.parent = gameObject.transform;
// if(i == hide)
// {
// child.SetActive(false);
// }
child.transform.Rotate(0,0,(240+init_angle));
init_angle += 60;
}
//start_time = Time.time;
//makeTransparent(3,start_time,0);
}
public void Shoot()
{
if ((Input.mousePosition.x > Screen.width / 5 || Input.mousePosition.y > Screen.height / 2.5) && (Input.mousePosition.x > 60 || Input.mousePosition.y < Screen.height - 60) && Input.mousePosition.x > Screen.width / 3)
{
//shooting animation on character
//anim.CrossFade("Shooting", 0f);
Vector3 target = new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0);
target = Camera.main.ScreenToWorldPoint(target);
target.Set(target.x, target.y, gameObject.transform.position.z);
//rifle movement
Quaternion rotation = Quaternion.LookRotation(target - transform.position, transform.TransformDirection(Vector3.up));
rifle.transform.rotation = new Quaternion(0, 0, rotation.z, rotation.w); ;
//bullet spawning
GameObject obj = bullets.FirstOrDefault(x => !x.activeInHierarchy);
if (obj == null)
{
obj = (GameObject)Instantiate(bullet);
bullets.Add(obj);
}
obj.SetActive(true);
obj.transform.position = new Vector3(bulletSpawn.transform.position.x,bulletSpawn.transform.position.y,0);
obj.transform.rotation = bulletSpawn.transform.rotation;
obj.GetComponent<Rigidbody2D>().velocity = (target - bulletSpawn.transform.position).normalized * speed;
shoot = false;
Invoke("CanShootAgain", 1f);
}
}
void Start()
{
if (GlobalData.difficultyLevel == 1){
totalGoods = new GameObject[]{greenGood, blueGood};
}
else if(GlobalData.difficultyLevel == 2){
totalGoods = new GameObject[]{yellowGood, blueGood, greenGood};
}
else {
totalGoods = new GameObject[]{redGood, blueGood, greenGood, yellowGood};
}
positionWhenOneGood = new Vector3();
positionWhenOneGood.Set (transform.position.x, transform.position.y, transform.position.z);
positionsWhenTwoGoods = new Vector3[2];
positionsWhenTwoGoods[0].Set(transform.position.x, transform.position.y + offsetWhenTwoGoods, transform.position.z);
positionsWhenTwoGoods[1].Set(transform.position.x, transform.position.y - offsetWhenTwoGoods, transform.position.z);
positionsWhenThreeGoods = new Vector3[3];
positionsWhenThreeGoods[0].Set(transform.position.x, transform.position.y + offsetWhenThreeGoods, transform.position.z);
positionsWhenThreeGoods[1].Set(transform.position.x, transform.position.y, transform.position.z);
positionsWhenThreeGoods[2].Set(transform.position.x, transform.position.y - offsetWhenThreeGoods, transform.position.z);
currentGoods = new GameObject[1];
GenerateNewLot();
rate = rateOfChange;
}
public static Vector3 CreateVector3(double chromosomeVal,float max_x,float max_y, float max_z)
{
// each chromosome is a double - 8 bytes - 64 bits. This means it has a max value of ~ 1.84467441 × 10^19
// We want to use as much of that as possible, in principle. So each axis of the 3 vector will have a max of about .6*10^6
// or 600000. Alternatively we could bit-shift it? If we wanted it to come out nicely we could just ignore two bytes
// and use 2 bytes for each of the axes, but that means a max value about 65000, so we're losing an order of
// magnitude of possible variation / detail. Anyway, this should get cleaned up a bit somehow.
Vector3 vect = new Vector3();
// a double has 8 bytes, or 64 bits. We're going to bitshift the shit out of this to produce longs(16 bits).
// one of the nice things is that with 4 longs we could represent a generic quaternion pretty effectively.
long maxValue = 0xff;
long x_component = ((long)chromosomeVal >> 48) & 0x000000ff;
long y_component = ((long)chromosomeVal >> 32) & 0x000000ff;
long z_component = ((long)chromosomeVal >> 16) & 0x000000ff;
chromosomeVal = (chromosomeVal % 50);
float xval = (float)chromosomeVal * max_x;
chromosomeVal = (chromosomeVal * 10000) % 50;
float yval = (float)chromosomeVal * max_y;
chromosomeVal = (chromosomeVal * 10000) % 50;
float zval = (float)chromosomeVal * max_z;
vect.Set(xval,yval,zval);
return vect;
}
void Update()
{
Camera.main.fieldOfView = Options.fov;
if (Input.GetAxis ("RotateCameraSnap") != 0) {
camBase.localEulerAngles = new Vector3(camBase.localEulerAngles.x,
camBase.localEulerAngles.y + Input.GetAxis ("RotateCameraSnap") * 180 * Time.deltaTime,
camBase.localEulerAngles.z);
}
if (Input.GetAxis ("ResetCameraRotation") != 0) {
camBase.localEulerAngles = new Vector3(camBase.localEulerAngles.x,
0, camBase.localEulerAngles.z);
currentZoomLevel = defaultZoomLevel;
UpdateEyeDepth ();
}
float scroll = Input.GetAxis ("Mouse ScrollWheel");
if (scroll != 0) {
currentZoomLevel = Mathf.Clamp (currentZoomLevel - scroll * zoomSensitivity * (currentZoomLevel / 10), minZoomLevel, maxZoomLevel);
UpdateEyeDepth ();
}
Vector3 move = new Vector3 (Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
if (move.sqrMagnitude != 0) {
move = camBase.TransformDirection (move);
move.Set (move.x, 0, move.z);
move = move.normalized * moveSpeed;
camBase.localPosition += move * Time.deltaTime * Mathf.Pow(currentZoomLevel, 1.25f) / 25;
camBase.localPosition = new Vector3 (Mathf.Clamp (camBase.localPosition.x, -80, 80), camBase.localPosition.y,
Mathf.Clamp (camBase.localPosition.z, -80, 80));
}
}
// Use this for initialization
void Start () {
RotateAxis = Vector3.zero;
RotateAxis.Set(0, 1, -0.2f);
RotateAxis.Normalize();
rotateAroundPos = canvas.transform.position;
RectTransform rekt;
rekt = canvas.GetComponent<RectTransform>();
Vector3 v3 = rekt.lossyScale;
rotateAroundPos.z+= v3.z * 2300;
var q = ControlsButton.transform.rotation;
ControlsButton.transform.RotateAround (rotateAroundPos, RotateAxis, 350);
ControlsButton.transform.rotation = q;
LanguageButton.transform.RotateAround (rotateAroundPos, RotateAxis, 340);
LanguageButton.transform.rotation = q;
CreditsButton.transform.RotateAround (rotateAroundPos, RotateAxis, 330);
CreditsButton.transform.rotation = q;
buttons.Add (AudioButton);
buttons.Add (ControlsButton);
buttons.Add (LanguageButton);
buttons.Add (CreditsButton);
changeAlpha ();
}
// Use this for initialization
void Start()
{
startTime = Time.time;
startMarker = transform.position;
endMarker = startMarker;
endMarker.Set(endMarker.x, endMarker.y - distance, endMarker.z);
journeyLength = Vector3.Distance(startMarker, endMarker);
}
public void ApplyVector3FromLocalVector2(ref Vector3 outVector, Vector2 localVector, float z)
{
outVector.Set
(
localVector.x*a + localVector.y*c + tx,
localVector.x*b + localVector.y*d + ty,
z
);
}
void OnJoinedRoom()
{
Debug.Log (isHost);
Vector3 location = new Vector3();
location.Set (-0.0f, -0.0f, -1.00f);
GameObject player = PhotonNetwork.Instantiate("New Prefab", location, Quaternion.identity, 0);
player.GetComponent<myThirdPersonController>().isControllable = true;
player.GetComponent<myThirdPersonController>().isHost = isHost;
isHost = false;
}
void OnPlayerDeath()
{
GetComponent<Camera>().targetTexture = null;
popUpDisplay.SetActive(false);
Vector3 newPosition = new Vector3();
newPosition.Set(target.transform.position.x, 200, target.transform.position.z);
SetPosition(newPosition);
SetRotation(new Vector3(90, 0, 0));
}
public override void MoveDirection( Vector3 direction )
{
planetTransform.Move( transform, direction, speed * Time.deltaTime );
if ( _subTransform ) {
_subTransform.localRotation = Quaternion.RotateTowards( _subTransform.localRotation, Quaternion.LookRotation( direction.Set( y: 0 ), Vector3.up ), _rotationToDirectionSpeed * Time.deltaTime );
}
ApplyPunishingForce();
}
void FixedUpdate()
{
if (!hasDestination) {
GameObject player = GameObject.Find ("Player");
destination = Random.insideUnitSphere * range + (player ? player.transform.position : new Vector3 (0, 0, 0));
destination.Set (destination.x, destination.y, Mathf.Clamp (destination.z, 5.0f, 15.0f));
hasDestination = true;
StartCoroutine ("PerformManeuver");
}
}
private float relCameraPosMag; // The distance of the camera from the player.
#endregion Fields
#region Methods
public void Follow(GameObject player)
{
// Setting up the reference.
//player = GameObject.FindGameObjectWithTag("Player").transform;
this.player = player.transform;
// Setting the relative position as the initial relative position of the camera in the scene.
relCameraPos = transform.position - this.player.position;
relCameraPos.Set(0, 0, relCameraPos.z);
relCameraPosMag = relCameraPos.magnitude - 0.5f;
}
void enemyWave()
{
waves++;
for (int i = 0; i < noEnemies; i++) {
int rand = Random.Range (0, 5);
Vector3 pos = new Vector3 (13, 0, Random.Range(-7f, 9f));
GameObject Enemey = Instantiate (enemies[rand], pos, Quaternion.identity) as GameObject;
pos.Set (pos.x * -1f, pos.y, Random.Range (-7f, 9f));
GameObject Enemy = Instantiate (enemies[rand], pos, Quaternion.identity) as GameObject;
}
}
// Update is called once per frame
void Update()
{
float fBaseSpeedx = Input.GetAxis ("X Axis");
float fBaseSpeedy = Input.GetAxis ("Y Axis");
float fBaseSpeedz = Input.GetAxis ("Z Axis");
Vector3 v3BaseSpeed = new Vector3 (fBaseSpeedx, fBaseSpeedy, fBaseSpeedz);
Vector3 v3BaseRotate = new Vector3 (0.0f, 0.0f, 0.0f);
Camera Cam = GetComponent<Camera> ();
if (Input.GetKeyDown (KeyCode.R)) {
v3BaseRotate.x += 10.0f;
}
if (Input.GetKeyDown (KeyCode.T)) {
v3BaseRotate.x -= 10.0f;
}
if (Input.GetKeyDown (KeyCode.Y)) {
v3BaseRotate.y += 10.0f;
}
if (Input.GetKeyDown (KeyCode.U)) {
v3BaseRotate.y -= 10.0f;
}
if (Input.GetKeyDown (KeyCode.I)) {
v3BaseRotate.z += 10.0f;
}
if (Input.GetKeyDown (KeyCode.O)) {
v3BaseRotate.z -= 10.0f;
}
Cam.transform.Rotate (v3BaseRotate);
Cam.transform.Translate (v3BaseSpeed);
v3BaseRotate.Set (0.0f, 0.0f, 0.0f);
}
void OnPostRender()
{
//return;
if (!doRender)
return;
CreateLineMaterial();
lineMaterial.SetPass(0);
GL.Begin(GL.LINES);
GL.Color(Color.red);
Vector3 start = new Vector3();
Vector3 end = new Vector3();
Tuple<float,float> nodePos;
Tuple<float,float> neighbourPos;
foreach (var node in tree.nodeList) {
// TODO: This is inefficient - renders lines multiple times on neighbouring nodes.
// render vertical lines of grid
nodePos = node.getPosition();
foreach (var neighbour in node.children) {
neighbourPos = neighbour.getPosition();
start.Set(nodePos.first, 0f, nodePos.second);
end.Set(neighbourPos.first, 0f, neighbourPos.second);
GL.Vertex3(start.x, start.y, start.z);
GL.Vertex3(end.x, end.y, end.z);
}
}
// Vector3 start = new Vector3();
// Vector3 end = new Vector3();
// Tuple<float,float> parentPos;
// Tuple<float,float> childPos;
//
// Queue q = new Queue();
// q.Enqueue(tree.root);
//
// while(q.Count != 0){
// TreeNode<StateConfig> front = (TreeNode<StateConfig>)q.Dequeue();
// parentPos = front.getPosition();
// foreach (var child in front.children) {
// q.Enqueue(child);
// childPos = child.getPosition();
// start.Set(parentPos.first, 0f, parentPos.second);
// end.Set(childPos.first, 0f, childPos.second);
// GL.Vertex3(start.x, start.y, start.z);
// GL.Vertex3(end.x, end.y, end.z);
// }
// }
GL.End();
}
public Vector3 getSpawnLocation()
{
float x = Random.value;
float z = Random.value;
if ((int)(z * 10) % 2 == 0)
{
z *= -1;
}
Vector3 location = new Vector3(0, 0, 0);
location.Set(MAP1_SIZE * x, 0, MAP1_SIZE * z);
return location;
}
// Update is called once per frame
void Update()
{
if (stateType != StateType.Up) return;
nowScale += new Vector3(addScale, addScale, addScale);
gameObject.transform.localScale = nowScale;
// 拡大率1.0fまでいったらおわり
if(nowScale.x >= 1.0f)
{
nowScale.Set(1.0f, 1.0f, 1.0f);
gameObject.transform.localScale = nowScale;
stateType = StateType.Success;
}
}
GameObject Spawn()
{
npcs++;
Vector3 pos = new Vector3(Random.Range(-1f, 1f), Random.Range(-1f, 1f), Random.Range(-1f, 1f));
pos = transform.TransformPoint(pos * .5f);
pos.Set(pos.x, npc.transform.position.y, pos.z);
GameObject res = (GameObject)Instantiate(npc, pos, Quaternion.identity);
res.transform.parent = transform;
res.name = res.name.Replace("(Clone)", "");
return res;
}
// Update is called once per frame
void Update () {
if (Input.GetKeyDown(KeyCode.Tab))
popUpDisplay.SetActive(!popUpDisplay.activeSelf);
if (target == null)
return;
Vector3 newPosition = new Vector3();
newPosition.Set(target.transform.position.x, this.transform.position.y, target.transform.position.z);
Vector3 newRotation = this.transform.rotation.eulerAngles;
newRotation.Set(this.transform.rotation.eulerAngles.x, target.transform.rotation.eulerAngles.y, target.transform.rotation.eulerAngles.z);
SetPosition(newPosition);
SetRotation(newRotation);
}
void OnPostRender()
{
if (!doRender)
return;
CreateLineMaterial();
lineMaterial.SetPass(0);
for (int i = 0; i < navPath.Length; i++) {
GL.Begin(GL.LINES);
GL.Color(pathColours[i]);
Vector3 start = new Vector3();
Vector3 end = new Vector3();
Tuple<float,float> currentPos;
Tuple<float,float> nextPos;
// loop over path nodes, apart from the last one
for (int j = 0; j < navPath[i].length - 1; j++) {
// get the node at the current index and the next node.
// we will draw a line between these two nodes.
currentPos = navPath[i][j].content.getPosition();
nextPos = navPath[i][j+1].content.getPosition();
//Debug.Log("current: " + currentPos + ", next: " + nextPos);
start.Set(currentPos.first, 0, currentPos.second);
end.Set(nextPos.first, 0, nextPos.second);
GL.Vertex3(start.x, start.y, start.z);
GL.Vertex3(end.x, end.y, end.z);
}
GL.End();
GL.Begin(GL.QUADS);
GL.Color(pathColours[i]);
Tuple<float,float> nodePos = navPath[i][navPath[i].length - 1].getPosition();
float x = nodePos.first;
float y = nodePos.second;
GL.Vertex3(x-0.2f,0f,y+0.2f);
//top right
GL.Vertex3(x+0.2f,0f,y+0.2f);
// bottom right
GL.Vertex3(x+0.2f,0f,y-0.2f);
// bottom left
GL.Vertex3(x-0.2f,0f,y-0.2f);
GL.End();
}
}
// translate corroutine
private IEnumerator rotateCoroutine(Vector3 markerDest)
{
float newY;
Vector3 newPosition = new Vector3();
while(true)
{
transform.GetChild(0).Rotate(0, Time.deltaTime * 180, 0); //Exterior
transform.GetChild(1).Rotate(0, Time.deltaTime * -30 , 0); //Core
//*
newY = markerDest.y + Mathf.PingPong(Time.time * 8, 6);
newPosition.Set(transform.position.x, newY, transform.position.z);
transform.position = newPosition;
//*/
yield return null;
}
}
// Calculate a vector3 at point t on a bezier curve between
// p0 and p2 via p1.
private Vector3 BezCurve(float t, Vector3 p0, Vector3 p1, Vector3 p2)
{
Vector3 bezPoint = new Vector3();
float a = 1f - t;
float tt = t * t;
float[] tPoints = new float[3];
for (int i = 0; i < 3; i++)
{
tPoints [i] = ((a * a) * p0 [i]) + (2 * a) * (t * p1 [i]) + (tt * p2 [i]);
}
bezPoint.Set(tPoints [0], tPoints [1], tPoints [2]);
return bezPoint;
}
void OnPostRender()
{
if (!doRender)
return;
CreateLineMaterial();
lineMaterial.SetPass(0);
GL.Begin(GL.LINES);
GL.Color(Color.red);
Vector3 start = new Vector3();
Vector3 end = new Vector3();
Tuple<float,float> nodePos;
Tuple<float,float> neighbourPos;
foreach (var node in graph.nodes) {
// TODO: This is inefficient - renders lines multiple times on neighbouring nodes.
// render vertical lines of grid
nodePos = node.getPosition();
foreach (var neighbour in node.neighbours) {
neighbourPos = neighbour.getPosition();
start.Set(nodePos.first, 0f, nodePos.second);
end.Set(neighbourPos.first, 0f, neighbourPos.second);
GL.Vertex3(start.x, start.y, start.z);
GL.Vertex3(end.x, end.y, end.z);
}
}
GL.End();
GL.Begin(GL.QUADS);
GL.Color(Color.red);
foreach (var node in graph.nodes) {
nodePos = node.getPosition();
float x = nodePos.first;
float y = nodePos.second;
GL.Vertex3(x-0.2f,0f,y+0.2f);
//top right
GL.Vertex3(x+0.2f,0f,y+0.2f);
// bottom right
GL.Vertex3(x+0.2f,0f,y-0.2f);
// bottom left
GL.Vertex3(x-0.2f,0f,y-0.2f);
}
GL.End();
}
private void goHere(Vector3 point)
{
Vector3 tmp;
Quaternion rotate;
float ajuste = 1;
tmp = point;
tmp.Set(tmp.x - this.transform.position.x, tmp.y - this.transform.position.y, 0f);
if (tmp.x < 0f)
ajuste = -1;
tmp.Normalize();
this.transform.localRotation = Quaternion.Euler( 0f, 0f, 180 - ajuste * (Mathf.Rad2Deg * Mathf.Acos(Vector3.Dot( tmp, new Vector3(0, 1f, 0f) ) ) ) );
// Camera.main.transform.position = new Vector3(this.transform.position.x, this.transform.position.y, Camera.main.transform.position.z);
tmp = new Vector3(point.x - this.transform.position.x, point.y - this.transform.position.y, 0f);
tmp.Normalize();
tmp *= 3f;
this._rigidBody.velocity = tmp;
}
void Start()
{
totalGoods = new GameObject[]{redGood, blueGood, greenGood, yellowGood};
positionWhenOneGood = new Vector3();
positionWhenOneGood.Set (transform.position.x, transform.position.y, transform.position.z);
positionsWhenTwoGoods = new Vector3[2];
positionsWhenTwoGoods[0].Set(transform.position.x, transform.position.y + offsetWhenTwoGoods, transform.position.z);
positionsWhenTwoGoods[1].Set(transform.position.x, transform.position.y - offsetWhenTwoGoods, transform.position.z);
positionsWhenThreeGoods = new Vector3[3];
positionsWhenThreeGoods[0].Set(transform.position.x, transform.position.y + offsetWhenThreeGoods, transform.position.z);
positionsWhenThreeGoods[1].Set(transform.position.x, transform.position.y, transform.position.z);
positionsWhenThreeGoods[2].Set(transform.position.x, transform.position.y - offsetWhenThreeGoods, transform.position.z);
currentGoods = new GameObject[1];
GenerateNewLot();
rate = rateOfChange;
}
// Use this for initialization
void Start () {
state = states.animation;
canvas.alpha = 0;
alphaVar = BlackAlphaLayer.color;
alphaVar.a = 0;
RotateAxis = Vector3.zero;
RotateAxis.Set(0, 1, -0.2f);
RotateAxis.Normalize();
rotateAroundPos = canvas.transform.position;
RectTransform rekt;
rekt = canvas.GetComponent<RectTransform>();
Vector3 v3 = rekt.lossyScale;
rotateAroundPos.z+= v3.z * 346.410083f;
var q = PlayButton.transform.rotation;
ShopButton.transform.RotateAround (rotateAroundPos, RotateAxis, 72);
ShopButton.transform.rotation = q;
ScoreButton.transform.RotateAround (rotateAroundPos, RotateAxis, 144);
ScoreButton.transform.rotation = q;
SettingButton.transform.RotateAround (rotateAroundPos, RotateAxis, 288);
SettingButton.transform.rotation = q;
QuitButton.transform.RotateAround (rotateAroundPos, RotateAxis, 216);
QuitButton.transform.rotation = q;
buttons.Add (PlayButton);
buttons.Add (ShopButton);
buttons.Add (ScoreButton);
buttons.Add (SettingButton);
buttons.Add (QuitButton);
changeAlpha ();
}
Quaternion FindLookAt(Vector3 target)
{
Quaternion b = Quaternion.identity;
if (useConstraints)
{
//compose 3 individual angles, x , y, z on each plane
Quaternion prot = Quaternion.identity;
if (parent)
{
prot = parent.gameObject.transform.rotation;
}
//start by total reset of rotations
transform.rotation = Quaternion.identity;
//X
Vector3 targetDir = target - transform.position;
Vector3 currentDir = transform.forward;
//flatten to my plane of interest y,z
currentDir.Set(0, currentDir.y, currentDir.z);
targetDir.Set(0, targetDir.y, targetDir.z);
xt = Vector3.SignedAngle(targetDir, currentDir, Vector3.left);
Quaternion qa = Quaternion.AngleAxis(xt, transform.right);
Quaternion qx = qa;
//clamp X
//initial rotation is the "rigging" rotation, we add parent x to allow
//child to rotate "plus" the rig,maxmin, and parent rotation
float max = initialRotation.x + maxRotation.x;
float min = initialRotation.x + minRotation.x;
if (xt > max)
{
qx = Quaternion.Euler(max, 0, 0);
angleDifferenceX = xt - max;
}
else if (xt < min)
{
qx = Quaternion.Euler(min, 0, 0);
angleDifferenceX = xt - min;
}
xt = Mathf.Clamp(xt, min, max);
//qx is now a valid rotation on the x axis
//Y
max = initialRotation.y + maxRotation.y;
min = initialRotation.y + minRotation.y;
targetDir = target - transform.position;
currentDir = transform.forward;
//flatten to my plane of interest x,z
currentDir.Set(currentDir.x, 0, currentDir.z);
targetDir.Set(targetDir.x, 0, targetDir.z);
yt = Vector3.SignedAngle(targetDir, currentDir, Vector3.down);
qa = Quaternion.AngleAxis(yt, transform.up);
Quaternion qy = qa;
//clamp Y
//initial rotation is the "rigging" rotation
if (yt > max)
{
qy = Quaternion.Euler(0, max, 0);
angleDifferenceY = yt - max;
}
else if (yt < min)
{
qy = Quaternion.Euler(0, min, 0);
angleDifferenceY = yt - min;
}
yt = Mathf.Clamp(yt, min, max);
//Z
max = initialRotation.z + maxRotation.z;
min = initialRotation.z + minRotation.z;
//first we DO apply the x,y rotation, Z is just a twist
transform.localRotation = Quaternion.Euler(xt, yt, 0);
targetDir = target - transform.position;
currentDir = transform.forward;
//flatten to my plane of interest x,y
currentDir.Set(currentDir.x, 0, currentDir.z);
targetDir.Set(targetDir.x, 0, targetDir.z);
zt = Vector3.SignedAngle(targetDir, currentDir, Vector3.down);
qa = Quaternion.AngleAxis(zt, transform.forward);
Quaternion qz = qa;
//clamp Z
//initial rotation is the "rigging" rotation
if (zt > max)
{
qz = Quaternion.Euler(0, 0, max);
angleDifferenceZ = zt - max;
}
else if (zt < min)
{
qz = Quaternion.Euler(0, 0, min);
angleDifferenceZ = zt - min;
}
zt = Mathf.Clamp(zt, min, max);
return(Quaternion.Euler(xt, yt, zt));
}
else
{
return(Quaternion.LookRotation(Vector3.Normalize(target - transform.position)));
}
}
// Update is called once per frame
void Update()
{
float rotateVariable = -Input.GetAxis("Ho") * 4;
if (bBoosted)
{
rotateVariable = -Input.GetAxis("Ho") * 2;
bBoosted = false;
}
//tr.Rotate(v, rotateVariable);
angleadd += rotateVariable;
dirX = Mathf.Cos((angleadd / 180) * PI);
dirY = Mathf.Sin((angleadd / 180) * PI);
//Vector3 vf = new Vector3(1, dirX, 1);
//Flighttr0.localScale.Scale(vf);
//Flighttr1.localScale.Scale(vf);
Flighttr1.localScale = new Vector3(0.5f, -FlightYScale * dirY, 1);
GameObject.Find("flightmask").GetComponent <Transform>().localScale = Flighttr1.localScale;
float Length = Mathf.Sqrt(Mathf.Pow(Vx, 2) + Mathf.Pow(Vy, 2));
if (Length != 0)
{
float dvx = decreaseSpeed * Vx / Length;
float dvy = decreaseSpeed * Vy / Length;
Vx -= dvx;
Vy -= dvy;
}
if (Input.GetAxis("X") == 1)
{
}
if (Input.GetAxis("Boost") > 0)
{
boostAnimator.SetInteger("StateNum", 0);
int t = boostAnimator.GetInteger("time") + 1;
boostAnimator.SetInteger("time", t);
bBoosted = true;
Vx += dirX * boostSpeed;
Vy += dirY * boostSpeed;
if (g.downSpeed > 0)
{
g.downSpeed -= 3 * g.gravity * dirY;
}
else
{
g.downSpeed = 0;
}
}
else
{
boostAnimator.SetInteger("StateNum", 1);
}
Length = Mathf.Sqrt(Mathf.Pow(Vx, 2) + Mathf.Pow(Vy, 2));
if (LimitSpeed < Length)
{
Vx = LimitSpeed * Vx / Length;
Vy = LimitSpeed * Vy / Length;
}
Vector3 v = new Vector3();
v.Set(0, 0, 1);
tr.Rotate(v, rotateVariable);
Quaternion q = tr.rotation;
Vector3 pos = new Vector3();
pos.Set(tr.position.x + Vx, tr.position.y + Vy, 0);
tr.SetPositionAndRotation(pos, q);
Vector3 CV = new Vector3();
CV.Set((tr.position.x + mctr.position.x) / 2, (tr.position.y + mctr.position.y) / 2, -50);
mctr.SetPositionAndRotation(CV, mctr.rotation);
}
/// <summary>
/// Converts tilemap grid coordinates to a Vector3 to be used for transform positions, based on the tilesize field.
/// </summary>
/// <param name="x">Tilemap x coordinate</param>
/// <param name="y">Tilemap y coordinate</param>
/// <returns>A Vector3 of the position in 3D space.</returns>
public Vector3 GridToPosition(int x, int y)
{
pos.Set(x * tilesize, 0, -y * tilesize);
return(pos);
}
// Use this for initialization
public void Build(int originX, int originY, float cubeSize)
{
this.aMeshFilter = GetComponent <MeshFilter>();
this.aMesh = aMeshFilter.mesh;
Vector3 vertLeftTopFront = new Vector3();
Vector3 vertRightTopFront = new Vector3();
Vector3 vertRightTopBack = new Vector3();
Vector3 vertLeftTopBack = new Vector3();
Vector3 vertLeftBottomFront = new Vector3();
Vector3 vertRightBottomFront = new Vector3();
Vector3 vertLeftBottomBack = new Vector3();
Vector3 vertRightBottomBack = new Vector3();
vertLeftTopFront.Set(originX + cubeSize, cubeSize, originY + cubeSize);
vertRightTopFront.Set(originX + cubeSize, cubeSize, originY);
vertRightTopBack.Set(originX, cubeSize, originY);
vertLeftTopBack.Set(originX, cubeSize, originY + cubeSize);
vertLeftBottomFront.Set(originX + cubeSize, 0, originY + cubeSize);
vertRightBottomFront.Set(originX + cubeSize, 0, originY);
vertLeftBottomBack.Set(originX, 0, originY + cubeSize);
vertRightBottomBack.Set(originX, 0, originY);
//Vertices//
Vector3[] vertices = new Vector3[]
{
//front face//
vertLeftTopFront, //left top front, 0
vertRightTopFront, //right top front, 1
vertLeftBottomFront, //left bottom front, 2
vertRightBottomFront, //right bottom front, 3
//back face//
vertRightTopBack, //right top back, 4
vertLeftTopBack, //left top back, 5
vertRightBottomBack, //right bottom back, 6
vertLeftBottomBack, //left bottom back, 7
//left face//
vertLeftTopBack, //left top back, 8
vertLeftTopFront, //left top front, 9
vertLeftBottomBack, //left bottom back, 10
vertLeftBottomFront, //left bottom front, 11
//right face//
vertRightTopFront, //right top front, 12
vertRightTopBack, //right top back, 13
vertRightBottomFront, //right bottom front, 14
vertRightBottomBack, //right bottom back, 15
//top face//
vertLeftTopBack, //left top back, 16
vertRightTopBack, //right top back, 17
vertLeftTopFront, //left top front, 18
vertRightTopFront, //right top front, 19
//bottom face//
vertLeftBottomFront, //left bottom front, 20
vertRightBottomFront, //right bottom front, 21
vertLeftBottomBack, //left bottom back, 22
vertRightBottomBack //right bottom back, 23
};
//Triangles// 3 points, clockwise determines which side is visible
int[] triangles = new int[]
{
//front face//
0, 2, 3, //first triangle
3, 1, 0, //second triangle
//back face//
4, 6, 7, //first triangle
7, 5, 4, //second triangle
//left face//
8, 10, 11, //first triangle
11, 9, 8, //second triangle
//right face//
12, 14, 15, //first triangle
15, 13, 12, //second triangle
//top face//
16, 18, 19, //first triangle
19, 17, 16, //second triangle
//bottom face//
20, 22, 23, //first triangle
23, 21, 20 //second triangle
};
//UVs//
Vector2[] uvs = new Vector2[]
{
//front face// 0,0 is bottom left, 1,1 is top right//
new Vector2(0, 1),
new Vector2(0, 0),
new Vector2(1, 1),
new Vector2(1, 0),
new Vector2(0, 1),
new Vector2(0, 0),
new Vector2(1, 1),
new Vector2(1, 0),
new Vector2(0, 1),
new Vector2(0, 0),
new Vector2(1, 1),
new Vector2(1, 0),
new Vector2(0, 1),
new Vector2(0, 0),
new Vector2(1, 1),
new Vector2(1, 0),
new Vector2(0, 1),
new Vector2(0, 0),
new Vector2(1, 1),
new Vector2(1, 0),
new Vector2(0, 1),
new Vector2(0, 0),
new Vector2(1, 1),
new Vector2(1, 0)
};
Renderer renderer = GetComponent <Renderer>();
this.aMesh.Clear();
this.aMesh.vertices = vertices;
this.aMesh.triangles = triangles;
this.aMesh.uv = uvs;
this.aMesh.RecalculateNormals();
Material mat = Resources.Load("Wall") as Material;
renderer.material = mat;
}
//public void Flex(bool flex, float range = 0f, float firstTime = 0f, float secondTime= 0f, bool isDiminishing = true)
//{
// if (flexCamera != null)
// {
// flexCamera.FlexRange = range;
// flexCamera.FirstHalfTime = firstTime;
// flexCamera.SecondHalfTime = secondTime;
// flexCamera.IsDiminishing = isDiminishing;
// flexCamera.IsStart = flex;
// }
//}
void FixedUpdate()
{
if (EventSystem.current && EventSystem.current.IsPointerOverGameObject() && Input.GetMouseButton(0))
{
return;
}
if (Target == null)
{
return;
}
if (isFirst)
{
mY = MaxLimitY;
}
//鼠标左键旋转
if (!Application.isMobilePlatform)
{
if (Input.GetMouseButton(0))
{
//获取鼠标输入
mX += Input.GetAxis("Mouse X") * SpeedX * 0.02F;
mY -= Input.GetAxis("Mouse Y") * SpeedY * 0.02F;
//范围限制
mY = ClampAngle(mY, MinLimitY, MaxLimitY);
}
else if (Target != null && Input.GetMouseButton(0) == false && isFirst == true)
{
mY = MaxLimitY;
mX = Target.transform.localEulerAngles.y;
}
//鼠标滚轮缩放
if (!IsGameEye)
{
Distance -= Input.GetAxis("Mouse ScrollWheel") * ZoomSpeed;
Distance = Mathf.Clamp(Distance, MinDistance, MaxDistance);
}
}
//重新计算位置和角度
Quaternion mRotation = Quaternion.Euler(mY, mX, 0);
tposition.Set(0F, 0F, -Distance);
Vector3 mPosition = mRotation * tposition + Target.transform.position;
//设置相机的角度和位置
if (isNeedDamping && isFirst == false)
{
//球形插值
myCamera.transform.rotation = Quaternion.Lerp(myCamera.transform.rotation, mRotation, Time.deltaTime * Damping);
//线性插值
myCamera.transform.position = Vector3.Lerp(myCamera.transform.position, mPosition, Time.deltaTime * Damping);
}
else
{
myCamera.transform.rotation = mRotation;
myCamera.transform.position = mPosition;
}
eulerAngles.Set(0f, mX, 0f);
//将玩家转到和相机对应的位置上
if (IsChangeEuler)
{
Target.transform.eulerAngles = eulerAngles;
}
if (IsGameEye)
{
Distance = 5f;
Target.transform.eulerAngles = eulerAngles;
position.Set(Target.transform.position.x + TargetOffset.x, Target.transform.position.y + TargetOffset.y, Target.transform.position.z + TargetOffset.z);
transform.LookAt(position);
}
isFirst = false;
}
void CamFollow()
{
CamPosition.Set(PlayerPosition.x, CamPosition.y, CamPosition.z);
Cam.transform.position = CamPosition;
Cam.transform.LookAt(transform.position);
}
void Move(float h, float v)
{
movement.Set(h, 0f, v);
movement = movement.normalized * speed * Time.deltaTime;
playerRigidbody.MovePosition(transform.position + movement);
}
// Update is called once per frame
void Update()
{
if (followTarget)
{
pos = Vector2.Lerp(transform.position, target.position, m_speed);
//Prevent camera from moving too far
pos.y = (float)Mathf.Min(Mathf.Max(target.position.y, height * 0.5f + correctionY),
levelPixelHeight - (height * 0.5f));
pos.x = (float)Mathf.Min(Mathf.Max(target.position.x, width * 0.5f + correctionX),
levelPixelWidth - (width * 0.5f));
depth.Set(pos.x, pos.y, depth.z);
transform.position = depth;
} else
{
Vector2 movement_vector = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical"));
Vector2 position = transform.position;
Vector2 targetPos = position + movement_vector * Time.deltaTime * FreeCameraSpeed;
print(movement_vector);
pos = Vector2.Lerp(transform.position, targetPos, m_speed);
//Prevent camera from moving too far
pos.y = (float)Mathf.Min(Mathf.Max(targetPos.y, height * 0.5f + correctionY),
levelPixelHeight - (height * 0.5f));
pos.x = (float)Mathf.Min(Mathf.Max(targetPos.x, width * 0.5f + correctionX),
levelPixelWidth - (width * 0.5f));
depth.Set(pos.x, pos.y, depth.z);
transform.position = depth;
}
if (Input.GetKeyDown(KeyCode.Return) || Input.GetKeyDown(KeyCode.KeypadEnter))
{
print("KeypadEnter");
if (followTarget)
{
print("target set to null");
exTarget = target;
followTarget = false;
} else
{
print("target reseted");
followTarget = true;
}
}
if (Input.GetKeyDown(KeyCode.Comma))
{
zoom -= 1f;
mycam.orthographicSize = (Screen.height / zoom) * 0.25f;
} else if (Input.GetKeyDown(KeyCode.Period))
{
zoom += 1f;
mycam.orthographicSize = (Screen.height / zoom) * 0.25f;
}
if (Input.GetKeyDown(KeyCode.P))
{
if (GameManager.isPaused())
GameManager.resumeGame();
else
GameManager.pauseGame();
}
}
IEnumerator MoveCoroutine()
{
while (Input.GetAxisRaw("Vertical") != 0 || Input.GetAxisRaw("Horizontal") != 0)
{
if (Input.GetKey(KeyCode.LeftShift))
{
applyRunSpeed = runSpeed;
applyRunFlag = true;
}
else
{
applyRunSpeed = 0;
applyRunFlag = false;
}
vector.Set(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical"), transform.position.z);
if (vector.x != 0)
{
vector.y = 0;
}
// vector.x!=0 0이 아닐시 위아래 정보를 가져올 필요가 없다
animator.SetFloat("DirX", vector.x);
animator.SetFloat("DirY", vector.y);
RaycastHit2D hit;
// A지점 B지점이 있을때 레이저를 쏴서
// B지점까지 무사히 도달한다면 hit==null
// 무사히 도달하지 못하면 hit==방해물이 리턴
Vector2 start = transform.position; // A지점 캐릭터의 현재 위치값
Vector2 end = start + new Vector2(vector.x * speed * walkCount, vector.y * speed * walkCount); // B지점 캐릭터가 이동하고자 하는 위치값
// 캐릭터가 자기본연의값 boxcollider를 가지고 있는데 본인이쏘고 본인이 맞을수가 있어서 잠시 해제해준다
boxCollider.enabled = false;
//레이저를 쏘는것
hit = Physics2D.Linecast(start, end, layerMask);
// 캐릭터 자기 본연의값을 다시 세팅해준다
boxCollider.enabled = true;
if (hit.transform != null)
{
break;
}
animator.SetBool("Walking", true);
// 상하좌우일때 인수를 DirX로 받는것 애니메이터에 입력
while (currentWalkCount < walkCount)
{
// 상하 좌우 모두 움직일 수 있는 기능 구현
if (vector.x != 0)
{
//Translate == 현재 있는값에서 옆에 수치만큼 더해준다
transform.Translate(vector.x * (speed + applyRunSpeed), 0, 0);
// 움직일 수 있는 다양한 방법이 있다
// transfrom.position=vector
}
else if (vector.y != 0)
{
transform.Translate(0, vector.y * (speed + applyRunSpeed), 0);
}
if (applyRunFlag)
{
currentWalkCount++;
}
currentWalkCount++;
yield return(new WaitForSeconds(0.01f));
}
currentWalkCount = 0;
}
animator.SetBool("Walking", false);
canMove = true;
}
private void Update()
{
flyBar.fillAmount = flyCount.value;
glideBar.fillAmount = maxGlide;
if (flyCount.value == flightAmount.value)
{
flyBar.fillAmount = 0;
}
if (maxGlide == 100f)
{
glideBar.fillAmount = 0;
}
if (Input.GetKey(KeyCode.LeftShift) && !controller.isGrounded && maxGlide < 100f)
{
yVar = glideSpeed;
maxGlide++;
moveSpeed = walkSpeed.value;
print("gliding");
if (maxGlide >= 100f)
{
yVar = gravity.value;
print("falling");
}
}
if (Input.GetKeyUp(KeyCode.LeftShift) && !controller.isGrounded)
{
yVar = gravity.value;
print("not gliding");
}
if (controller.isGrounded)
{
maxGlide = 0f;
}
hInput = Input.GetAxis("Horizontal") * -moveSpeed;
vInput = Input.GetAxis("Vertical") * moveSpeed;
movement.Set(vInput, yVar, hInput);
Vector3 newPosition = new Vector3(-hInput, 0.0f, vInput);
transform.rotation = Quaternion.LookRotation(newPosition);
yVar += gravity.value * Time.deltaTime;
if (controller.isGrounded && movement.y < 0)
{
flyCount.value = 0;
}
if (Input.GetButton("Jump") && flyCount.value < flightAmount.value)
{
yVar = flyHeight;
flyCount.value++;
}
controller.Move((movement) * Time.deltaTime);
}
void LateUpdate()
{
if (target)
{
Vector3 delta = target.position -
gameCamera.ViewportToWorldPoint(new Vector3(cameraCenterX, cameraCenterY, 0));
if (!isFollowHorizontal)
{
delta.x = 0;
}
if (!isFollowVertical)
{
delta.y = 0;
}
Vector3 destination = transform.position + delta;
if (!hardDeadZone)
{
tempVec = Vector3.SmoothDamp(transform.position, destination, ref velocity, dampTime);
}
else
{
tempVec.Set(transform.position.x, transform.position.y, transform.position.z);
}
if (isDeadZoneHorizontal)
{
if (delta.x > rightDeadBound)
{
tempVec.x = target.position.x - rightDeadBound + deltaCenterVec.x;
}
if (delta.x < -leftDeadBound)
{
tempVec.x = target.position.x + leftDeadBound + deltaCenterVec.x;
}
}
if (isDeadZoneVertical)
{
if (delta.y > upperDeadBound)
{
tempVec.y = target.position.y - upperDeadBound + deltaCenterVec.y;
}
if (delta.y < -lowerDeadBound)
{
tempVec.y = target.position.y + lowerDeadBound + deltaCenterVec.y;
}
}
if (isBoundHorizontal)
{
tempVec.x = Mathf.Clamp(tempVec.x, leftBound + horzExtent, rightBound - horzExtent);
}
if (isBoundVertical)
{
tempVec.y = Mathf.Clamp(tempVec.y, lowerBound + vertExtent, upperBound - vertExtent);
}
tempVec.z = transform.position.z;
transform.position = tempVec;
}
}
// --------------------------------------------------------------------------------
public override void OnUpdate()
{
if (m_characterController != null)
{
float dt = GetScaledDeltaTime();
// movement acceleration
if (m_movementStep.sqrMagnitude > 0.0f)
{
if (m_movementAcceleration < 1.0f)
{
m_movementAcceleration = Mathf.Clamp(m_movementAcceleration + dt * m_config.MovementAccelerationFactor, 0.0f, 1.0f);
}
m_appliedMovementStep = m_movementStep * m_movementAcceleration;
m_lastMovementStep = m_movementStep;
}
// movement deceleration
else
{
if (m_movementAcceleration > 0.0f)
{
m_movementAcceleration = Mathf.Clamp(m_movementAcceleration - dt * m_config.MovementDecelerationFactor, 0.0f, 1.0f);
m_appliedMovementStep = m_lastMovementStep * m_movementAcceleration;
}
}
// move
if (m_movementFrozen == false)
{
m_characterController.Move(m_appliedMovementStep);
}
m_movementStep.Set(0.0f, 0.0f, 0.0f);
// rotation acceleration
if (m_rotationStep != 0.0f)
{
if (m_rotationAcceleration < 1.0f)
{
m_rotationAcceleration = Mathf.Clamp(m_rotationAcceleration + dt * m_config.RotationAccelerationFactor, 0.0f, 1.0f);
}
m_appliedRotationStep = m_rotationStep * m_rotationAcceleration;
m_lastRotationStep = m_rotationStep;
}
// rotation deceleration
else
{
if (m_rotationAcceleration > 0.0f)
{
m_rotationAcceleration = Mathf.Clamp(m_rotationAcceleration - dt * m_config.RotationDecelerationFactor, 0.0f, 1.0f);
m_appliedRotationStep = m_lastRotationStep * m_rotationAcceleration;
}
}
// rotate
if (m_movementFrozen == false)
{
m_transform.Rotate(0.0f, m_appliedRotationStep, 0.0f);
}
m_rotationStep = 0.0f;
}
}
void Start()
{
//Set the new Vector to be that of the Transform you attach in the Inspector
m_MyPosition.Set(m_NewTransform.position.x, m_NewTransform.position.y, 0);
}
private void onLidarRangeTriggered(Collider detect)
{
if (!isEnabled || lidarDetectedColliders == null)
{
return;
}
if (!lidarDetectedColliders.ContainsKey(detect))
{
string label = "";
Vector3 size = Vector3.zero;
if (detect.gameObject.layer == 14 || detect.gameObject.layer == 19)
{
// if NPC or NPC Static
label = "car";
if (detect.GetType() == typeof(BoxCollider))
{
size.x = ((BoxCollider)detect).size.z;
size.y = ((BoxCollider)detect).size.x;
size.z = ((BoxCollider)detect).size.y;
}
}
else if (detect.gameObject.layer == 18)
{
// if Pedestrian
label = "pedestrian";
if (detect.GetType() == typeof(CapsuleCollider))
{
size.x = ((CapsuleCollider)detect).radius;
size.y = ((CapsuleCollider)detect).radius;
size.z = ((CapsuleCollider)detect).height;
}
}
if (label == "" || size.magnitude == 0)
{
return;
}
// Local position of object in Lidar local space
Vector3 relPos = lidarSensor.transform.InverseTransformPoint(detect.transform.position);
// Convert from (Right/Up/Forward) to (Forward/Left/Up)
relPos.Set(relPos.z, -relPos.x, relPos.y);
// Relative rotation of objects wrt Lidar frame
Quaternion relRot = Quaternion.Inverse(lidarSensor.transform.rotation) * detect.transform.rotation;
// Convert from (Right/Up/Forward) to (Forward/Left/Up)
relRot.Set(relRot.z, -relRot.x, relRot.y, relRot.w);
// Linear velocity in forward direction of objects, in meters/sec
float linear_vel = Vector3.Dot(GetLinVel(detect), detect.transform.forward);
// Angular velocity around up axis of objects, in radians/sec
float angular_vel = -(GetAngVel(detect)).y;
lidarDetectedColliders.Add(detect, new Ros.Detection3D()
{
header = new Ros.Header()
{
stamp = Ros.Time.Now(),
seq = seqId++,
frame_id = "velodyne",
},
id = objId++,
label = label,
score = 1.0f,
bbox = new Ros.BoundingBox3D()
{
position = new Ros.Pose()
{
position = new Ros.Point()
{
x = relPos.x,
y = relPos.y,
z = relPos.z,
},
orientation = new Ros.Quaternion()
{
x = relRot.x,
y = relRot.y,
z = relRot.z,
w = relRot.w,
},
},
size = new Ros.Vector3()
{
x = size.x,
y = size.y,
z = size.z,
},
},
velocity = new Ros.Twist()
{
linear = new Ros.Vector3()
{
x = linear_vel,
y = 0,
z = 0,
},
angular = new Ros.Vector3()
{
x = 0,
y = 0,
z = angular_vel,
},
},
});
}
}
public void ShowInternalData( UndoParentNode owner, bool useCustomLabel = false, string customLabel = null )
{
string label = ( useCustomLabel == true && customLabel != null ) ? customLabel : m_internalDataPropertyLabel:
switch( m_dataType )
{
case WirePortDataType.OBJECT:
case WirePortDataType.FLOAT:
{
FloatInternalData = owner.EditorGUILayoutFloatField( label, FloatInternalData ):
}
break:
case WirePortDataType.FLOAT2:
{
Vector2InternalData = owner.EditorGUILayoutVector2Field( label, Vector2InternalData ):
}
break:
case WirePortDataType.FLOAT3:
{
Vector3InternalData = owner.EditorGUILayoutVector3Field( label, Vector3InternalData ):
}
break:
case WirePortDataType.FLOAT4:
{
Vector4InternalData = owner.EditorGUILayoutVector4Field( label, Vector4InternalData ):
}
break:
case WirePortDataType.FLOAT3x3:
{
Matrix4x4 matrix = Matrix4x4InternalData:
Vector3 currVec3 = Vector3.zero:
for( int i = 0: i < 3: i++ )
{
Vector4 currVec = matrix.GetRow( i ):
currVec3.Set( currVec.x, currVec.y, currVec.z ):
EditorGUI.BeginChangeCheck():
currVec3 = owner.EditorGUILayoutVector3Field( label + "[ " + i + " ]", currVec3 ):
if( EditorGUI.EndChangeCheck() )
{
currVec.Set( currVec3.x, currVec3.y, currVec3.z, currVec.w ):
matrix.SetRow( i, currVec ):
}
}
Matrix4x4InternalData = matrix:
}
break:
case WirePortDataType.FLOAT4x4:
{
Matrix4x4 matrix = Matrix4x4InternalData:
for( int i = 0: i < 4: i++ )
{
Vector4 currVec = matrix.GetRow( i ):
EditorGUI.BeginChangeCheck():
currVec = owner.EditorGUILayoutVector4Field( label + "[ " + i + " ]", currVec ):
if( EditorGUI.EndChangeCheck() )
{
matrix.SetRow( i, currVec ):
}
}
Matrix4x4InternalData = matrix:
}
break:
case WirePortDataType.COLOR:
{
ColorInternalData = owner.EditorGUILayoutColorField( label, ColorInternalData ):
}
break:
case WirePortDataType.INT:
{
IntInternalData = owner.EditorGUILayoutIntField( label, IntInternalData ):
}
break:
}
}
/// <summary>
/// 计算最佳击球点
/// </summary>
/// <out>[0,1,2,3]: 落地前, 第一次落地点, 第一次弹起后, 第二次落地前</out>
/// <returns type="System.Boolean"></returns>
/// Unity3D中常用的物理学公式 https://www.cnblogs.com/msxh/p/6128851.html
/// Unity 如何计算阻力？ https://www.leadwerks.com/community/topic/4385-physics-how-does-unity-calculate-drag/
/// FIXIT: 求解微积分方程获取精确路径 https://www.zhihu.com/question/68565717
/// 每次实时获取，不可用缓存
public bool GetTarget(out Vector3[] outPos, out float[] outTimes)
{
// if (lastFloorHit == FloorHit.FloorAHit || lastFloorHit == FloorHit.FloorBHit)
// {
// outPos = TargetPos;
// outTimes =Tt;
// return outPos.Length > 3;
// }
// List<Quaternion> tq = new List<Quaternion>();
// var q = new Quaternion(Vector3.back, Single.Epsilon, );
var ball = pg.ball;
var G = pg.G.y;
var v = ball.Velocity;
var d = ball.rb.drag; // 0.47 https://www.jianshu.com/p/9da46cf6d5f5
var m = ball.rb.mass;
// var ad = - Mathf.Pow(v.magnitude, 2) * drag * v.normalized;
var ops = new List <Vector3>(4);
var ots = new List <float>(4);
var pp = ball.transform.localPosition; // rb.position; //
var a = new Vector3();
var tp = pp;
var time = 5f;
var dt = 0.009f;//Time.deltaTime;
// if (dt < 0.01f || dt > 0.3f) dt = 0.01f;
var timeCount = 0f;
var bouncec = 0;
Vector3 minP = pp;
float minl = float.MaxValue;
float minPt = 0f;
for (float t = 0f; t < time && bouncec < 2; t += dt)
{
timeCount += dt;
var ppy = tp.y;
tp = new Vector3(v.x * dt, v.y * dt, v.z * dt) + pp;
var l = (tp - transform.localPosition).sqrMagnitude;
if (l < minl)
{
minl = l;
minP = tp;
minPt = timeCount;
}
if (ppy * tp.y < 0f) // 反弹
{
++bouncec;
tp.y = 0f;
ops.Add(tp);
ots.Add(timeCount);
v.y = -v.y;
// v *= 0.8f; // 非刚性反弹？
}
pp = tp;
a.Set(
(d * v.x * v.x) / m * (v.x > 0f ? -1f : 1f),
(d * v.y * v.y) / m * (v.y > 0f ? -1f : 1f) + G,
(d * v.z * v.z) / m * (v.z > 0f ? -1f : 1f));
var pvy = v.y;
v.Set(
v.x + a.x * dt,
v.y + a.y * dt,
v.z + a.z * dt);
// 最佳击球点
var bestHitY = v.x > 0f ? pg.agentA.BestTargetY : pg.agentB.BestTargetY;
if (tp.y >= bestHitY && Mathf.Abs(tp.y - bestHitY) < Mathf.Abs(v.y * dt) * 1f ||
tp.y < bestHitY && pvy * v.y < 0f) // 顶点
{
ops.Add(tp);
ots.Add(timeCount);
if (pvy * v.y < 0f)
{
v.y = 0f;
}
}
} // for
// 最近击球点
ops.Add(minP);
ots.Add(minPt);
outTimes = ots.ToArray();
outPos = ops.ToArray();
TargetPos = outPos;
Tt = outTimes;
return(outPos.Length > 5);
}
public void MoveEnd()
{
isMove = false;
targetPosition.Set(-1, -1, -1);
}
public static void SetLocalScaleX(this Transform transform, float v)
{
vec.Set(v, transform.localScale.y, transform.localScale.z);
transform.localScale = vec;
}
void Move(float v, float h, bool sprinting)
{
Vector3 movement;
// Vertical movement
Vector3 movementV = new Vector3();
movementV.Set(transform.forward.x, 0f, transform.forward.z);
movementV.Normalize();
// Horizontal movement
Vector3 movementH = new Vector3();
movementH.Set(transform.right.x, 0f, transform.right.z);
movementH.Normalize();
if (h == 0)
{
// forwards
if (v > 0)
{
movement = movementV.normalized * vSpeed * Time.deltaTime * v;
}
// backwards
else
{
movement = movementV.normalized * hSpeed * Time.deltaTime * v;
}
}
// strafe
else if (v == 0)
{
movement = movementH.normalized * hSpeed * Time.deltaTime * h;
}
// forward and strafe
else if (v > 0)
{
movementH *= h;
movementV *= v;
movement = movementH + movementV;
movement = movement.normalized * vSpeed * Time.deltaTime;
}
// backward and strafe
else
{
movementH *= h;
movementV *= v;
movement = movementH + movementV;
movement = movement.normalized * hSpeed * Time.deltaTime;
}
if (sprinting && v > 0)
{
movement *= sprintMultiplier;
}
rb.AddForce(movement);
//Vector3 vec3 = rb.velocity;
//vec3.y = 0;
//Debug.Log(vec3.magnitude);
}
private void FixedUpdate()
{
//Generate an imaginary sphere at the character's feet and see if it collides with anything on the ground layer.
//If it does, then we are on the ground. Otherwise we are not on the ground
if (Physics.CheckSphere(transform.position, .1f, whatIsGround))
{
grounded = true;
}
else
{
grounded = false;
}
//If the GameManager exists AND it tells us that the game is over, leave
if (GameManager.instance != null && GameManager.instance.CurrentGameState == GameState.Gameover)
{
//Go back to our Idle animation by dropping the speed to 0
anim.SetFloat("Speed", 0f);
return;
}
//Get the horizontal and vertical input (up/down/left/right arrows, WASD keys, controller analog stick, etc),
//and store that input in our playerInput variable (there won't be any "y" input)
playerInput.Set(Input.GetAxis("Horizontal"), 0f, Input.GetAxis("Vertical"));
//Adjust to camera space
playerInput = Quaternion.Euler(Vector3.up * cameraTransform.rotation.eulerAngles.y) * playerInput;
bool canRun = anim.GetCurrentAnimatorStateInfo(0).IsName("Idle") || anim.GetCurrentAnimatorStateInfo(0).IsName("Run") || anim.GetCurrentAnimatorStateInfo(0).IsName("Jump");
//Tell the animator the "speed" of our movement based on the magnitude
//of the vector (the numerical "value" of the vector)
if (canRun)
{
anim.SetFloat("Speed", playerInput.sqrMagnitude);
}
else
{
anim.SetFloat("Speed", 0f);
}
//Get Attack state
if (Input.GetMouseButtonDown(0))
{
anim.SetBool("Attack", true);
CancelInvoke("AttackCooldown");
Invoke("AttackCooldown", 0.5f);
}
//If there is no input from the player, we're done here and can leave
if (playerInput == Vector3.zero)
{
return;
}
//Use the "Quaternion" class to determine the rotation we need to face the direction we want to go
Quaternion newRotation = Quaternion.LookRotation(playerInput);
//If we need to turn and face a new direction, use the RotateTowards() method to turn quickly, but not
//instantly (which looks better)
if (rigidBody.rotation != newRotation)
{
rigidBody.rotation = Quaternion.RotateTowards(rigidBody.rotation, newRotation, turnSpeed * Time.deltaTime);
}
if (canRun)
{
//We take our input, multiply it by our speed, and then multiply Time.deltaTime. We then
//add this amount to our current position to get the new desired position. NOTE: We "normalize"
//our input so that the player won't move faster going diagonolly. NOTE: multiplying the value
//with Time.deltaTime ensures that everyone has the same gameplay regardless of the speed of their
//computers or the physics settings of the game
Vector3 newPosition = transform.position + playerInput.normalized * movementSpeed * Time.deltaTime;
//Use the rigidbody to move to the new position. This is better than Transform.Translate since it means
//the player will mvoe with physics and force instead of just "teleporting" to the new spot
rigidBody.MovePosition(newPosition);
}
}
private Vector3 playerCom; // Reset center of mass so tank no flip over
private void Awake()
{
playerCom.Set(0.0f, 0.5f, 1.1f);
_Rigidbody = GetComponent <Rigidbody>();
_Rigidbody.centerOfMass = playerCom;
}
public static void SetTiledSpriteGeom(Vector3[] pos, Vector2[] uv, int offset, out Vector3 boundsCenter, out Vector3 boundsExtents, tk2dSpriteDefinition spriteDef, Vector3 scale, Vector2 dimensions, tk2dBaseSprite.Anchor anchor, float colliderOffsetZ, float colliderExtentZ)
{
boundsCenter = Vector3.zero;
boundsExtents = Vector3.zero;
int numTilesX = (int)Mathf.Ceil((dimensions.x * spriteDef.texelSize.x) / spriteDef.untrimmedBoundsData[1].x);
int numTilesY = (int)Mathf.Ceil((dimensions.y * spriteDef.texelSize.y) / spriteDef.untrimmedBoundsData[1].y);
Vector2 totalMeshSize = new Vector2(dimensions.x * spriteDef.texelSize.x * scale.x, dimensions.y * spriteDef.texelSize.y * scale.y);
Vector2 texelEpsilon = Vector2.Scale(spriteDef.texelSize, scale) * 0.1f;
// Anchor tweaks
Vector3 anchorOffset = Vector3.zero;
switch (anchor)
{
case tk2dBaseSprite.Anchor.LowerLeft:
case tk2dBaseSprite.Anchor.MiddleLeft:
case tk2dBaseSprite.Anchor.UpperLeft:
break;
case tk2dBaseSprite.Anchor.LowerCenter:
case tk2dBaseSprite.Anchor.MiddleCenter:
case tk2dBaseSprite.Anchor.UpperCenter:
anchorOffset.x = -(totalMeshSize.x / 2.0f); break;
case tk2dBaseSprite.Anchor.LowerRight:
case tk2dBaseSprite.Anchor.MiddleRight:
case tk2dBaseSprite.Anchor.UpperRight:
anchorOffset.x = -(totalMeshSize.x); break;
}
switch (anchor)
{
case tk2dBaseSprite.Anchor.LowerLeft:
case tk2dBaseSprite.Anchor.LowerCenter:
case tk2dBaseSprite.Anchor.LowerRight:
break;
case tk2dBaseSprite.Anchor.MiddleLeft:
case tk2dBaseSprite.Anchor.MiddleCenter:
case tk2dBaseSprite.Anchor.MiddleRight:
anchorOffset.y = -(totalMeshSize.y / 2.0f); break;
case tk2dBaseSprite.Anchor.UpperLeft:
case tk2dBaseSprite.Anchor.UpperCenter:
case tk2dBaseSprite.Anchor.UpperRight:
anchorOffset.y = -totalMeshSize.y; break;
}
Vector3 colliderAnchor = anchorOffset;
anchorOffset -= Vector3.Scale(spriteDef.positions[0], scale);
boundsCenter.Set(totalMeshSize.x * 0.5f + colliderAnchor.x, totalMeshSize.y * 0.5f + colliderAnchor.y, colliderOffsetZ);
boundsExtents.Set(totalMeshSize.x * 0.5f, totalMeshSize.y * 0.5f, colliderExtentZ);
int vert = 0;
Vector3 bounds = Vector3.Scale(spriteDef.untrimmedBoundsData[1], scale);
Vector3 baseOffset = Vector3.zero;
Vector3 p = baseOffset;
for (int y = 0; y < numTilesY; ++y)
{
p.x = baseOffset.x;
for (int x = 0; x < numTilesX; ++x)
{
float xClipFrac = 1;
float yClipFrac = 1;
if (Mathf.Abs(p.x + bounds.x) > Mathf.Abs(totalMeshSize.x) + texelEpsilon.x)
{
xClipFrac = ((totalMeshSize.x % bounds.x) / bounds.x);
}
if (Mathf.Abs(p.y + bounds.y) > Mathf.Abs(totalMeshSize.y) + texelEpsilon.y)
{
yClipFrac = ((totalMeshSize.y % bounds.y) / bounds.y);
}
Vector3 geomOffset = p + anchorOffset;
if (xClipFrac != 1 || yClipFrac != 1)
{
Vector2 fracBottomLeft = Vector2.zero;
Vector2 fracTopRight = new Vector2(xClipFrac, yClipFrac);
Vector3 bottomLeft = new Vector3(Mathf.Lerp(spriteDef.positions[0].x, spriteDef.positions[3].x, fracBottomLeft.x) * scale.x,
Mathf.Lerp(spriteDef.positions[0].y, spriteDef.positions[3].y, fracBottomLeft.y) * scale.y,
spriteDef.positions[0].z * scale.z);
Vector3 topRight = new Vector3(Mathf.Lerp(spriteDef.positions[0].x, spriteDef.positions[3].x, fracTopRight.x) * scale.x,
Mathf.Lerp(spriteDef.positions[0].y, spriteDef.positions[3].y, fracTopRight.y) * scale.y,
spriteDef.positions[0].z * scale.z);
pos[offset + vert + 0] = geomOffset + new Vector3(bottomLeft.x, bottomLeft.y, bottomLeft.z);
pos[offset + vert + 1] = geomOffset + new Vector3(topRight.x, bottomLeft.y, bottomLeft.z);
pos[offset + vert + 2] = geomOffset + new Vector3(bottomLeft.x, topRight.y, bottomLeft.z);
pos[offset + vert + 3] = geomOffset + new Vector3(topRight.x, topRight.y, bottomLeft.z);
// find the fraction of UV
// This can be done without a branch, but will end up with loads of unnecessary interpolations
if (spriteDef.flipped == tk2dSpriteDefinition.FlipMode.Tk2d)
{
Vector2 v0 = new Vector2(Mathf.Lerp(spriteDef.uvs[0].x, spriteDef.uvs[3].x, fracBottomLeft.y),
Mathf.Lerp(spriteDef.uvs[0].y, spriteDef.uvs[3].y, fracBottomLeft.x));
Vector2 v1 = new Vector2(Mathf.Lerp(spriteDef.uvs[0].x, spriteDef.uvs[3].x, fracTopRight.y),
Mathf.Lerp(spriteDef.uvs[0].y, spriteDef.uvs[3].y, fracTopRight.x));
uv[offset + vert + 0] = new Vector2(v0.x, v0.y);
uv[offset + vert + 1] = new Vector2(v0.x, v1.y);
uv[offset + vert + 2] = new Vector2(v1.x, v0.y);
uv[offset + vert + 3] = new Vector2(v1.x, v1.y);
}
else if (spriteDef.flipped == tk2dSpriteDefinition.FlipMode.TPackerCW)
{
Vector2 v0 = new Vector2(Mathf.Lerp(spriteDef.uvs[0].x, spriteDef.uvs[3].x, fracBottomLeft.y),
Mathf.Lerp(spriteDef.uvs[0].y, spriteDef.uvs[3].y, fracBottomLeft.x));
Vector2 v1 = new Vector2(Mathf.Lerp(spriteDef.uvs[0].x, spriteDef.uvs[3].x, fracTopRight.y),
Mathf.Lerp(spriteDef.uvs[0].y, spriteDef.uvs[3].y, fracTopRight.x));
uv[offset + vert + 0] = new Vector2(v0.x, v0.y);
uv[offset + vert + 2] = new Vector2(v1.x, v0.y);
uv[offset + vert + 1] = new Vector2(v0.x, v1.y);
uv[offset + vert + 3] = new Vector2(v1.x, v1.y);
}
else
{
Vector2 v0 = new Vector2(Mathf.Lerp(spriteDef.uvs[0].x, spriteDef.uvs[3].x, fracBottomLeft.x),
Mathf.Lerp(spriteDef.uvs[0].y, spriteDef.uvs[3].y, fracBottomLeft.y));
Vector2 v1 = new Vector2(Mathf.Lerp(spriteDef.uvs[0].x, spriteDef.uvs[3].x, fracTopRight.x),
Mathf.Lerp(spriteDef.uvs[0].y, spriteDef.uvs[3].y, fracTopRight.y));
uv[offset + vert + 0] = new Vector2(v0.x, v0.y);
uv[offset + vert + 1] = new Vector2(v1.x, v0.y);
uv[offset + vert + 2] = new Vector2(v0.x, v1.y);
uv[offset + vert + 3] = new Vector2(v1.x, v1.y);
}
}
else
{
pos[offset + vert + 0] = geomOffset + Vector3.Scale(spriteDef.positions[0], scale);
pos[offset + vert + 1] = geomOffset + Vector3.Scale(spriteDef.positions[1], scale);
pos[offset + vert + 2] = geomOffset + Vector3.Scale(spriteDef.positions[2], scale);
pos[offset + vert + 3] = geomOffset + Vector3.Scale(spriteDef.positions[3], scale);
uv[offset + vert + 0] = spriteDef.uvs[0];
uv[offset + vert + 1] = spriteDef.uvs[1];
uv[offset + vert + 2] = spriteDef.uvs[2];
uv[offset + vert + 3] = spriteDef.uvs[3];
}
vert += 4;
p.x += bounds.x;
}
p.y += bounds.y;
}
}
private Vector3 GetCurrentDirection(Vector3 direction)
{
direction.Set(_horizontal.GetAxis(), 0, _vertical.GetAxis());
direction = direction.normalized;
return(direction);
}
public static void SetSlicedSpriteGeom(Vector3[] pos, Vector2[] uv, int offset, out Vector3 boundsCenter, out Vector3 boundsExtents, tk2dSpriteDefinition spriteDef, Vector3 scale, Vector2 dimensions, Vector2 borderBottomLeft, Vector2 borderTopRight, tk2dBaseSprite.Anchor anchor, float colliderOffsetZ, float colliderExtentZ)
{
boundsCenter = Vector3.zero;
boundsExtents = Vector3.zero;
if (spriteDef.positions.Length == 4)
{
float sx = spriteDef.texelSize.x;
float sy = spriteDef.texelSize.y;
Vector3[] srcVert = spriteDef.positions;
float dx = (srcVert[1].x - srcVert[0].x);
float dy = (srcVert[2].y - srcVert[0].y);
float borderTopPixels = borderTopRight.y * dy;
float borderBottomPixels = borderBottomLeft.y * dy;
float borderRightPixels = borderTopRight.x * dx;
float borderLeftPixels = borderBottomLeft.x * dx;
float dimXPixels = dimensions.x * sx;
float dimYPixels = dimensions.y * sy;
float anchorOffsetX = 0.0f;
float anchorOffsetY = 0.0f;
switch (anchor)
{
case tk2dBaseSprite.Anchor.LowerLeft:
case tk2dBaseSprite.Anchor.MiddleLeft:
case tk2dBaseSprite.Anchor.UpperLeft:
break;
case tk2dBaseSprite.Anchor.LowerCenter:
case tk2dBaseSprite.Anchor.MiddleCenter:
case tk2dBaseSprite.Anchor.UpperCenter:
anchorOffsetX = -(int)(dimensions.x / 2.0f); break;
case tk2dBaseSprite.Anchor.LowerRight:
case tk2dBaseSprite.Anchor.MiddleRight:
case tk2dBaseSprite.Anchor.UpperRight:
anchorOffsetX = -(int)(dimensions.x); break;
}
switch (anchor)
{
case tk2dBaseSprite.Anchor.LowerLeft:
case tk2dBaseSprite.Anchor.LowerCenter:
case tk2dBaseSprite.Anchor.LowerRight:
break;
case tk2dBaseSprite.Anchor.MiddleLeft:
case tk2dBaseSprite.Anchor.MiddleCenter:
case tk2dBaseSprite.Anchor.MiddleRight:
anchorOffsetY = -(int)(dimensions.y / 2.0f); break;
case tk2dBaseSprite.Anchor.UpperLeft:
case tk2dBaseSprite.Anchor.UpperCenter:
case tk2dBaseSprite.Anchor.UpperRight:
anchorOffsetY = -(int)dimensions.y; break;
}
// scale back to sprite coordinates
// do it after the cast above, as we're trying to align to pixel
anchorOffsetX *= sx;
anchorOffsetY *= sy;
boundsCenter.Set(scale.x * (dimXPixels * 0.5f + anchorOffsetX), scale.y * (dimYPixels * 0.5f + anchorOffsetY), colliderOffsetZ);
boundsExtents.Set(scale.x * (dimXPixels * 0.5f), scale.y * (dimYPixels * 0.5f), colliderExtentZ);
Vector2[] srcUv = spriteDef.uvs;
Vector2 duvx = srcUv[1] - srcUv[0];
Vector2 duvy = srcUv[2] - srcUv[0];
Vector3 origin = new Vector3(anchorOffsetX, anchorOffsetY, 0);
Vector3[] originPoints = new Vector3[4] {
origin,
origin + new Vector3(0, borderBottomPixels, 0),
origin + new Vector3(0, dimYPixels - borderTopPixels, 0),
origin + new Vector3(0, dimYPixels, 0),
};
Vector2[] originUvs = new Vector2[4] {
srcUv[0],
srcUv[0] + duvy * borderBottomLeft.y,
srcUv[0] + duvy * (1 - borderTopRight.y),
srcUv[0] + duvy,
};
for (int i = 0; i < 4; ++i)
{
pos[offset + i * 4 + 0] = originPoints[i];
pos[offset + i * 4 + 1] = originPoints[i] + new Vector3(borderLeftPixels, 0, 0);
pos[offset + i * 4 + 2] = originPoints[i] + new Vector3(dimXPixels - borderRightPixels, 0, 0);
pos[offset + i * 4 + 3] = originPoints[i] + new Vector3(dimXPixels, 0, 0);
for (int j = 0; j < 4; ++j)
{
pos[offset + i * 4 + j] = Vector3.Scale(pos[offset + i * 4 + j], scale);
}
uv[offset + i * 4 + 0] = originUvs[i];
uv[offset + i * 4 + 1] = originUvs[i] + duvx * borderBottomLeft.x;
uv[offset + i * 4 + 2] = originUvs[i] + duvx * (1 - borderTopRight.x);
uv[offset + i * 4 + 3] = originUvs[i] + duvx;
}
}
}
void Update()
{
tempPos.Set(transform.position.x, Mathf.Clamp(transform.position.y, 0, int.MaxValue), transform.position.z);
this.transform.position = tempPos;
}
public static void SetClippedSpriteGeom(Vector3[] pos, Vector2[] uv, int offset, out Vector3 boundsCenter, out Vector3 boundsExtents, tk2dSpriteDefinition spriteDef, Vector3 scale, Vector2 clipBottomLeft, Vector2 clipTopRight, float colliderOffsetZ, float colliderExtentZ)
{
boundsCenter = Vector3.zero;
boundsExtents = Vector3.zero;
if (spriteDef.positions.Length == 4)
{
// Transform clipped region from untrimmed -> trimmed region
Vector3 untrimmedMin = spriteDef.untrimmedBoundsData[0] - spriteDef.untrimmedBoundsData[1] * 0.5f;
Vector3 untrimmedMax = spriteDef.untrimmedBoundsData[0] + spriteDef.untrimmedBoundsData[1] * 0.5f;
// clipBottomLeft is the fraction to start from the bottom left (0,0 - full sprite)
// clipTopRight is the fraction to start from the top right (1,1 - full sprite)
float left = Mathf.Lerp(untrimmedMin.x, untrimmedMax.x, clipBottomLeft.x);
float right = Mathf.Lerp(untrimmedMin.x, untrimmedMax.x, clipTopRight.x);
float bottom = Mathf.Lerp(untrimmedMin.y, untrimmedMax.y, clipBottomLeft.y);
float top = Mathf.Lerp(untrimmedMin.y, untrimmedMax.y, clipTopRight.y);
Vector3 trimmedBounds = spriteDef.boundsData[1];
Vector3 trimmedOrigin = spriteDef.boundsData[0] - trimmedBounds * 0.5f;
float clipLeft = (left - trimmedOrigin.x) / trimmedBounds.x;
float clipRight = (right - trimmedOrigin.x) / trimmedBounds.x;
float clipBottom = (bottom - trimmedOrigin.y) / trimmedBounds.y;
float clipTop = (top - trimmedOrigin.y) / trimmedBounds.y;
// The fractional clip region relative to the trimmed region
Vector2 fracBottomLeft = new Vector2(Mathf.Clamp01(clipLeft), Mathf.Clamp01(clipBottom));
Vector2 fracTopRight = new Vector2(Mathf.Clamp01(clipRight), Mathf.Clamp01(clipTop));
// Default quad has index 0 = bottomLeft, index 3 = topRight
Vector3 c0 = spriteDef.positions[0];
Vector3 c1 = spriteDef.positions[3];
// find the fraction of positions, but fold in the scale multiply as well
Vector3 bottomLeft = new Vector3(Mathf.Lerp(c0.x, c1.x, fracBottomLeft.x) * scale.x,
Mathf.Lerp(c0.y, c1.y, fracBottomLeft.y) * scale.y,
c0.z * scale.z);
Vector3 topRight = new Vector3(Mathf.Lerp(c0.x, c1.x, fracTopRight.x) * scale.x,
Mathf.Lerp(c0.y, c1.y, fracTopRight.y) * scale.y,
c0.z * scale.z);
boundsCenter.Set(bottomLeft.x + (topRight.x - bottomLeft.x) * 0.5f, bottomLeft.y + (topRight.y - bottomLeft.y) * 0.5f, colliderOffsetZ);
boundsExtents.Set((topRight.x - bottomLeft.x) * 0.5f, (topRight.y - bottomLeft.y) * 0.5f, colliderExtentZ);
// The z component only needs to be consistent
pos[offset + 0] = new Vector3(bottomLeft.x, bottomLeft.y, bottomLeft.z);
pos[offset + 1] = new Vector3(topRight.x, bottomLeft.y, bottomLeft.z);
pos[offset + 2] = new Vector3(bottomLeft.x, topRight.y, bottomLeft.z);
pos[offset + 3] = new Vector3(topRight.x, topRight.y, bottomLeft.z);
// find the fraction of UV
// This can be done without a branch, but will end up with loads of unnecessary interpolations
if (spriteDef.flipped == tk2dSpriteDefinition.FlipMode.Tk2d)
{
Vector2 v0 = new Vector2(Mathf.Lerp(spriteDef.uvs[0].x, spriteDef.uvs[3].x, fracBottomLeft.y),
Mathf.Lerp(spriteDef.uvs[0].y, spriteDef.uvs[3].y, fracBottomLeft.x));
Vector2 v1 = new Vector2(Mathf.Lerp(spriteDef.uvs[0].x, spriteDef.uvs[3].x, fracTopRight.y),
Mathf.Lerp(spriteDef.uvs[0].y, spriteDef.uvs[3].y, fracTopRight.x));
uv[offset + 0] = new Vector2(v0.x, v0.y);
uv[offset + 1] = new Vector2(v0.x, v1.y);
uv[offset + 2] = new Vector2(v1.x, v0.y);
uv[offset + 3] = new Vector2(v1.x, v1.y);
}
else if (spriteDef.flipped == tk2dSpriteDefinition.FlipMode.TPackerCW)
{
Vector2 v0 = new Vector2(Mathf.Lerp(spriteDef.uvs[0].x, spriteDef.uvs[3].x, fracBottomLeft.y),
Mathf.Lerp(spriteDef.uvs[0].y, spriteDef.uvs[3].y, fracBottomLeft.x));
Vector2 v1 = new Vector2(Mathf.Lerp(spriteDef.uvs[0].x, spriteDef.uvs[3].x, fracTopRight.y),
Mathf.Lerp(spriteDef.uvs[0].y, spriteDef.uvs[3].y, fracTopRight.x));
uv[offset + 0] = new Vector2(v0.x, v0.y);
uv[offset + 2] = new Vector2(v1.x, v0.y);
uv[offset + 1] = new Vector2(v0.x, v1.y);
uv[offset + 3] = new Vector2(v1.x, v1.y);
}
else
{
Vector2 v0 = new Vector2(Mathf.Lerp(spriteDef.uvs[0].x, spriteDef.uvs[3].x, fracBottomLeft.x),
Mathf.Lerp(spriteDef.uvs[0].y, spriteDef.uvs[3].y, fracBottomLeft.y));
Vector2 v1 = new Vector2(Mathf.Lerp(spriteDef.uvs[0].x, spriteDef.uvs[3].x, fracTopRight.x),
Mathf.Lerp(spriteDef.uvs[0].y, spriteDef.uvs[3].y, fracTopRight.y));
uv[offset + 0] = new Vector2(v0.x, v0.y);
uv[offset + 1] = new Vector2(v1.x, v0.y);
uv[offset + 2] = new Vector2(v0.x, v1.y);
uv[offset + 3] = new Vector2(v1.x, v1.y);
}
}
}
// Setting position
#region SetPosition
public static void SetPosition(this Transform transform, float x, float y, float z)
{
vector3.Set(x, y, z);
transform.position = vector3;
}
//-------------------------------------------------
private void UnFreeze()
{
frozen = false;
frozenHandWorldPos.Set(0.0f, 0.0f, 0.0f);
}
private void OnEnable()
{
loss_pnl.SetActive(false);
pos = new Vector3(-350f, 150f, 1);
level = PlayerPrefs.GetInt("levels");
candegeri = PlayerPrefs.GetInt("canlar");
if (candegeri == 0)
{
loss_pnl.SetActive(true);
}
sorular = gameObject.AddComponent <word>();
if (PlayerPrefs.GetInt("lang") == 1)
{
sorular.sorular = sorular.ing_sorular;
sorular.cevaplar = sorular.ing_cevaplar;
sorular.ekran = sorular.ing_ekran;
}
text_soru.text = sorular.sorular[level];
if (PlayerPrefs.GetInt("bombaturu") == 0)
{
for (int i = 0; i < harfler.Length; ++i)
{
harfler[i].GetComponent <Image>().sprite = Resources.Load <Sprite>($"Normal/{harfler[i].name}");
harfler[i].transform.localScale = new Vector3(1.3f, 1.3f, 1);
bosluky = 130f;
}
animation1 = animation5;
}
if (PlayerPrefs.GetInt("bombaturu") == 1)
{
for (int i = 0; i < harfler.Length; ++i)
{
harfler[i].GetComponent <Image>().sprite = Resources.Load <Sprite>($"Dinamit/{harfler[i].name}");
harfler[i].transform.localScale = new Vector3(1f, 2f, 1);
bosluky = 160f;
}
animation1 = animation2;
}
if (PlayerPrefs.GetInt("bombaturu") == 2)
{
for (int i = 0; i < harfler.Length; ++i)
{
harfler[i].GetComponent <Image>().sprite = Resources.Load <Sprite>($"ElBombasi/{harfler[i].name}");
harfler[i].transform.localScale = new Vector3(1.3f, 1.3f, 1);
}
animation1 = animation3;
}
if (PlayerPrefs.GetInt("bombaturu") == 3)
{
for (int i = 0; i < harfler.Length; ++i)
{
harfler[i].GetComponent <Image>().sprite = Resources.Load <Sprite>($"Fuze/{harfler[i].name}");
harfler[i].transform.localScale = new Vector3(1, 2, 1);
bosluky = 160f;
}
animation1 = animation4;
}
foreach (GameObject k in harfler)
{
k.SetActive(false);
}
for (int i = 0; i < sorular.ekran[level].Length; ++i)
{
for (int j = 0; j < harfler.Length; ++j)
{
if (sorular.ekran[level][i].ToString() == harfler[j].name)
{
if (ekranHarfler.Contains(harfler[j]))
{
GameObject clonedObject = (GameObject)Instantiate(harfler[j], transform.position, transform.rotation);
clonedObject.transform.SetParent(harfler[0].transform.parent);
if (PlayerPrefs.GetInt("bombaturu") == 0)
{
clonedObject.transform.localScale = new Vector3(1.3f, 1.3f, 1f);
}
else if (PlayerPrefs.GetInt("bombaturu") == 1)
{
clonedObject.transform.localScale = new Vector3(1f, 2f, 1);
}
else if (PlayerPrefs.GetInt("bombaturu") == 2)
{
clonedObject.transform.localScale = new Vector3(1.3f, 1.3f, 1);
}
else
{
clonedObject.transform.localScale = new Vector3(1f, 2f, 0.03f);
}
ekranHarfler.Add(clonedObject);
clonedObjects.Add(clonedObject);
continue;
}
ekranHarfler.Add(harfler[j]);
}
}
}
int q = 0;
int as2 = 0;
for (int i = 0; i < ekranHarfler.Count; ++i)
{
ekranHarfler[i].SetActive(true);
ekranHarfler[i].transform.localPosition = pos;
pos.Set(pos.x + boslukx, pos.y, pos.z);
if (i > 5 & i < 12)
{
pos.Set(-350f + q * boslukx, -1 * bosluky + 150f, pos.z);
q++;
}
else if (i > 12)
{
pos.Set(-350f + as2 * boslukx, -2 * bosluky + 150f, pos.z);
as2++;
}
}
foreach (GameObject x in ekranHarfler)
{
if (x.name.Contains("(Clone)"))
{
x.name = x.name.Replace("(Clone)", "");
x.name = x.name.ToUpper();
}
sonHarfler += x.name;
}
loss_pnl.GetComponent <Transform>().SetAsLastSibling();
}
//
public Vector3 TilePosToWorldPos(Point2 Pos)
{
Vector3 vPos = new Vector3();
vPos.Set((Pos.x+0.5f) * TILE_SIZE, 0, (Pos.y+0.5f)* TILE_SIZE);
return vPos;
}
