public override void Open()
{
HOTween.To(this.GetComponent <RectTransform>(), 0.3f, new TweenParms().Prop("anchoredPosition", new Vector2(0f, 100f)));
}
void Start()
{
HOTween.To(transform, ScaleTime, new TweenParms().Prop("localScale", ScaleSize).OnComplete(Shoot));
}
public void Show()
{
StopAnimations();
HOTween.To(canvasGroup, 0.1f, "alpha", 1f, false).Play();
HOTween.To(canvasGroup.transform, animDuration, "localScale", defaultScale, false, EaseType.EaseOutBack, 0).Play();
}
// Update is called once per frame
void Update()
{
//we make sure that we are not jumping
bool prisonerGrounded = (PossessionMaster.CurrentlyPossesing == null) ? false : PossessionMaster.CurrentlyPossesing.PrisonerAnimator.GetBool("OnGround");
//Entering into astral
if (Input.GetKeyUp(KeyCode.E) && !PossessionMaster.AstralForm && possMaster.CanSwap && prisonerGrounded)
{
StartCoroutine(possMaster.enterAstral());
}
//Swapping
if (Input.GetKeyUp(KeyCode.Q) && possMaster.CanSwap)
{
if (PossessionMaster.AstralForm && (possMaster.getInventory().Count >= 1))
{
StartCoroutine(possMaster.swap(possMaster.getInventory()[0]));
}
else if ((possMaster.getInventory().Count > 1) && prisonerGrounded)
{
++curPosIndex;
if (curPosIndex >= possMaster.getInventory().Count)
{
curPosIndex = 0;
StartCoroutine(possMaster.swap(possMaster.getInventory()[curPosIndex]));
}
else
{
StartCoroutine(possMaster.swap(possMaster.getInventory()[curPosIndex]));
}
}
}
if (Input.GetKeyUp(KeyCode.R) && julia.CurrentlyViewing != null && !possMaster.getInventory().Contains(julia.CurrentlyViewing) && !julia.CurrentlyViewing.IsDead)
{
julia.addPrisoner();
}
if (Input.GetKeyUp(KeyCode.T))
{
if (selectionMode)
{
julia.gameObject.rigidbody.useGravity = true;
selectionMode = false;
HOTween.To(julia.gameObject.transform.GetChild(0).GetChild(0).gameObject.GetComponent <Camera>(), 0.5f, "fieldOfView", 60);
julia.startControlling();
}
else
{
julia.gameObject.rigidbody.useGravity = false;
selectionMode = true;
StartCoroutine(astralUp());
//Vector3 up = julia.gameObject.transform.position;
//up.y += 1.5f;
// HOTween.To(julia.gameObject.transform, 0.5f, new TweenParms().Prop("position", up).Ease(EaseType.EaseOutQuad));
// curPosIndex = 0;
//julia.stopControlling();
// selectPris2Poss(possMaster.getInventory()[0]);
}
}
if (selectionMode)
{
if (Input.GetKeyUp(KeyCode.LeftArrow))
{
StartCoroutine(deselectPris2Pos(true));
}
if (Input.GetKeyUp(KeyCode.RightArrow))
{
StartCoroutine(deselectPris2Pos(false));
}
}
}
// Use this for initialization
void Start()
{
k = GetComponent <Kalidescope>();
HOTween.To(k, 3, "angle", 12, false, EaseType.EaseInOutSine, 0);
}
void OnGameOver()
{
HOTween.To(transform, 0.5f, new TweenParms().Ease(EaseType.EaseInBounce).Prop("position", Vector3.zero));
}
//creates a new HOTween tween with give arguments that moves along the path
private void CreateTween()
{
//prepare HOTween's parameters, you can look them up here
//http://www.holoville.com/hotween/documentation.html
//create new plugin for curved paths
//pass in array of Vector3 waypoint positions, relative = true
plugPath = new PlugVector3Path(waypoints, true, pathType);
//orients the tween target along the path
if (orientToPath)
{
plugPath.OrientToPath(lookAhead, lockAxis);
}
//lock position axis, if set
if (lockPosition != Holoville.HOTween.Axis.None)
{
plugPath.LockPosition(lockPosition);
}
//create a closed loop, if set
if (loopType == LoopType.loop && closeLoop)
{
plugPath.ClosePath(true);
}
//create TweenParms for storing HOTween's parameters
tParms = new TweenParms();
//sets the path plugin as tween position property
tParms.Prop("position", plugPath);
//additional tween parameters
tParms.AutoKill(false);
tParms.Loops(1);
if (!moveToPath)
{
tParms.OnComplete(ReachedEnd);
}
//differ between TimeValue, use speed with linear easing
//or time based tweening with an animation easetype
if (timeValue == TimeValue.speed)
{
tParms.SpeedBased();
tParms.Ease(EaseType.Linear);
}
else
{
//use time in seconds and the chosen easetype
if (easeType == Holoville.HOTween.EaseType.AnimationCurve)
{
tParms.Ease(animEaseType);
}
else
{
tParms.Ease(easeType);
}
}
//finally create the tween
tween = HOTween.To(transform, originSpeed, tParms);
//continue new tween with adjusted speed if it was changed before
if (originSpeed != speed)
{
ChangeSpeed(speed);
}
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.Escape))
{
Application.Quit();
}
//Detecting if the player clicked on the left mouse button and also if there is no animation playing
if (Input.GetButtonDown("Fire1"))
{
//The 3 following lines is to get the clicked GameObject and getting the RaycastHit2D that will help us know the clicked object
RaycastHit2D hit = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.zero);
if (hit.transform != null)
{
if (hit.transform.gameObject.name == _MenuButton.name)
{
GetComponent <AudioSource>().PlayOneShot(MenuSound);
hit.transform.localScale = new Vector3(1.1f, 1.1f, 0);
Application.LoadLevel("MainMenu");
}
if (hit.transform.gameObject.name == _FaceBookButton.name)
{
hit.transform.localScale = new Vector3(1.5f, 1.5f, 0);
onBragClicked();
}
if (hit.transform.gameObject.name == _ReloadButton.name)
{
GetComponent <AudioSource>().PlayOneShot(MenuSound);
Time.timeScale = 1;
isPaused = false;
HOTween.Play();
hit.transform.localScale = new Vector3(1.1f, 1.1f, 0);
Application.LoadLevel(Application.loadedLevelName);
}
if (hit.transform.gameObject.name == _PauseButton.name && !isPaused && !isCountingDown && !isEnded && HOTween.GetTweenersByTarget(_PlayButton.transform, false).Count == 0 && HOTween.GetTweenersByTarget(_MenuButton.transform, false).Count == 0)
{
GetComponent <AudioSource>().PlayOneShot(MenuSound);
StartCoroutine(ShowMenu());
hit.transform.localScale = new Vector3(1.1f, 1.1f, 0);
}
else if ((hit.transform.gameObject.name == _PauseButton.name || hit.transform.gameObject.name == _PlayButton.name) && !isEnded && !isCountingDown && isPaused && HOTween.GetTweenersByTarget(_PlayButton.transform, false).Count == 0 && HOTween.GetTweenersByTarget(_MenuButton.transform, false).Count == 0)
{
GetComponent <AudioSource>().PlayOneShot(MenuSound);
StartCoroutine(HideMenu());
hit.transform.localScale = new Vector3(1f, 1f, 0);
}
else if ((hit.transform.gameObject.name == _TestScore.name) && !isEnded && !isCountingDown && !isPaused)
{
GetComponent <AudioSource>().PlayOneShot(MenuSound);
_scoreTotal += _scoreIncrement;
UpdateLevel(20 * _scoreIncrement);
Util.ButtonPressAnimation(hit.transform.gameObject);
}
else if ((hit.transform.gameObject.name == _TestLevelEnd.name) && !isEnded && !isCountingDown && !isPaused)
{
isEnded = true;
isPaused = true;
StartCoroutine(ShowBoardScore());
Util.ButtonPressAnimation(hit.transform.gameObject);
//Update the Level
UpdateReachedLevel();
}
}
}
if (isPaused)
{
return;
}
if (!isPaused)
{
timing += 0.001f;
progress = (float)(timing * _timerCoef);
_Time.transform.localScale = new Vector3(Mathf.Clamp01(progress), _Time.transform.localScale.y, 0);
}
if (Mathf.Clamp01(progress) >= 1)
{
isEnded = true;
isPaused = true;
TweenParms parms = new TweenParms().Prop("position", new Vector3(_TimeIsUp.transform.position.x, -0.85f, -6)).Ease(EaseType.EaseOutQuart);
HOTween.To(_TimeIsUp.transform, 0.5f, parms).WaitForCompletion();
StartCoroutine(ShowBoardScore());
}
//Update the score
(GetComponent(typeof(TextMesh)) as TextMesh).text = _scoreTotal.ToString();
if (PlayerPrefs.GetInt("HighScore") < _scoreTotal && !_BestScoreReached)
{
_BestScoreReached = true;
}
if (PlayerPrefs.GetInt("HighLevel") < level && !_BestLevelReached)
{
_BestLevelReached = true;
}
}
private void Update()
{
switch (state)
{
case GameState.MainMenu:
break;
case GameState.Pause:
break;
case GameState.Transition:
break;
case GameState.GetReady:
ResetBattle();
state = GameState.Battle;
TimeText.gameObject.SetActive(true);
ShowBattle();
TimeText.color = Color.black;
HOTween.Kill(TimeText);
HOTween.To(TimeText, 10f, new TweenParms()
.Prop("color", Color.red)
.Ease(EaseType.Linear)
);
break;
case GameState.Battle:
timer -= Time.deltaTime;
TimeText.text = timer.ToString("0.00");
if (timer <= 0.0f &&
Player.go.GetComponent <PlayerScript>().GetState() != PlayerScript.PlayerState.Prepare &&
Player.go.GetComponent <PlayerScript> ().GetState() != PlayerScript.PlayerState.Attack)
{
state = GameState.GameOver;
TimeText.gameObject.SetActive(false);
HOTween.To(Battle, 1f, new TweenParms()
.Prop("position", new Vector3(Screen.width * 0.5f, -512f, 0.5f))
.Ease(EaseType.EaseInOutBack)
.OnComplete(ShowGameOver)
);
}
else
{
if (enemyAttackTimes.Count > 0)
{
float time = enemyAttackTimes[0];
if (timer <= time &&
numEnemyAttacks < maxEnemyAttacks &&
Enemy.go.GetComponent <EnemyScript> ().GetState() == EnemyScript.EnemyState.Idle)
{
Enemy.go.GetComponent <EnemyScript> ().Attack();
Enemy.go.audio.PlayOneShot(prepareSFX);
enemyAttackTimes.RemoveAt(0);
numEnemyAttacks++;
}
}
if (Input.GetButtonDown("Attack") &&
hitted == false &&
gotHit == false &&
Player.go.GetComponent <PlayerScript> ().GetState() == PlayerScript.PlayerState.Idle)
{
Player.go.GetComponent <PlayerScript> ().Attack();
Player.go.audio.PlayOneShot(prepareSFX);
}
// Change to an collision detect
if (hitted == false &&
Player.go.GetComponent <PlayerScript> ().GetState() == PlayerScript.PlayerState.Attack &&
Enemy.go.GetComponent <EnemyScript> ().GetState() == EnemyScript.EnemyState.Prepare)
{
hitted = true;
Player.go.audio.PlayOneShot(hitSFX);
}
if (hitted == false &&
Player.go.GetComponent <PlayerScript> ().GetState() == PlayerScript.PlayerState.Attack &&
Enemy.go.GetComponent <EnemyScript> ().GetState() == EnemyScript.EnemyState.Idle)
{
Enemy.go.GetComponent <EnemyScript> ().Guard();
}
// Change to an collision detect
if (gotHit == false &&
Player.go.GetComponent <PlayerScript> ().GetState() == PlayerScript.PlayerState.Prepare &&
Enemy.go.GetComponent <EnemyScript> ().GetState() == EnemyScript.EnemyState.Attack)
{
gotHit = true;
Enemy.go.audio.PlayOneShot(hitSFX);
}
if (gotHit == false &&
Player.go.GetComponent <PlayerScript> ().GetState() == PlayerScript.PlayerState.Idle &&
Enemy.go.GetComponent <EnemyScript> ().GetState() == EnemyScript.EnemyState.Attack)
{
Player.go.GetComponent <PlayerScript> ().Guard();
}
if (hitted == true &&
Player.go.GetComponent <PlayerScript> ().GetState() == PlayerScript.PlayerState.Idle &&
Enemy.go.GetComponent <EnemyScript> ().GetState() == EnemyScript.EnemyState.Idle)
{
Enemy.go.GetComponent <EnemyScript> ().Die();
state = GameState.Victory;
TimeText.gameObject.SetActive(false);
HOTween.To(Battle, 1f, new TweenParms()
.Prop("position", new Vector3(Screen.width * 0.5f, -512f, 0.5f))
.Ease(EaseType.EaseInOutBack)
.OnComplete(ShowVictory)
);
}
if (gotHit == true &&
Player.go.GetComponent <PlayerScript> ().GetState() == PlayerScript.PlayerState.Idle &&
Enemy.go.GetComponent <EnemyScript> ().GetState() == EnemyScript.EnemyState.Idle)
{
Player.go.GetComponent <PlayerScript> ().Die();
state = GameState.GameOver;
TimeText.gameObject.SetActive(false);
HOTween.To(Battle, 1f, new TweenParms()
.Prop("position", new Vector3(Screen.width * 0.5f, -512f, 0.5f))
.Ease(EaseType.EaseInOutBack)
.OnComplete(ShowGameOver)
);
}
}
if (Input.GetButtonDown("MainMenu"))
{
state = GameState.MainMenu;
TimeText.gameObject.SetActive(false);
HideBattle();
ShowMainMenu();
}
break;
case GameState.Victory:
case GameState.GameOver:
TimeText.gameObject.SetActive(false);
if (Input.GetButtonDown("Reset"))
{
state = GameState.GetReady;
}
if (Input.GetButtonDown("MainMenu"))
{
state = GameState.MainMenu;
HideGameOver();
HideVictory();
ShowMainMenu();
}
break;
}
StartGame.position = MainMenu.position + StartGameOff;
About.position = MainMenu.position + AboutOff;
Exit.position = MainMenu.position + ExitOff;
Back.position = Credit.position + BackOff;
}
protected IEnumerator StartCombineWithBombEffect(BombTile neighborBombTile)
{
Match3Tile nextToEffectOriginTile;
// TileColorType movedTileColor;
IsDestroying = true;
neighborBombTile.IsDestroying = true;
if (OnDirectionalBombCombine != null)
{
OnDirectionalBombCombine(this);
}
isCombineWithBombEffect = true;
if (!TappedFirst)
{
// Do the combo destroy effect from the other tiles world position because that one was moved by input.
winterchilOriginTile = neighborBombTile;
nextToEffectOriginTile = this;
}
else
{
nextToEffectOriginTile = neighborBombTile;
}
// Spawn the combined tile effect (an enlarging cross directional tile that builds up and the destroys itself)
CrossBombCombineVisualEffect combinedTileEffect = (Instantiate(prefabBombCombinedTileEffect) as GameObject).GetComponent <CrossBombCombineVisualEffect>();
combinedTileEffect.InitComponent();
// Bring this giant tile in the front
combinedTileEffect.cachedTransform.position = winterchilOriginTile.WorldPosition - Vector3.forward * 0.5f;
// Set the delay between the horizontal and vertical direction destroy effect.
delayBetweenCrossDirections = combinedTileEffect.horizontalAnimTime;
HOTween.To(nextToEffectOriginTile.cachedTransform, 0.2f, new TweenParms()
.Prop("localPosition", winterchilOriginTile.LocalPosition)
.Prop("localScale", Vector3.zero));
bombCombineEffectColumn = winterchilOriginTile.BoardPiece.BoardPosition.col;
yield return(new WaitForSeconds(0.2f));
neighborBombTile.gameObject.SetActive(false);
// Disable the default visual effect for this directional tile because we're doing a special combine effect.
useDestroyEffect = false;
StartCoroutine(DelayedTileRelease(0.1f));
// Destroy the cross tile effect after a delay.
GameObject.Destroy(combinedTileEffect.gameObject, combinedTileEffect.totalAnimTime);
SetVerticalColumnsLock(bombCombineEffectColumn, true);
canDestroyBaseTileAfterWinterchill = false;
direction = Direction.Horizontal;
StartDirectionalDestroy(() =>
{
canDestroyBaseTileAfterWinterchill = true;
direction = Direction.Vertical;
StartDirectionalDestroy();
if (neighborBombTile.BoardPiece)
{
neighborBombTile.BoardPiece.Tile = null;
}
GameObject.Destroy(neighborBombTile.gameObject, 0.2f);
});
}
// Rotate the die
public IEnumerator RotateDie(int direction, float duration)
{
isAnimating = true;
//if rotate to the front
if (direction == 1)
{
dieTweener = HOTween.To
(
anchorPointGameObject.transform,
duration,
new TweenParms()
.Prop
(
"rotation",
new Vector3
(
90f,
0f,
0f
),
true
)
.Ease(EaseType.EaseInBack)
.Delay(0f)
);
}
else
//if rotate to the right
if (direction == 2)
{
dieTweener = HOTween.To
(
anchorPointGameObject.transform,
duration,
new TweenParms()
.Prop
(
"rotation",
new Vector3
(
0f,
0f,
-90f
),
true
)
.Ease(EaseType.EaseInBack)
.Delay(0f)
);
}
else
//if rotate to the back
if (direction == 3)
{
dieTweener = HOTween.To
(
anchorPointGameObject.transform,
duration,
new TweenParms()
.Prop
(
"rotation",
new Vector3
(
-90f,
0f,
0f
),
true
)
.Ease(EaseType.EaseInBack)
.Delay(0f)
);
}
else
//if rotate to the left
if (direction == 4)
{
dieTweener = HOTween.To
(
anchorPointGameObject.transform,
duration,
new TweenParms()
.Prop
(
"rotation",
new Vector3
(
0f,
0f,
90f
),
true
)
.Ease(EaseType.EaseInBack)
.Delay(0f)
);
}
yield return(new WaitForSeconds(duration));
}
public override void Open()
{
HOTween.To(mainButton, 0.3f, new TweenParms().Prop("localRotation", new Vector3(0, 0, 45f)));
mainMenu.gameObject.SetActive(true);
HOTween.To(mainMenu, 0.3f, new TweenParms().Prop("anchoredPosition", new Vector2(mainMenu.anchoredPosition.x, 100f)));
}
// Update is called once per frame
void Update()
{
// float x = 0, y = 0, z = 0;
// #if UNITY_ANDROID
// get_m(ref x, ref y, ref z);
// #endif
// tilt = (Input.acceleration.x) * 8;
switch (menuPosition)
{
case MenuState.MAIN:
if (tilt < -2.500812f)
{
v3.Set(9.47f, 2.43f, 2);
HOTween.To(cursor.transform, 0.5f, "localScale", v3);
v3.Set(-5.305806f, 1, 4.47749f);
HOTween.To(cursor.transform, 1f, "localPosition", v3);
if (buttonSelected == Button.NONE)
{
GameObject.Find("Audio/ButtonHover").GetComponent <AudioSource>().Play();
buttonSelected = Button.START;
}
else if (buttonSelected == Button.START)
{
timeButtonSelected++;
if (timeButtonSelected >= timeToSelectButton)
{
GameObject.Find("Audio/ButtonPress").GetComponent <AudioSource>().Play();
GameObject.Find("GameEngine").GetComponent <GameEngine>().startGame();
timeButtonSelected = 0;
switchToGame();
}
}
}
else if (tilt > 3.385096f)
{
v3.Set(8.5f, 2, 2);
HOTween.To(cursor.transform, 0.5f, "localScale", v3);
v3.Set(6.128964f, 1, 4.47749f);
HOTween.To(cursor.transform, 1f, "localPosition", v3);
if (buttonSelected == Button.NONE)
{
GameObject.Find("Audio/ButtonHover").GetComponent <AudioSource>().Play();
buttonSelected = Button.EXIT;
}
else if (buttonSelected == Button.EXIT)
{
timeButtonSelected++;
if (timeButtonSelected >= timeToSelectButton)
{
GameObject.Find("Audio/ButtonPress").GetComponent <AudioSource>().Play();
Application.Quit();
timeButtonSelected = 0;
}
}
}
else
{
v3.Set(2, 2, 2);
HOTween.To(cursor.transform, 0.5f, "localScale", v3);
v3.Set(tilt, -1, 3.891185f);
HOTween.To(cursor.transform, 1f, "localPosition", v3);
if (buttonSelected != Button.NONE)
{
buttonSelected = Button.NONE;
timeButtonSelected = 0;
}
}
break;
case MenuState.GAME:
time.GetComponent <TextMesh>().text = (Mathf.Round((Time.time - GameEngine.startTime) * 100) / 100) + "";
break;
case MenuState.GAMEOVER:
lastTime.GetComponent <TextMesh>().text = (Mathf.Round((GameEngine.endTime - GameEngine.startTime) * 100) / 100) + "";
bestTime.GetComponent <TextMesh>().text = "Best: " + PlayerPrefs.GetFloat("HighScore");
if (tilt < -2.500812f)
{
v3.Set(9.47f, 2.43f, 2);
HOTween.To(cursor.transform, 0.5f, "localScale", v3);
v3.Set(-5.305806f, 1, 4.47749f);
HOTween.To(cursor.transform, 1f, "localPosition", v3);
if (buttonSelected == Button.NONE)
{
GameObject.Find("Audio/ButtonHover").GetComponent <AudioSource>().Play();
buttonSelected = Button.RESTART;
}
else if (buttonSelected == Button.RESTART)
{
timeButtonSelected++;
if (timeButtonSelected >= timeToSelectButton)
{
GameObject.Find("Audio/ButtonPress").GetComponent <AudioSource>().Play();
GameObject.Find("GameEngine").GetComponent <GameEngine>().startGame();
timeButtonSelected = 0;
switchToGame();
}
}
}
else if (tilt > 3.385096f)
{
v3.Set(8.5f, 2, 2);
HOTween.To(cursor.transform, 0.5f, "localScale", v3);
v3.Set(6.128964f, 1, 4.47749f);
HOTween.To(cursor.transform, 1f, "localPosition", v3);
if (buttonSelected == Button.NONE)
{
GameObject.Find("Audio/ButtonHover").GetComponent <AudioSource>().Play();
buttonSelected = Button.BACK;
}
else if (buttonSelected == Button.BACK)
{
timeButtonSelected++;
if (timeButtonSelected >= timeToSelectButton)
{
GameObject.Find("Audio/ButtonPress").GetComponent <AudioSource>().Play();
switchToMain();
timeButtonSelected = 0;
}
}
}
else
{
v3.Set(2, 2, 2);
HOTween.To(cursor.transform, 0.5f, "localScale", v3);
v3.Set(tilt, -1, 3.891185f);
HOTween.To(cursor.transform, 1f, "localPosition", v3);
if (buttonSelected != Button.NONE)
{
buttonSelected = Button.NONE;
timeButtonSelected = 0;
}
}
break;
}
}
void Start()
{
HOTween.showPathGizmos = true;
Vector3[] path = new[] {
Vector3.zero,
new Vector3(0, 1, 0),
new Vector3(1, 2, 0),
new Vector3(2, 1, 0),
new Vector3(2, 0, 0)
};
Axis lockRotation = lockRotation0 | lockRotation1;
PlugVector3Path plugPath = new PlugVector3Path(path, true).ClosePath().OrientToPath(0.1f, lockRotation).LockPosition(lockPosition);
if (is2DPath)
{
plugPath.Is2D(is2DSideScroller);
}
HOTween.To(targets[0], 3, new TweenParms()
.Prop("position", plugPath)
.Ease(EaseType.Linear)
.Loops(-1)
).Pause();
plugPath = new PlugVector3Path(path).ClosePath().LookAt(targets[2]).LockPosition(lockPosition);
if (is2DPath)
{
plugPath.Is2D(is2DSideScroller);
}
HOTween.To(targets[1], 3, new TweenParms()
.Prop("position", plugPath)
.Ease(EaseType.Linear)
.Loops(-1)
).Pause();
// Linear VS curved
plugPath = new PlugVector3Path(path, true, PathType.Curved).ClosePath().LookAt(Vector3.zero).LockPosition(lockPosition);
if (is2DPath)
{
plugPath.Is2D(is2DSideScroller);
}
HOTween.To(targets[2], 3, new TweenParms()
.Prop("position", plugPath)
.Ease(EaseType.Linear)
.Loops(-1)
).Pause();
plugPath = new PlugVector3Path(path, true, PathType.Linear).ClosePath().OrientToPath(0.1f, lockRotation).LockPosition(lockPosition);
if (is2DPath)
{
plugPath.Is2D(is2DSideScroller);
}
HOTween.To(targets[3], 3, new TweenParms()
.Prop("position", plugPath)
.Ease(EaseType.Linear)
.Loops(-1)
).Pause();
// Linear VS curved top-down
path = new[] {
Vector3.zero,
new Vector3(0, 0, 1),
new Vector3(1, 0, 2),
new Vector3(2, 0, 1),
new Vector3(2, 0, 0)
};
plugPath = new PlugVector3Path(path, true, PathType.Curved).ClosePath().OrientToPath(0.1f, lockRotation).LockPosition(lockPosition);
if (is2DPath)
{
plugPath.Is2D(is2DSideScroller);
}
HOTween.To(targets[4], 3, new TweenParms()
.Prop("position", plugPath)
.Ease(EaseType.Linear)
.Loops(-1)
).Pause();
plugPath = new PlugVector3Path(path, true, PathType.Linear).ClosePath().OrientToPath(0.1f, lockRotation).LockPosition(lockPosition);
if (is2DPath)
{
plugPath.Is2D(is2DSideScroller);
}
HOTween.To(targets[5], 3, new TweenParms()
.Prop("position", plugPath)
.Ease(EaseType.Linear)
.Loops(-1)
).Pause();
}
public void Camera3dToPosition(float x, float y)
{
HOTween.To(camera3d.transform, 0.3f, new TweenParms().Prop("localPosition", new Vector3(x, y, camera3d.transform.localPosition.z)));
}
// 隐藏界面
public override void Hide()
{
panel.alpha = 1f;
isShow = true;
HOTween.To(panel, 0.5f, new TweenParms().Prop("alpha", 0f).OnComplete(() => { isShow = false; gameObject.SetActive(false); }));
}
public void Show(float PosDelay, float RotationDelay, float ScaleDelay)
{
#if USE_DOTWEEN // use DOTween: https://www.assetstore.unity3d.com/en/#!/content/27676 Documentation: http://dotween.demigiant.com/documentation.php
#elif USE_HOTWEEN // use HOTween: https://www.assetstore.unity3d.com/#/content/3311 Documentation: http://hotween.demigiant.com/documentation.html
// tween position
m_PosValue = 0;
HOTween.To(this, m_PosDuration, new TweenParms()
.Prop("m_PosValue", 1.0f, false)
.Delay(PosDelay)
.Ease(EaseType.EaseOutElastic)
.OnStart(UpdateTransformPos_Start)
.OnUpdate(UpdateTransformPos_Transforming)
.OnStepComplete(UpdateTransformPos_Finished)
);
// tween rotation
m_RotationValue = 0;
if (m_RotationType == FCProp.eRotationType.Endless)
{
FCGameObjectUtil pFCGameObjectUtil = m_PropGameObject.AddComponent <FCGameObjectUtil>();
pFCGameObjectUtil.InitRotation(m_Rotation);
}
else if (m_RotationType == FCProp.eRotationType.LimitedRound)
{
HOTween.To(this, m_RotationDurationPerRound * m_MaxRotationRound, new TweenParms()
.Prop("m_RotationValue", (float)m_MaxRotationRound, false)
.Delay(RotationDelay)
.Ease(EaseType.EaseInOutQuad)
.OnStart(UpdateRotation_Start)
.OnUpdate(UpdateRotation_Transforming)
.OnStepComplete(UpdateRotation_Finished)
);
}
// tween scale
if (m_ScaleType == eScaleType.Enable)
{
HOTween.To(this, m_ScaleDuration, new TweenParms()
.Prop("m_ScaleValue", 1.0f, false)
.Delay(ScaleDelay)
.Ease(EaseType.EaseOutElastic)
.OnStart(UpdateScale_Start)
.OnUpdate(UpdateScale_Transforming)
.OnStepComplete(UpdateScale_Finished)
);
}
#elif USE_LEANTWEEN // use LeanTween: https://www.assetstore.unity3d.com/#/content/3595 Documentation: http://dentedpixel.com/LeanTweenDocumentation/classes/LeanTween.html
// tween position
//UpdateTransformPos_Start();
LeanTween.value(m_PropGameObject, UpdateTransformPos_TransformingWithValue, 0.0f, 1.0f, m_PosDuration)
.setDelay(PosDelay)
.setEase(LeanTweenType.easeOutElastic)
.setOnComplete(UpdateTransformPos_Finished);
// tween rotation
if (m_RotationType == FCProp.eRotationType.Endless)
{
FCGameObjectUtil pFCGameObjectUtil = m_PropGameObject.AddComponent <FCGameObjectUtil>();
pFCGameObjectUtil.InitRotation(m_Rotation);
}
else if (m_RotationType == FCProp.eRotationType.LimitedRound)
{
//UpdateRotation_Start();
LeanTween.value(m_PropGameObject, UpdateRotation_TransformingWithValue, 0.0f, (float)m_MaxRotationRound, m_RotationDurationPerRound * m_MaxRotationRound)
.setDelay(RotationDelay)
.setEase(LeanTweenType.easeInOutQuad)
.setOnComplete(UpdateRotation_Finished);
}
// tween scale
if (m_ScaleType == eScaleType.Enable)
{
//UpdateScale_Start();
LeanTween.value(m_PropGameObject, UpdateScale_TransformingWithValue, 0.0f, 1.0f, m_ScaleDuration)
.setDelay(ScaleDelay)
.setEase(LeanTweenType.easeOutElastic)
.setOnComplete(UpdateScale_Finished);
}
#else // use iTween: https://www.assetstore.unity3d.com/#/content/84 Documentation: http://itween.pixelplacement.com/documentation.php
// tween position
iTween.ValueTo(m_PropGameObject, iTween.Hash("from", 0, "to", 1,
"time", m_PosDuration,
"delay", PosDelay,
"easeType", FCEaseType.EaseTypeConvert(m_PosEaseType),
"onstart", "UpdateTransformPos_Start",
"onupdate", "UpdateTransformPos_TransformingWithValue",
"onupdatetarget", this.gameObject,
"oncomplete", "UpdateTransformPos_Finished"));
// tween rotation
if (m_RotationType == FCProp.eRotationType.Endless)
{
FCGameObjectUtil pFCGameObjectUtil = m_PropGameObject.AddComponent <FCGameObjectUtil>();
pFCGameObjectUtil.InitRotation(m_Rotation);
pFCGameObjectUtil.StartRotation();
}
else if (m_RotationType == FCProp.eRotationType.LimitedRound)
{
iTween.ValueTo(m_PropGameObject, iTween.Hash("from", 0, "to", m_MaxRotationRound,
"time", m_RotationDurationPerRound * m_MaxRotationRound,
"delay", RotationDelay,
"easeType", FCEaseType.EaseTypeConvert(m_RotationEaseType),
"onstart", "UpdateRotation_Start",
"onupdate", "UpdateRotation_TransformingWithValue",
"onupdatetarget", this.gameObject,
"oncomplete", "UpdateRotation_Finished"));
}
// tween scale
if (m_ScaleType == eScaleType.Enable)
{
iTween.ValueTo(m_PropGameObject, iTween.Hash("from", 0, "to", 1,
"time", m_ScaleDuration,
"delay", ScaleDelay,
"easeType", FCEaseType.EaseTypeConvert(m_ScaleEaseType),
"onstart", "UpdateScale_Start",
"onupdate", "UpdateScale_TransformingWithValue",
"onupdatetarget", this.gameObject,
"oncomplete", "UpdateScale_Finished"));
}
#endif
}
// show turn bumper animation. 1 is player, 2 is enemy
public IEnumerator ShowTurnBumperAnimation(int turnTargetID)
{
GameObject bumperUI = uiCanvas.transform.GetChild(3).gameObject.transform.GetChild(0).gameObject;
Text bumperText = bumperUI.transform.GetChild(0).gameObject.GetComponent <Text>();
bumperUI.SetActive(true);
//if going to player's turn
if (turnTargetID == 1)
{
bumperUI.GetComponent <Image>().color = Color.blue;
bumperText.text = "PLAYER'S TURN";
}
else
//if going to enemy's turn
if (turnTargetID == 2)
{
bumperUI.GetComponent <Image>().color = Color.red;
bumperText.text = "ENEMY'S TURN";
}
HOTween.To
(
bumperUI.GetComponent <RectTransform>(),
0.5f,
new TweenParms()
.Prop
(
"anchoredPosition",
new Vector2
(
0f,
0f
),
false
)
.Ease(EaseType.EaseOutBack)
.Delay(0f)
);
//yield return new WaitForSeconds(1f);
HOTween.To
(
bumperUI.GetComponent <RectTransform>(),
0.5f,
new TweenParms()
.Prop
(
"anchoredPosition",
new Vector2
(
2000f,
0f
),
false
)
.Ease(EaseType.EaseInBack)
.Delay(1f)
);
yield return(new WaitForSeconds(1.5f));
bumperUI.SetActive(false);
bumperUI.GetComponent <RectTransform>().anchoredPosition = new Vector2(-2000f, 0f);
}
/// <summary>
/// Creates a tween based on the given tweenData and returns it,
/// or returns <code>null</code> if the tween was empty.
/// </summary>
/// <param name="p_twData">
/// A <see cref="HOTweenData"/>
/// </param>
public static Holoville.HOTween.Tweener CreateTween(HOTweenData p_twData, float p_globalDelay, float p_globalTimeScale)
{
if (p_twData.propDatas.Count == 0 || !p_twData.isActive)
{
return(null);
}
TweenParms parms = new TweenParms()
.Delay(p_twData.delay + p_globalDelay)
.Id(p_twData.id)
.Loops(p_twData.loops, p_twData.loopType)
.UpdateType(p_twData.updateType)
.Ease(p_twData.easeType)
.TimeScale(p_twData.timeScale * p_globalTimeScale)
.AutoKill(p_twData.autoKill)
.Pause(p_twData.paused);
// Eventual onComplete
if (p_twData.onCompleteActionType != HOTweenData.OnCompleteActionType.None)
{
switch (p_twData.onCompleteActionType)
{
case HOTweenData.OnCompleteActionType.PlayAll:
parms.OnComplete(() => HOTween.Play());
break;
case HOTweenData.OnCompleteActionType.PlayTweensById:
parms.OnComplete(() => HOTween.Play(p_twData.onCompletePlayId));
break;
case HOTweenData.OnCompleteActionType.SendMessage:
if (p_twData.onCompleteTarget == null || p_twData.onCompleteMethodName == "")
{
break;
}
object onCompleteParm = null;
switch (p_twData.onCompleteParmType)
{
case HOTweenData.ParameterType.Color:
onCompleteParm = p_twData.onCompleteParmColor;
break;
case HOTweenData.ParameterType.Number:
onCompleteParm = p_twData.onCompleteParmNumber;
break;
case HOTweenData.ParameterType.Object:
onCompleteParm = p_twData.onCompleteParmObject;
break;
case HOTweenData.ParameterType.Quaternion:
onCompleteParm = p_twData.onCompleteParmQuaternion;
break;
case HOTweenData.ParameterType.Rect:
onCompleteParm = p_twData.onCompleteParmRect;
break;
case HOTweenData.ParameterType.String:
onCompleteParm = p_twData.onCompleteParmString;
break;
case HOTweenData.ParameterType.Vector2:
onCompleteParm = p_twData.onCompleteParmVector2;
break;
case HOTweenData.ParameterType.Vector3:
onCompleteParm = p_twData.onCompleteParmVector3;
break;
case HOTweenData.ParameterType.Vector4:
onCompleteParm = p_twData.onCompleteParmVector4;
break;
}
parms.OnComplete(p_twData.onCompleteTarget, p_twData.onCompleteMethodName, onCompleteParm);
break;
}
}
foreach (HOPropData propData in p_twData.propDatas)
{
if (propData.isActive)
{
parms.Prop(propData.propName, Activator.CreateInstance(propData.pluginType, propData.endVal, propData.isRelative));
}
}
if (!parms.hasProps)
{
return(null);
}
if (p_twData.tweenFrom)
{
return(HOTween.From(p_twData.target, p_twData.duration, parms));
}
return(HOTween.To(p_twData.target, p_twData.duration, parms));
}
public void FinishLevel()
{
HOTween.To(Camera.main.GetComponent <tk2dCamera> ().camera, 8.0f, new TweenParms().Prop("backgroundColor", (Color) new Color32(129, 184, 209, 255)).OnComplete(this.TransitionLevel));
}
void TweenMoney(int val, EaseType easeType)
{
TweenParms parms = new TweenParms().Prop("tweenMoney", val).Ease(easeType).OnUpdate(TweenMoneyUpdate);
HOTween.To(this, 0.5f, parms);
}
public void TransitionLevel()
{
HOTween.To(GameObject.Find("Fade").GetComponent <SpriteRenderer> (), 4f, new TweenParms().Prop("color", Color.black).OnComplete(this.LoadLevel));
}
//creates a new HOTween tween which moves us to the next waypoint
//(defined by passed arguments)
internal void CreateTween()
{
//play walk animation if set
PlayWalk();
//prepare HOTween's parameters, you can look them up here
//http://www.holoville.com/hotween/documentation.html
////////////////////////////////////////////////////////////
//create new HOTween plugin for curved paths
//pass in array of Vector3 waypoint positions, relative = true
plugPath = new PlugVector3Path(wpPos, true, pathtype);
//orients the tween target along the path
//constrains this game object on one axis
if (orientToPath || lockAxis != Axis.None)
{
plugPath.OrientToPath(lookAhead, lockAxis);
}
//lock position axis
if (lockPosition != Axis.None)
{
plugPath.LockPosition(lockPosition);
}
//create a smooth path if closePath was true
if (closePath)
{
plugPath.ClosePath(true);
}
//create TweenParms for storing HOTween's parameters
tParms = new TweenParms();
//sets the path plugin as tween position property
if (local)
{
tParms.Prop("localPosition", plugPath);
}
else
{
tParms.Prop("position", plugPath);
}
//additional tween parameters for partial tweens
tParms.AutoKill(false);
tParms.Pause(true);
tParms.Loops(1);
//differ between TimeValue like mentioned above at enum TimeValue
//use speed with linear easing
if (timeValue == TimeValue.speed)
{
tParms.SpeedBased();
tParms.Ease(EaseType.Linear);
}
else
{
//use time in seconds and the chosen easetype
tParms.Ease(easetype);
}
//create a new tween, move this gameobject with given arguments
tween = HOTween.To(transform, originSpeed, tParms);
//continue new tween with adjusted speed if it was changed before
if (originSpeed != speed)
{
ChangeSpeed(speed);
}
}
protected void StartReshuffleTilesAnim()
{
// Start their re-shuffle tween animation.
Match3Tile tile;
// Spawn a reshuffle effect that will get auto-destroyed.
effectReshuffle = (GameObject.Instantiate(prefabEffectReshuffle) as GameObject).transform;
effectReshuffle.parent = Match3BoardGameLogic.Instance.boardVisualContainer;
cachedParticleSystem = effectReshuffle.particleSystem;
// Auto destroy the effect.
GameObject.Destroy(effectReshuffle.gameObject, 4.0f);
Tweener lastTween = null;
// if(piecesToReshuffle.Count == 0) {
// Debug.LogWarning("[piecesToReshuffle.Count] " + piecesToReshuffle.Count);
// }
for (int i = 0; i < piecesToReshuffle.Count; i++)
{
tile = piecesToReshuffle[i].Tile as Match3Tile;
if (tile != null)
{
// Stored the tile position in a separate vector because so the below lambda method will receive a copy of this value to execute correctly.
Vector3 tilePos = tile.cachedTransform.position;
// Offset effect to bring it in front of the tiles.
tilePos.z -= 1f;
lastTween = HOTween.To(tile.tileModelTransform, 0.5f, new TweenParms()
.Prop("localScale", Vector3.zero)
.Ease(EaseType.EaseOutQuad)
.Delay(0.9f)
.OnStart(() => {
if (effectReshuffle != null)
{
// Position the effect
effectReshuffle.position = tilePos;
cachedParticleSystem.Emit(Random.Range(minNumParticles, maxNumParticles));
}
}));
// if (lastTween == null) {
// Debug.LogWarning("Last tween is NULL!!!");
// }
}
// else {
// Debug.LogWarning("[StartReshuffleTilesAnim] Boardpiece has NULL tile = " + piecesToReshuffle[i]);
// }
}
if (lastTween != null)
{
lastTween.ApplyCallback(CallbackType.OnComplete, () =>
{
ReshuffleTiles();
});
}
// else {
// Debug.LogWarning("[StartReshuffleTilesAnim] Error lastTween is NULL");
// }
}
// ===================================================================================
// UNITY METHODS ---------------------------------------------------------------------
void Start()
{
// HOTWEEN INITIALIZATION
// Must be done only once, before the creation of your first tween
// (you can skip this if you want, and HOTween will be initialized automatically
// when you create your first tween - using default values)
HOTween.Init(true, true, true);
// TWEEN CREATION
// With each one is shown a different way you can create a tween,
// so that in the end you can choose what you prefer
// Tween the first transform using fast writing mode,
// and applying an animation that will last 4 seconds
HOTween.To(CubeTrans1, 4, "position", new Vector3(-3, 6, 0));
// Tween the second transform using full mode with parameters and linebreaks,
// applying a yoyo loop with custom ease,
// and assigning an onStepComplete callback
// which will be fired each time a loop iteration is complete.
// Also note that we are tweening 2 proporties of the same target
// (a transform, in this case)
HOTween.To(CubeTrans2, 3, new TweenParms()
.Prop("position", new Vector3(0, 6, 0), true) // Position tween (set as relative)
.Prop("rotation", new Vector3(0, 1024, 0), true) // Relative rotation tween (this way rotations higher than 360 can be applied)
.Loops(-1, LoopType.Yoyo) // Infinite yoyo loops
.Ease(EaseType.EaseInOutQuad) // Ease
.OnStepComplete(Cube2StepComplete) // OnComplete callback
);
// Tween the sample string using full mode with parameters and without linebreaks.
// The result will be shown using OnGUI
HOTween.To(this, 3, new TweenParms().Prop("SampleString", "Hello I'm a sample tweened string").Ease(EaseType.Linear).Loops(-1, LoopType.Yoyo));
// Tween the sample floating point number while creating TweenParms first,
// and then assigning it to HOTween.
TweenParms tweenParms = new TweenParms().Prop("SampleFloat", 27.5f).Ease(EaseType.Linear).Loops(-1, LoopType.Yoyo);
HOTween.To(this, 3, tweenParms);
// SEQUENCE CREATION
// Here you'll see how to create a Sequence,
// which stores your tweens in a timeline-like way
// Create a Sequence with cube3, which will rotate it,
// then move it upwards, the rotate it again,
// all the while changing the alpha of its material's color
// (which can be done since the cube uses a transparent material).
// The Sequence will also be set to loop.
// Note that Sequences don't start automatically, so you'll have to call Play().
Color colorTo = CubeTrans3.renderer.material.color;
colorTo.a = 0;
Sequence sequence = new Sequence(new SequenceParms().Loops(-1, LoopType.Yoyo));
// "Append" will add a tween after the previous one/s have completed
sequence.Append(HOTween.To(CubeTrans3, 1, new TweenParms().Prop("rotation", new Vector3(360, 0, 0))));
sequence.Append(HOTween.To(CubeTrans3, 1, new TweenParms().Prop("position", new Vector3(0, 6, 0), true)));
sequence.Append(HOTween.To(CubeTrans3, 1, new TweenParms().Prop("rotation", new Vector3(0, 360, 0))));
// "Insert" lets you insert a tween where you want
// (in this case we're having it start at half the sequence and last until the end)
sequence.Insert(sequence.duration * 0.5f, HOTween.To(CubeTrans3.renderer.material, sequence.duration * 0.5f, new TweenParms().Prop("color", colorTo)));
// Start the sequence animation
sequence.Play();
sequence.Rewind();
}
protected void ReshuffleTiles()
{
// Re-shuffle tiles
for (int i = 0; i < piecesToReshuffle.Count; i++)
{
int randomIdx = Random.Range(0, piecesToReshuffle.Count);
if (randomIdx != i)
{
// Switch tiles
Match3Tile tempTile = piecesToReshuffle[i].Tile as Match3Tile;
piecesToReshuffle[i].Tile = piecesToReshuffle[randomIdx].Tile;
piecesToReshuffle[randomIdx].Tile = tempTile;
}
}
int numTries = 0;
matchesUndoer.OnNewTileSpawned = (newTile) =>
{
newTile.tileModelTransform.localScale = Vector3.zero;
newTile.enabled = false;
};
possibleMatchGenerator.OnNewTileSpawned = (newTile) =>
{
newTile.tileModelTransform.localScale = Vector3.zero;
newTile.enabled = false;
};
matchFailed = true;
while ((numTries++) < 10 && (matchesUndoer.FindMatchesAndUndo(false) || numTries == 1))
{
// Debug.Log("Board shuffle re-tries: " + numTries);
matchFailed = !possibleMatchesFinder.FindFirstPossibleMatch();
if (matchFailed)
{
// Debug.LogWarning("Forcing a rematch because re-shuffle failed.");
matchFailed = !possibleMatchGenerator.GenerateMatch(false);
}
}
matchesUndoer.OnNewTileSpawned = null;
possibleMatchGenerator.OnNewTileSpawned = null;
// Show hidden tiles.
Match3Tile tile = null;
Tweener lastTween = null;
// if(piecesToReshuffle.Count == 0) {
// Debug.LogWarning("[piecesToReshuffle.Count] " + piecesToReshuffle.Count);
// }
for (int i = 0; i < piecesToReshuffle.Count; i++)
{
tile = piecesToReshuffle[i].Tile as Match3Tile;
piecesToReshuffle[i].ResetTilePosition();
if (tile != null)
{
// Position the effect
// effectReshuffle.position = tile.cachedTransform.position;
//cachedParticleSystem.Emit(Random.Range(minNumParticles, maxNumParticles));
lastTween = HOTween.To(tile.tileModelTransform, 0.5f, new TweenParms()
.Prop("localScale", Vector3.one)
.Ease(EaseType.EaseOutQuad));
// if (lastTween == null) {
// Debug.LogWarning("Last tween is NULL!!!");
// }
}
// else {
// Debug.LogWarning("[ReshuffleTiles] In show tiles anim Boardpiece has NULL tile = " + piecesToReshuffle[i]);
// }
}
if (lastTween != null)
{
lastTween.ApplyCallback(CallbackType.OnComplete, () =>
{
RaiseBoardShuffleFinishedEvent();
OnReshuffleFinished.RaiseEvent();
});
}
else
{
RaiseBoardShuffleFinishedEvent();
OnReshuffleFinished.RaiseEvent();
// Debug.LogWarning("[StartReshuffleTilesAnim] Error lastTween is NULL");
}
}
void Start()
{
HOTween.Init(true, true, true);
//----------------------------------------------------
HOTween.To(tnCube1, 4, "position", tnCube1.position + Vector3.up * 5);
//HOTween.To(tnCube1, 4, "rotation", tnCube1.rotation * Quaternion.Euler(0, 360+1, 0));
HOTween.To(tnCube1, 4, "eulerAngles", new Vector3(0, 360 * 4, 0));
HOTween.To(tnCube1.GetComponent <MeshRenderer>().material, 4, "color", new Color(1f, 0, 0));
//--------------------------------------------------------
//HOTween.To(tnCube2, 4, new TweenParms()
// .Prop("position", tnCube2.position + Vector3.up * 5, false)
// .Prop("eulerAngles", new Vector3(0, 360 * 4, 0), false)
// .Loops(-1, LoopType.Yoyo)
// .Ease(EaseType.EaseInOutQuad)
// .OnStepComplete(OnStepComplete)
// .OnComplete(OnComplete)
// .OnUpdate(OnUpdate)
// );
//HOTween.To(tnCube2, 4, new TweenParms()
// .Prop("position", deltaPos2, true)
// .Prop("eulerAngles", deltaAngle2, true)
// .Loops(-1, loopType2)
// .Ease(easeType2)
// .OnStepComplete(OnStepComplete)
// .OnComplete(OnComplete)
// .OnUpdate(OnUpdate)
// );
HOTween.To(tnCube2, 4, new TweenParms()
.Prop("localPosition", deltaPos2, true)
.Prop("localEulerAngles", deltaAngle2, true)
.Loops(-1, loopType2)
.Ease(easeType2)
.OnStepComplete(OnStepComplete)
.OnComplete(OnComplete)
.OnUpdate(OnUpdate)
);
//--------------------------------------------------------
//Material _mat3 = tnCube3.GetComponent<Renderer>().material;
//Sequence _sequence = new Sequence(new SequenceParms().Loops(-1, LoopType.Yoyo));
////_sequence.AppendInterval(.1f);
//_sequence.Append(HOTween.To(tnCube3, 1, new TweenParms().Prop("localEulerAngles", new Vector3(0, 360, 0), true)));
//_sequence.Append(HOTween.To(tnCube3, 1, new TweenParms().Prop("localPosition", new Vector3(0, 5, 0), true)));
//_sequence.Append(HOTween.To(tnCube3, 1, new TweenParms().Prop("localEulerAngles", new Vector3(0, 360, 0), true)));
//Debug.Log(_sequence.duration);
//float _time = _sequence.duration * 0.5f;
//_sequence.Insert(_time, HOTween.To(_mat3, _time, new TweenParms().Prop("color", color3)));
//_sequence.Play();
//Material _mat3 = tnCube3.GetComponent<Renderer>().material;
//Sequence _seq = new Sequence(new SequenceParms().Loops(-1, loopType3));
//_seq.Append(HOTween.To(tnCube3, 1f, new TweenParms().Prop("localEulerAngles", deltaAngle3, true)));
//_seq.Append(HOTween.To(tnCube3, 1f, new TweenParms().Prop("localPosition", deltaPos3, true)));
//_seq.Append(HOTween.To(tnCube3, 1f, new TweenParms().Prop("localEulerAngles", deltaAngle3, true)));
//float _duration = _seq.duration * 0.3f;
//_seq.Insert(_duration, HOTween.To(_mat3, _duration, new TweenParms().Prop("color", color3)));
//_seq.Play();
//Material _mat3 = tnCube3.GetComponent<Renderer>().material;
//Sequence _seq = new Sequence(new SequenceParms().Loops(-1, loopType3));
//_seq.Append(HOTween.To(tnCube3, 1f, new TweenParms().Prop("localEulerAngles", deltaAngle3, true)));
//_seq.Append(HOTween.To(tnCube3, 1f, new TweenParms().Prop("localPosition", deltaPos3, true)));
//_seq.Append(HOTween.To(tnCube3, 1f, new TweenParms().Prop("localEulerAngles", deltaAngle3, true)));
//float _duration = _seq.duration * 0.3f;
//_seq.Insert(_duration, HOTween.To(_mat3, _duration, new TweenParms().Prop("color", color3)));
//_seq.Play();
Material _mat3 = tnCube3.GetComponent <Renderer>().material;
Sequence _seq = new Sequence(new SequenceParms().Loops(-1, loopType3));
_seq.Append(HOTween.To(tnCube3, 1f, new TweenParms().Prop("localEulerAngles", deltaAngle3, true)));
_seq.Append(HOTween.To(tnCube3, 1f, new TweenParms().Prop("localPosition", deltaPos3, true)));
_seq.Append(HOTween.To(tnCube3, 1f, new TweenParms().Prop("localEulerAngles", deltaAngle3, true)));
_seq.Insert(1f, HOTween.To(_mat3, 1f, new TweenParms().Prop("color", color3)));
_seq.Play();
}
void movePlayer()
{
HOTween.To(this.gameObject.transform, moveSpeed, new TweenParms().Prop("position", leftDistance, true).Ease(EaseType.Linear).OnComplete(changeMovingState));
}
public void Hide()
{
StopAnimations();
HOTween.To(canvasGroup, animDuration / 2.0f, "alpha", 0f, false, EaseType.EaseInOutExpo, animDuration - 0.1f).Play();
HOTween.To(canvasGroup.transform, animDuration, "localScale", new Vector3(), false, EaseType.EaseInBack, 0).Play();
}
public void StartDestroy()
{
destroying = true;
Messenger.Broadcast(destroyEvent);
HOTween.To(this, 2, new TweenParms().Prop("kill", 1));
}