void resetDominosPositions()
{
if (this.allDominos.Count > 0)
{
foreach (GameObject domino in this.allDominos)
{
if (this.dominosRunning)
{
domino.rigidbody.isKinematic = true;
Domino dominoAttributes = domino.GetComponent <Domino>();
dominoAttributes.hasCollided = false;
domino.transform.position = dominoAttributes.originalPosition;
domino.transform.rotation = dominoAttributes.originalRotation;
}
else
{
domino.rigidbody.isKinematic = false;
}
}
LevelPropertiesScript.sharedInstance().dominosFalling = false;
}
BackgroundMusic bm = this.GetComponent <BackgroundMusic>();
bm.playGameMusic();
}
void updateFloorSize()
{
GameObject floor = LevelPropertiesScript.sharedInstance().floor;
Vector3 position = this.transform.position;
Vector3 floorScale = floor.transform.localScale;
float offset = 75;
float ratio = 1.0f;
if ((position.x - offset) < ((floor.transform.position.x - floorScale.x * 0.5f) * ratio))
{
floorScale.x = (((floor.transform.position.x - (position.x - offset)) * 2.0f) / ratio) + 1.0f;
}
if ((position.x + offset) > ((floor.transform.position.x + floorScale.x * 0.5f) * ratio))
{
floorScale.x = ((((position.x + offset) - floor.transform.position.x) * 2.0f) / ratio) + 1.0f;
}
if ((position.z - offset) < ((floor.transform.position.z - floorScale.z * 0.5f) * ratio))
{
floorScale.z = (((floor.transform.position.z - (position.z - offset)) * 2.0f) / ratio) + 1.0f;
}
if ((position.z + offset) > ((floor.transform.position.z + floorScale.z * 0.5f) * ratio))
{
floorScale.z = ((((position.z + offset) - floor.transform.position.z) * 2.0f) / ratio) + 1.0f;
}
floor.transform.localScale = floorScale;
}
public void instantiatePath()
{
GameObject floor = LevelPropertiesScript.sharedInstance().floor;
float floorYPos = floor.transform.position.y + floor.transform.localScale.y * 0.5f + +0.01f;
if (this.checkpoints.Count > 0)
{
GameObject circleGO;
Circle circle;
Vector3 prevPos = (Vector3)this.checkpoints[0];
for (int i = 1; i < this.checkpoints.Count; i++)
{
Vector3 nextPos = (Vector3)this.checkpoints[i];
Vector3 pos = new Vector3((nextPos.x + prevPos.x) / 2.0f, floorYPos, (nextPos.z + prevPos.z) / 2.0f);
Quaternion lookRotation = Quaternion.LookRotation(nextPos - prevPos);
Quaternion rotation = Quaternion.Euler(0.0f, lookRotation.eulerAngles.y, 0.0f);
GameObject pathPlane = ((Transform)Instantiate(this.pathPrefab, pos, rotation)).gameObject;
pathPlane.transform.localScale = new Vector3(0.1f, 1.0f, (Vector3.Distance(nextPos, prevPos) / 10.0f));
circleGO = new GameObject();
circle = circleGO.AddComponent <Circle>();
circle.SetRadius(0.5f);
circleGO.transform.position = new Vector3(prevPos.x, floorYPos, prevPos.z);
prevPos = nextPos;
}
circleGO = new GameObject();
circle = circleGO.AddComponent <Circle>();
circle.SetRadius(0.5f);
circleGO.transform.position = new Vector3(prevPos.x, 0.001f, prevPos.z);
}
}
public int minRequiredDominos()
{
int nDominos = 0;
LevelPropertiesScript properties = LevelPropertiesScript.sharedInstance();
ArrayList placesToGo = new ArrayList(properties.powerups.Count);
foreach (GameObject powerup in properties.powerups)
{
placesToGo.Add(powerup.transform.position);
}
Vector3 nextPos = MominoScript.sharedInstance().gameObject.transform.position;
while (placesToGo.Count > 0)
{
float minDistance = float.MaxValue;
Vector3 closestPosition = nextPos;
foreach (Vector3 position in placesToGo)
{
float dist = Vector3.SqrMagnitude(position - nextPos);
if (dist < minDistance)
{
closestPosition = position;
minDistance = dist;
}
}
nextPos = closestPosition;
placesToGo.Remove(closestPosition);
nDominos += (int)(Mathf.Sqrt(minDistance) / CreateDominos.dominosSeparation);
}
return(nDominos);
}
public void setState(PowerupState theState)
{
Color color;
switch (theState)
{
case PowerupState.kPowerupStateCorrect:
LevelPropertiesScript.sharedInstance().nPowerupsExplode++;
color = Color.green;
break;
case PowerupState.kPowerupStateWaiting:
LevelPropertiesScript.sharedInstance().nPowerupsGot++;
color = Color.yellow;
audio.clip = this.audioClip;
float volume = 2.0f;
audio.volume = volume;
audio.Play();
break;
case PowerupState.kPowerupStateDefault:
default:
color = Color.blue;
break;
}
this.powerupLight.color = color;
this.powerupSphere.renderer.material.color = new Color(color.r, color.g, color.b, 0.5f);
this.state = theState;
}
// Use this for initialization
void Start()
{
GameObject floor = LevelPropertiesScript.sharedInstance().floor;
this.mouseLastDominoPosition = new Vector3(0, (floor.transform.position.y + floor.transform.localScale.y * 0.5f), 0);
this.mouseLastDominoAngle = Quaternion.identity;
}
bool positionIsValid(Vector3 position)
{
GameObject floor = LevelPropertiesScript.sharedInstance().floor;
Vector3 vToCenter = (position - floor.transform.position);
float distSqr = (vToCenter.x * vToCenter.x + vToCenter.z * vToCenter.z);
return(distSqr < (this.maxDistanceFromCenter * this.maxDistanceFromCenter));
}
public void applyCurrentColor()
{
foreach (Transform dominoTransf in this.transform)
{
Domino domino = dominoTransf.gameObject.GetComponent <Domino>();
domino.setColor(LevelPropertiesScript.sharedInstance().currentColor());
}
}
void OnDestroy()
{
if ((this.steps != null) && (LevelPropertiesScript.sharedInstance() != null))
{
foreach (GameObject step in this.steps)
{
LevelPropertiesScript.sharedInstance().removeStep(step);
}
}
}
public void reset()
{
foreach (GameObject domino in this.allDominos)
{
Destroy(domino);
}
this.allDominos = new ArrayList();
LevelPropertiesScript.sharedInstance().nDominosCombo = 0;
LevelPropertiesScript.sharedInstance().nDominos = 0;
}
void OnCollisionEnter(Collision collision)
{
float collisionMagnitude = collision.relativeVelocity.magnitude;
if (collisionMagnitude > thresholdVelocity)
{
Domino otherDomino = null;
ContactPoint [] contactPoints = collision.contacts;
bool foundOther = false;
int i = 0;
while (!foundOther && i < contactPoints.Length)
{
ContactPoint contactPoint = contactPoints[i];
GameObject firstGameObject = contactPoint.thisCollider.gameObject;
GameObject secondGameObject = contactPoint.otherCollider.gameObject;
foundOther = ((firstGameObject == this.gameObject) && (secondGameObject.tag == "Domino"));
if (foundOther)
{
otherDomino = secondGameObject.GetComponent <Domino>();
}
i++;
}
if (foundOther)
{
if (!otherDomino.hasCollided)
{
otherDomino.hasCollided = true;
LevelPropertiesScript.sharedInstance().nDominosCombo += 1;
audio.clip = this.audioFile;
float volume = Mathf.InverseLerp(thresholdVelocity, thresholdVelocity * 4, collisionMagnitude);
audio.volume = volume;
audio.Play();
if (this.followCamera != null)
{
CollisionFollowCameraScript followCameraScript = this.followCamera.GetComponent <CollisionFollowCameraScript>();
Vector3 position = this.followCameraPosition();
followCameraScript.positionTo = position;
followCameraScript.rotationTo = Quaternion.LookRotation(contactPoints[0].point - position);
}
LevelPropertiesScript.sharedInstance().updateFallingPosition(contactPoints[0].point);
Transform explosionTransform = (Transform)Instantiate(this.collisionParticleSystem, contactPoints[0].point, this.transform.rotation);
this.explosionParticleSystem = explosionTransform.gameObject;
ParticleSystem ps = this.explosionParticleSystem.particleSystem;
ps.startColor = this.gameObject.renderer.material.color;
}
}
}
}
void Awake()
{
LevelPropertiesScript.singleton = this;
this.rnd = new System.Random();
this.floor.transform.localScale = this.defaultFloorSize();
if (GameProperties.gameType == GameType.kGameTypeMominoTargets)
{
this.nPowerups = 3 + (GameProperties.level * 2);
this.instantiatePowerups();
}
}
// Use this for initialization
void Start()
{
this.currFloor = LevelPropertiesScript.sharedInstance().floor;
this.allCollidedFloors = new HashSet <GameObject>();
if (GameProperties.IsTactil())
{
this.moveJoystick = this.joystick.GetComponent <Joystick>();
}
else
{
Destroy(this.joystick.gameObject);
}
}
void addStep(GameObject step, float scaleY, Vector3 position)
{
if (this.needsBuild)
{
Vector3 scale = step.transform.localScale;
scale.y = scaleY;
step.transform.localScale = scale;
position.y = (step.transform.localScale.y * 0.5f);
step.transform.localPosition = position;
}
this.steps.Add(step);
LevelPropertiesScript.sharedInstance().addStep(step);
}
public bool positionIsOnGUI(Vector3 screenPos)
{
bool found = false;
if (GameProperties.IsTactil())
{
found = (new Rect((Screen.width - 260), (Screen.height - 150), 130, 75)).Contains(screenPos);
}
else if (LevelPropertiesScript.sharedInstance().nPowerupsGot >= LevelPropertiesScript.sharedInstance().nPowerups)
{
found = (new Rect((Screen.width - 250), 50, 150, 50)).Contains(screenPos);
}
return(found);
}
void OnGUI()
{
if (this.buttonsStyle == null)
{
this.buttonsStyle = new GUIStyle(GUI.skin.button);
if (GameProperties.IsTactil())
{
this.buttonsStyle.fontSize = 18;
}
}
if (GameProperties.IsTactil())
{
if ((this.allDominos.Count > 0) && (GUI.Button(new Rect((Screen.width - 260), (Screen.height - 150), 130, 75), "Action", this.buttonsStyle)))
{
LevelPropertiesScript.sharedInstance().nDominosCombo = 0;
if (this.dominosRunning)
{
this.resetDominosPositions();
LevelPropertiesScript.sharedInstance().setMainCamera();
}
else
{
this.pushDominos();
LevelPropertiesScript.sharedInstance().setFollowCamera();
}
this.dominosRunning = !this.dominosRunning;
}
}
else if (!LevelPropertiesScript.sharedInstance().dominosFalling&& (LevelPropertiesScript.sharedInstance().nPowerupsGot >= LevelPropertiesScript.sharedInstance().nPowerups))
{
if (GUI.Button(new Rect((Screen.width - 250), 50, 150, 50), "Action"))
{
LevelPropertiesScript.sharedInstance().nDominosCombo = 0;
if (this.dominosRunning)
{
this.resetDominosPositions();
LevelPropertiesScript.sharedInstance().setMainCamera();
}
else
{
this.pushDominos();
LevelPropertiesScript.sharedInstance().setFollowCamera();
}
this.dominosRunning = !this.dominosRunning;
}
}
}
public void reset()
{
this.allCollidedFloors = new HashSet <GameObject>();
this.currFloor = LevelPropertiesScript.sharedInstance().floor;
if (GameProperties.gameType == GameType.kGameTypeMominoTargets)
{
Vector3 firstPowerupPos = (Vector3)ShortestPathScript.sharedInstance().checkpoints[0];
Vector3 secondPowerupPos = (Vector3)ShortestPathScript.sharedInstance().checkpoints[1];
Vector3 firstDirection = (secondPowerupPos - firstPowerupPos);
this.transform.position = (firstPowerupPos - firstDirection.normalized);
this.transform.rotation = Quaternion.LookRotation(firstDirection);
}
else
{
this.transform.position = new Vector3(0, this.transform.localScale.y * 0.5f, 0);
this.transform.rotation = Quaternion.Euler(0, 0, 0);
}
}
void pushDominos()
{
if (this.allDominos.Count > 0)
{
foreach (GameObject domino in this.allDominos)
{
domino.rigidbody.isKinematic = false;
}
GameObject firstDomino = (GameObject)this.allDominos[0];
Domino dominoAttributes = firstDomino.GetComponent <Domino>();
dominoAttributes.hasCollided = true;
LevelPropertiesScript.sharedInstance().nDominosCombo = 1;
firstDomino.rigidbody.AddForce(firstDomino.transform.forward * 100);
LevelPropertiesScript.sharedInstance().dominosFalling = true;
}
BackgroundMusic bm = this.GetComponent <BackgroundMusic>();
bm.playGameFastMusic();
}
public Vector3 worldCoordinatesFromScreenCoordinates(Vector3 screenCoordinates, Vector3 floorPosition)
{
Ray ray = Camera.main.ScreenPointToRay(screenCoordinates);
Vector3 position = new Vector3(0.0f, 0.0f, 0.0f);
GameObject collidingStep = LevelPropertiesScript.sharedInstance().rayCastWithStairSteps(ray, out position);
if (collidingStep == null)
{
Plane plane = new Plane(Vector3.up, floorPosition);
float distance;
if (plane.Raycast(ray, out distance))
{
position = ray.GetPoint(distance);
return(position);
}
}
return(position);
}
void updateState()
{
if (this.state == PowerupState.kPowerupStateDefault)
{
MominoScript momino = MominoScript.sharedInstance();
GameObject lastDomino = ((momino == null) ? null : CreateDominos.sharedInstance().lastDomino);
if (lastDomino != null)
{
if (Vector3.SqrMagnitude(this.transform.position - lastDomino.transform.position) < (this.haloMinSize * this.haloMinSize))
{
this.setState(PowerupState.kPowerupStateWaiting);
}
}
}
else if ((this.state == PowerupState.kPowerupStateWaiting) && LevelPropertiesScript.sharedInstance().dominosFalling)
{
if (Vector3.SqrMagnitude(this.transform.position - LevelPropertiesScript.sharedInstance().dominosFallingPosition) < (this.haloMinSize * this.haloMinSize))
{
this.setState(PowerupState.kPowerupStateCorrect);
}
}
}
public void updateCurrentFloor()
{
if (this.allCollidedFloors.Count > 0)
{
GameObject topFloor = null;
float topY = float.MinValue;
foreach (GameObject floor in this.allCollidedFloors)
{
float currY = floor.transform.position.y + floor.transform.localScale.y * 0.5f;
if (currY > topY)
{
topFloor = floor;
topY = currY;
}
this.currFloor = topFloor;
}
}
else
{
this.currFloor = LevelPropertiesScript.sharedInstance().floor;
}
}
// Update is called once per frame
void Update()
{
if (GameProperties.paused || LevelPropertiesScript.sharedInstance().wasPaused())
{
return;
}
if (Input.GetButtonDown("Jump"))
{
LevelPropertiesScript.sharedInstance().nDominosCombo = 0;
LevelPropertiesScript levelProps = this.GetComponent <LevelPropertiesScript>();
if (this.dominosRunning)
{
this.resetDominosPositions();
levelProps.setMainCamera();
}
else
{
this.pushDominos();
levelProps.setFollowCamera();
}
this.dominosRunning = !this.dominosRunning;
}
}
public GameObject instantiateDomino(ref Vector3 position, Quaternion rotation)
{
int nMaxDominos = LevelPropertiesScript.sharedInstance().maxNDominos;
if ((nMaxDominos >= 0) && (LevelPropertiesScript.sharedInstance().nDominos >= nMaxDominos))
{
return(null);
}
// if (!this.positionIsValidToInstantiateDomino(position))
// {
// return null;
// }
position.y += this.dominoPrefab.transform.localScale.y * 0.5f;
Rigidbody domino = (Rigidbody)Instantiate(this.dominoPrefab, position, rotation);
domino.isKinematic = true;
Domino dominoAttributes = domino.GetComponent <Domino>();
dominoAttributes.setColor(LevelPropertiesScript.sharedInstance().currentColor());
dominoAttributes.originalPosition = position;
dominoAttributes.originalRotation = rotation;
dominoAttributes.originalForwardVector = domino.transform.forward;
if (this.followDominosCollisionsCamera != null)
{
dominoAttributes.followCamera = this.followDominosCollisionsCamera;
}
this.allDominos.Add(domino.gameObject);
this.lastDomino = domino.gameObject;
LevelPropertiesScript.sharedInstance().nDominos++;
return(domino.gameObject);
}
public void calculateCheckpoints()
{
LevelPropertiesScript properties = LevelPropertiesScript.sharedInstance();
this.checkpoints = new ArrayList(properties.powerups.Count);
ArrayList placesToGo = new ArrayList(properties.powerups.Count);
foreach (GameObject powerup in properties.powerups)
{
placesToGo.Add(powerup.transform.position);
}
Vector3 nextPos = (Vector3)placesToGo[0];
this.checkpoints.Add(nextPos);
placesToGo.RemoveAt(0);
while (placesToGo.Count > 0)
{
float minDistance = float.MaxValue;
Vector3 closestPosition = nextPos;
foreach (Vector3 position in placesToGo)
{
float dist = Vector3.SqrMagnitude(position - nextPos);
if (dist < minDistance)
{
closestPosition = position;
minDistance = dist;
}
}
nextPos = closestPosition;
this.checkpoints.Add(closestPosition);
placesToGo.Remove(closestPosition);
}
}
public void removeDomino(GameObject domino)
{
this.allDominos.Remove(domino);
Destroy(domino);
LevelPropertiesScript.sharedInstance().nDominos--;
}
void OnGUI()
{
int nButtons = this.prefabs.Length;
float currY = (Screen.height - nButtons * this.buttonsHeight - (nButtons - 1) * this.buttonsSep) / 2;
float startX = (Screen.width - this.buttonsWidth - this.buttonsRightOffset);
if (GameProperties.gameType != GameType.kGameTypeMominoTargets)
{
for (int i = 0; i < nButtons; i++)
{
if (GUI.Button(new Rect(startX, currY, this.buttonsWidth, this.buttonsHeight), this.prefabs[i].name))
{
Instantiate(this.mouseClick);
LevelPropertiesScript.sharedInstance().setWasPaused();
GameProperties.editMode = EditMode.kEditModePrefabs;
this.editingPrefab = (GameObject)Instantiate(this.prefabs[i], new Vector3(0, 0, 0), Quaternion.identity);
if (this.editingPrefab.tag == "DominosCollection")
{
MakeDominos makeDominos = this.editingPrefab.GetComponent <MakeDominos>();
makeDominos.applyCurrentColor();
}
this.rotationX = 0.0f;
this.instances.Add(this.editingPrefab);
}
currY += (this.buttonsSep + this.buttonsHeight);
}
if (GUI.Button(new Rect(startX, 15.0f, this.buttonsWidth, this.buttonsHeight), ("Color (x): " + LevelPropertiesScript.sharedInstance().currentColorName())))
{
Instantiate(this.mouseClick);
LevelPropertiesScript.sharedInstance().setWasPaused();
LevelPropertiesScript.sharedInstance().changeCurrentColor();
}
if (GameProperties.gameType != GameType.kGameTypeGod)
{
bool shoot = MominoScript.sharedInstance().shoot;
if (GUI.Button(new Rect(startX - this.buttonsWidth - this.buttonsRightOffset, 15.0f, this.buttonsWidth, this.buttonsHeight), (shoot ? "Stop (q)" : "Continue (q)")))
{
Instantiate(this.mouseClick);
MominoScript.sharedInstance().shoot = !shoot;
}
}
if (GUI.Button(new Rect(startX - (this.buttonsWidth + this.buttonsRightOffset) * 2, 15.0f, this.buttonsWidth, this.buttonsHeight), "Camera (c)"))
{
Instantiate(this.mouseClick);
LevelPropertiesScript.sharedInstance().setWasPaused();
LevelPropertiesScript.sharedInstance().changeCamera();
}
}
else
{
if (!GameProperties.IsTactil())
{
if (GUI.Button(new Rect(startX, 15.0f, this.buttonsWidth, this.buttonsHeight), ("Color (x): " + LevelPropertiesScript.sharedInstance().currentColorName())))
{
Instantiate(this.mouseClick);
LevelPropertiesScript.sharedInstance().setWasPaused();
LevelPropertiesScript.sharedInstance().changeCurrentColor();
}
if (GameProperties.gameType != GameType.kGameTypeGod)
{
bool shoot = MominoScript.sharedInstance().shoot;
if (GUI.Button(new Rect(startX - this.buttonsWidth - this.buttonsRightOffset, 15.0f, this.buttonsWidth, this.buttonsHeight), (shoot ? "Stop (q)" : "Continue (q)")))
{
Instantiate(this.mouseClick);
MominoScript.sharedInstance().shoot = !shoot;
}
}
}
}
Event e = Event.current;
this.isPressingRotateKey = (e.alt || e.command || e.control);
}
// Update is called once per frame
void Update()
{
if (GameProperties.editMode == EditMode.kEditModePrefabs)
{
if (this.editingPrefab != null)
{
if (this.isPressingRotateKey)
{
this.rotationX -= Input.GetAxis("Mouse X") * this.rotationXSpeed * 0.02f;
this.editingPrefab.transform.rotation = Quaternion.Euler(0.0f, this.rotationX, 0.0f);
}
else
{
Vector3 screenCoordinates = Input.mousePosition;
GameObject floor = LevelPropertiesScript.sharedInstance().floor;
Vector3 position = this.worldCoordinatesFromScreenCoordinates(screenCoordinates, (floor.transform.position + Vector3.up * floor.transform.localScale.y * 0.5f));
this.editingPrefab.transform.position = position;
}
if (Input.GetMouseButtonDown(0))
{
if (this.editingPrefab.tag == "DominosCollection")
{
MakeDominos makeDominos = this.editingPrefab.GetComponent <MakeDominos>();
makeDominos.saveStateAsOriginal();
}
if (MominoScript.sharedInstance() != null)
{
MominoScript.sharedInstance().updateCurrentFloor();
}
this.editingPrefab = null;
this.timeSinceEditing = 0.0;
this.hasToGoBackToEditDominos = true;
}
}
if (this.hasToGoBackToEditDominos)
{
this.timeSinceEditing += Time.deltaTime;
if (timeSinceEditing > 0.25)
{
GameProperties.editMode = EditMode.kEditModeDominos;
this.hasToGoBackToEditDominos = false;
}
}
if (Input.GetKeyDown(KeyCode.Escape))
{
if (this.editingPrefab != null)
{
this.instances.Remove(this.editingPrefab);
Destroy(this.editingPrefab);
this.editingPrefab = null;
GameProperties.editMode = EditMode.kEditModeDominos;
this.hasToGoBackToEditDominos = false;
}
}
}
if (GameProperties.gameType != GameType.kGameTypeMominoTargets)
{
if (Input.GetButtonDown("ChangeCamera"))
{
Instantiate(this.mouseClick);
LevelPropertiesScript.sharedInstance().changeCamera();
}
}
if (Input.GetButtonDown("ChangeColor"))
{
Instantiate(this.mouseClick);
LevelPropertiesScript.sharedInstance().changeCurrentColor();
}
}
// Update is called once per frame
void Update()
{
if (GameProperties.gameType == GameType.kGameTypeGod)
{
if ((GameProperties.editMode != EditMode.kEditModeDominos) || GameProperties.paused || LevelPropertiesScript.sharedInstance().wasPaused())
{
return;
}
if (Input.GetMouseButton(0) || (Input.GetMouseButtonUp(0)))
{
Vector3 screenCoordinates = Input.mousePosition;
if (CreateDominos.sharedInstance().positionIsOnGUI(screenCoordinates) || LevelPropertiesScript.sharedInstance().positionIsOnGUI(screenCoordinates) || EditModeScript.sharedInstance().positionIsOnGUI(screenCoordinates))
{
return;
}
GameObject floor = LevelPropertiesScript.sharedInstance().floor;
Vector3 floorPosition = floor.transform.position;
floorPosition.y = (floor.transform.position.y + floor.transform.localScale.y * 0.5f);
Vector3 position = CreateDominos.sharedInstance().worldCoordinatesFromScreenCoordinates(screenCoordinates, floorPosition);
if (!this.positionIsValid(position))
{
return;
}
if (Input.GetMouseButtonDown(0))
{
this.mouseLastDominoPosition = position;
this.mouseNDominosCurrentMotion = 0;
this.mouseLastDomino = null;
}
Vector3 diffVector = (position - this.mouseLastDominoPosition);
diffVector.y = 0.0f;
float distanceWithLastDominoSqr = diffVector.sqrMagnitude;
if (distanceWithLastDominoSqr >= (CreateDominos.dominosSeparation * CreateDominos.dominosSeparation))
{
float distanceWithLastDomino = Mathf.Sqrt(distanceWithLastDominoSqr);
Vector3 nextPosition = this.mouseLastDominoPosition;
Vector3 moveVector = (diffVector.normalized * CreateDominos.dominosSeparation);
this.mouseLastDominoAngle = Quaternion.LookRotation(diffVector);
this.mouseLastDominoAngle.x = 0.0f;
this.mouseLastDominoAngle.z = 0.0f;
int nDominos = (int)(distanceWithLastDomino / CreateDominos.dominosSeparation);
Quaternion rotation = this.mouseLastDominoAngle;
for (int i = 0; i < nDominos; i++)
{
if (i == 0)
{
if (this.mouseLastDomino != null)
{
Domino mouseLastDominoAttributes = this.mouseLastDomino.GetComponent <Domino>();
rotation = mouseLastDominoAttributes.originalRotation;
if (this.mouseNDominosCurrentMotion == 1)
{
rotation = this.mouseLastDominoAngle;
}
else
{
rotation = Quaternion.Lerp(rotation, this.mouseLastDominoAngle, 0.5f);
}
this.mouseLastDomino.transform.rotation = rotation;
mouseLastDominoAttributes.originalRotation = rotation;
}
}
nextPosition += moveVector;
Vector3 p = new Vector3(nextPosition.x, nextPosition.y, nextPosition.z);
float f = (0.5f + (0.5f * i / nDominos));
Quaternion nextRotation = Quaternion.Lerp(rotation, this.mouseLastDominoAngle, f);
GameObject domino = CreateDominos.sharedInstance().instantiateDomino(ref nextPosition, nextRotation);
nextPosition.x = p.x;
nextPosition.y = p.y;
nextPosition.z = p.z;
if (domino != null)
{
this.mouseNDominosCurrentMotion++;
this.mouseLastDomino = domino;
}
}
this.mouseLastDominoPosition = nextPosition;
}
if (Input.GetMouseButtonUp(0))
{
if (this.mouseNDominosCurrentMotion == 0)
{
Ray ray = Camera.main.ScreenPointToRay(screenCoordinates);
Vector3 pos;
GameObject selectedDomino = CreateDominos.rayCastWithDominos(ray, out pos);
if (selectedDomino != null)
{
CreateDominos.sharedInstance().removeDomino(selectedDomino);
}
else
{
CreateDominos.sharedInstance().instantiateDomino(ref position, this.mouseLastDominoAngle);
}
}
this.mouseNDominosCurrentMotion = 0;
this.mouseLastDomino = null;
}
}
}
}
void OnDestroy()
{
LevelPropertiesScript.singleton = null;
}
void OnDestroy()
{
LevelPropertiesScript.singleton = null;
}
void Awake()
{
LevelPropertiesScript.singleton = this;
this.rnd = new System.Random();
this.floor.transform.localScale = this.defaultFloorSize();
if (GameProperties.gameType == GameType.kGameTypeMominoTargets)
{
this.nPowerups = 3 + (GameProperties.level * 2);
this.instantiatePowerups();
}
}
