public void ShakeCam()
{
cam.transform.position = camPosition + Vector3.right * 0.2f;
TweenParms parms = new TweenParms().Prop("localPosition", camPosition).Ease(EaseType.EaseOutBounce).OnComplete(DoneShakeCam);
HOTween.To(cam.transform, 0.4f, parms);
}
void SetPosition(bool isMotion)
{
//print ("SetPosition");
//print ("isMotion="+isMotion);
Vector3 pos = mLocalPosition;
//print ("pos1="+pos);
//print ("seq="+seq);
pos += new Vector3(0f, seq * cellHeight, 0f);
//print ("pos2="+pos);
//pos -= new Vector3(0f, 300f, 0f);
if (isMotion)
{
//print ("if isMotion");
TweenParms parms = new TweenParms();
parms.Prop("localPosition", pos);
parms.Ease(EaseType.EaseOutCirc);
HOTween.To(mTrans, 0.1f, parms);
HOTween.Play();
}
else
{
//print ("else isMotion");
mTrans.localPosition = pos;
}
//titleLabel.text = heros[seq].spriteName;
}
public U9HOTweenTransition(HOTweenDelegate tweenDelegate, object go, float duration, TweenParms args)
{
this.tweenDelegate = tweenDelegate;
this.go = go;
this.args = args;
this.duration = duration;
}
void IntroGame()
{
friendAnimator.CrossFade("Walk", 0.2f);
enemyAnimator.CrossFade("Walk", 0.2f);
Vector3 pos = friendPos;
friendAnimator.transform.localPosition = new Vector3(pos.x * 3f, pos.y, pos.z);
TweenParms parms = new TweenParms().Prop("localPosition", friendPos).Ease(EaseType.Linear).OnComplete(OnFriendStop);
HOTween.To(friendAnimator.transform, 2f, parms);
pos = enemyPos;
enemyAnimator.transform.localPosition = new Vector3(pos.x * 3f, pos.y, pos.z);
parms = new TweenParms().Prop("localPosition", pos).Ease(EaseType.Linear).OnComplete(OnEnemyStop);
HOTween.To(enemyAnimator.transform, 2f, parms);
pos = shieldPos;
shieldGroup.localPosition = new Vector3(pos.x, 0f, pos.z);
parms = new TweenParms().Prop("localPosition", pos).Delay(1f);
HOTween.To(shieldGroup, 1f, parms);
shieldGroup.localScale = new Vector3(2f, 2f, 1f);
parms = new TweenParms().Prop("localScale", new Vector3(0.8f, 0.8f, 1f));
HOTween.To(shieldGroup, 1f, parms);
pos = friendHpPos;
friendHpGroup.localPosition = new Vector3(pos.x * 3f, pos.y, pos.z);
parms = new TweenParms().Prop("localPosition", pos).Delay(0.5f);
HOTween.To(friendHpGroup, 1f, parms);
pos = enemyHpPos;
enemyHpGroup.localPosition = new Vector3(pos.x * 3f, pos.y, pos.z);
parms = new TweenParms().Prop("localPosition", pos).Delay(0.5f);
HOTween.To(enemyHpGroup, 1f, parms);
}
// Disable and disappear a button
void DisableButton(GameObject go)
{
Color oldColor = go.GetComponent <Renderer> ().material.color;
TweenParms parms = new TweenParms().Prop("color", new Color(oldColor.r, oldColor.b, oldColor.g, 0f)).Ease(EaseType.EaseOutQuart);
HOTween.To(go.GetComponent <Renderer> ().material, 1f, parms);
}
private IEnumerator Animate()
{
if (Layer.OldLayer != Layer.OtherLayer)
{
LayerSetter.SetAllLayerRecursively(gameObject, Layer.OtherLayer);
}
SetPlayerMotion(false);
Transform tweenTarget = LinkedEquipment.transform;
if (LinkedEquipment as EquipmentAsGui)
{
tweenTarget = Player.transform;
}
TweenParms parms = new TweenParms();
parms.Prop("position", new PlugVector3(tweenTarget.position));
parms.Prop("rotation", new PlugQuaternion(tweenTarget.rotation));
parms.Prop("localScale", new PlugVector3(tweenTarget.localScale));
parms.Ease(EaseType.EaseInOutSine);
HOTween.To(transform, TakeAnimationLength, parms);
//dan
//TODO
//yield WaitForSeconds(TakeAnimationLength);
yield return(new WaitForSeconds(TakeAnimationLength));
SetPlayerMotion(true);
LayerSetter.SetAllLayerRecursively(gameObject, Layer.OldLayer);
}
//creates a new HOTween tween which moves us to the next waypoint
//(defined by passed arguments)
internal void CreateTween()
{
//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)
{
plugPath.OrientToPath();
}
//create TweenParms for storing HOTween's parameters
tParms = new TweenParms();
//sets the path plugin as tween position property
tParms.Prop("position", plugPath);
tParms.AutoKill(true);
//use speed based tween with linear easing
tParms.SpeedBased();
tParms.Ease(EaseType.Linear);
tParms.OnComplete(OnPathComplete);
//create a new tween, move this gameobject with given arguments
tween = HOTween.To(transform, maxSpeed, tParms);
}
IEnumerator Init()
{
isPaused = true; Time.timeScale = 0;
if (PlayerPrefs.GetInt("Tutorial") != 1)
{
var isOkay = false;
while (isOkay == false)
{
if (Input.GetButtonDown("Fire1"))
{
isOkay = true;
Time.timeScale = 1;
TweenParms parms = new TweenParms().Prop("localPosition", new Vector3(100, 0, -10)).Ease(EaseType.EaseOutQuart);
HOTween.To(_Tutorial.transform, 3f, parms);
PlayerPrefs.SetInt("Tutorial", 1);
}
yield return(0);
}
}
else
{
Time.timeScale = 1;
_Tutorial.transform.localPosition = new Vector3(100, 0, -10);
}
isPaused = false;
}
private void StartMooving(float movingDuration)
{
for (var i = 0; i < ItemList.Count; i++)
{
if (_targetItemPositionPathList[i].Count < 1)
{
continue;
}
var param = new TweenParms();
if (_targetItemPositionPathList[i].Count > 1)
{
param.Prop("localPosition", new PlugVector3Path(_targetItemPositionPathList[i].ToArray()));
}
else
{
param.Prop("localPosition", _targetItemPositionPathList[i][0]);
}
if (i == 0)
{
HOTween.Kill();
param.OnStart(() => { IsScrollingInProcess = true; });
param.OnComplete(DetectCurrentItem);
}
HOTween.To(ItemList[i].transform, movingDuration, param);
}
}
private void Show()
{
GoodsItemVO vo = currSelectedVO;
//todo:根据数据初始化整个详情
SetName(vo.name);
SetOwn(vo.own);
SetDetails(vo.description, vo.extraDescription);
SetCost(vo.totalcost, vo.cout, vo.goodsCostType);
Convert();
if (temp == null)
{
this.mTrans.localScale = new Vector3(0.1f, 0.1f, 0.1f);
HOTween.Init();
parms = new TweenParms();
parms.Prop("localScale", new Vector3(1f, 1f, 1f));
parms.Ease(EaseType.EaseOutBack);
parms.Delay(0.1f);
parms.AutoKill(false);
temp = HOTween.To(this.mTrans, 0.2f, parms);
temp.intId = 1;
}
temp.PlayForward();
}
public void ShowHideCard(bool hide)
{
var colliderEnabled = Collider.enabled;
Collider.enabled = false;
var param = new TweenParms();
param.Prop("color", new Color(1, 1, 1, hide ? 1 : 0));
param.OnComplete(() =>
{
Collider.enabled = colliderEnabled;
if (OnShowCardFinished != null && !hide)
{
OnShowCardFinished();
OnShowCardFinished = null;
}
if (OnHideCardFinished != null && hide)
{
OnHideCardFinished();
OnHideCardFinished = null;
}
});
HOTween.To(_lampOff, SHOW_HIDE_DURATION, param);
}
private void Init(string tip)
{
imageObj = MonoBehaviour.Instantiate(Resources.Load("Tips/TipsImage")) as GameObject;
imageObj.GetComponent <RectTransform>().SetParent(tipParent);
imageObj.transform.localPosition = new Vector3(0, -100, 0);
image = imageObj.GetComponent <Image>();
imageforblack = image.transform.Find("for more black").GetComponent <Image>();
text = imageforblack.transform.Find("my lable").GetComponent <Text>();
text.text = tip;
HOTween.Init();
TweenParms parms = new TweenParms();
parms.Prop("localPosition", new PlugVector3Y(50));
parms.Ease(EaseType.EaseOutCubic);
parms.Delay(0.1f);
parms.OnComplete(MyComplete);
HOTween.To(image.rectTransform, 1.5f, parms);
#region Legacy DoTween
//DOTween.Init();
//Tweener tweener = image.rectTransform.DOMoveY(250f, 1f);
//tweener.SetEase(Ease.Linear);
//image.material.DOColor(Color.clear,1.5f);
//text.material.DOColor(Color.clear, 1.5f);
//tweener.OnComplete(MyComplete);
#endregion
}
// Move with Tweening Animation
void TweenMove(Transform tr, Vector3 pos1, Vector3 pos2)
{
tr.localPosition = pos1;
TweenParms parms = new TweenParms().Prop("localPosition", pos2).Ease(EaseType.Linear);
HOTween.To(tr, 0.1f, parms);
}
// Animate the Logos with fadeIn and fadeOut effect
IEnumerator Init()
{
Sequence mySequence = new Sequence(new SequenceParms());
TweenParms parms;
Color oldColor = _Logo.GetComponent <Renderer>().material.color;
_Logo.GetComponent <Renderer>().material.color = new Color(oldColor.r, oldColor.b, oldColor.g, 0f);
parms = new TweenParms().Prop("color", new Color(oldColor.r, oldColor.b, oldColor.g, 1f)).Ease(EaseType.EaseInQuart);
mySequence.Append(HOTween.To(_Logo.GetComponent <Renderer>().material, _FadeInTime, parms));
mySequence.Append(HOTween.To(_Logo.GetComponent <Renderer>().material, _WaitingTime, parms));
parms = new TweenParms().Prop("color", new Color(oldColor.r, oldColor.b, oldColor.g, 0f));
mySequence.Append(HOTween.To(_Logo.GetComponent <Renderer>().material, _FadeOutTime, parms));
mySequence.Play();
yield return(new WaitForSeconds(_FadeInTime + _WaitingTime + _FadeOutTime));
SceneManager.LoadScene(1);
//Application.LoadLevel(_nextScene);
}
public void Move(Transform tr)
{
SoundController.Sound.ClickBtn();
if (!isOpen)
{
if (tr.name == "Quit Game")
{
}
overlay.SetActive(true);
oriPos = tr.position;
TweenParms parms = new TweenParms().Prop("position", target.position).Ease(easeTypeGoTo);
HOTween.To(tr, .7f, parms);
isOpen = true;
ExitGameObj.SetActive(true);
OptionsObj.SetActive(true);
}
else
{
overlay.SetActive(false);
TweenParms parms = new TweenParms().Prop("position", oriPos).Ease(easeTypeGoTo).OnComplete(OnComplete);
HOTween.To(tr, .7f, parms);
ExitGameObj.SetActive(false);
OptionsObj.SetActive(false);
}
}
//Update the Level
void UpdateLevel(int score)
{
ScoreByLevel += score;
maxProgress = (float)Mathf.Floor(250 * (level + 1));
_Level.transform.localScale = new Vector3((float)(ScoreByLevel / maxProgress), _Level.transform.localScale.y, 0);
if (Mathf.Clamp01(_Level.transform.localScale.x) >= 1)
{
//_Level.transform.localScale= new Vector3 (0, _Level.transform.localScale.y, 0) ;
//Order is important for calculus
level += 1;
ScoreByLevel = 0;
timing = 0;
GetComponent <AudioSource>().PlayOneShot(PowerSound);
TweenParms parms = new TweenParms().Prop("localScale", new Vector3(0, _Level.transform.localScale.y, -6)).Ease(EaseType.EaseOutQuart);
HOTween.To(_Level.transform, 0.5f, parms).WaitForCompletion();
parms = new TweenParms().Prop("localScale", new Vector3(0, _Time.transform.localScale.y, -6)).Ease(EaseType.EaseOutQuart);
HOTween.To(_Time.transform, 0.5f, parms).WaitForCompletion();
(_LevelTextValue.GetComponent(typeof(TextMesh)) as TextMesh).text = level.ToString();
var destroyingParticle = GameObject.Instantiate(_LevelTextValue as GameObject, new Vector3(_LevelTextValue.transform.position.x, _LevelTextValue.transform.position.y, _LevelTextValue.transform.position.z - 1), transform.rotation) as GameObject;
Color oldColor = destroyingParticle.GetComponent <Renderer>().material.color;
parms = new TweenParms().Prop("color", new Color(oldColor.r, oldColor.b, oldColor.g, 0f)).Ease(EaseType.EaseOutQuart);
HOTween.To((destroyingParticle.GetComponent(typeof(TextMesh)) as TextMesh), 4f, parms);
parms = new TweenParms().Prop("fontSize", 150).Ease(EaseType.EaseOutQuart);
HOTween.To((destroyingParticle.GetComponent(typeof(TextMesh)) as TextMesh), 2f, parms);
Destroy(destroyingParticle, 5);
}
else
{
(_LevelTextValue.GetComponent(typeof(TextMesh)) as TextMesh).text = level.ToString();
}
}
public bool CheckChar(char c)
{
if (BubbleGuessingCore.CurrentStage == null)
{
return(false);
}
var rightChar = BubbleGuessingCore.RealFindingWord[BubbleGuessingCore.CurrentFindingCharIndex];
if (!char.ToUpper(c).Equals(char.ToUpper(rightChar)))
{
BubbleGuessingCore.UserData.ErrorCount++;
if (BubbleGuessingCore.UserData.ErrorCount >= BubbleGuessingCore.CurrentStage.MaxErrorCount)
{
//StartCoroutine(MoveNextStage(false));
}
UpdateErrorNumText();
return(false);
}
var tweenCharIndex = BubbleGuessingCore.UseTemplate ? BubbleGuessingCore.Expression.Template.IndexOf(Const.UNKNOWN_CHAR, BubbleGuessingCore.CurrentFindingCharIndex + 1) : BubbleGuessingCore.CurrentFindingCharIndex;
if (tweenCharIndex < 0)
{
tweenCharIndex = BubbleGuessingCore.CurrentFindingCharIndex;
}
if (!BubbleGuessingCore.UseTemplate)
{
HOTween.To(_charSpriteList[tweenCharIndex], _charShowDuration, "color", Color.white);
}
else
{
var param = new TweenParms();
param.Prop("scale", Vector3.zero);
param.OnComplete(() =>
{
var pos = _charSpriteList[tweenCharIndex].gameObject.transform.localPosition;
PoolManager.Despawn(_charSpriteList[tweenCharIndex].gameObject);
var go = PoolManager.Spawn(_findingCharObject, transform);
go.transform.localPosition = pos;
var charSprite = go.GetComponent <tk2dSprite>();
charSprite.SetSprite(Utils.GetCharSpriteName(BubbleGuessingCore.CurrentCharLibraryNameSequence, c));
charSprite.scale = Vector3.zero;
HOTween.To(charSprite, _charShowDuration, "scale", _findingCharObject.GetComponent <tk2dSprite>().scale);
});
HOTween.To(_charSpriteList[tweenCharIndex], _charShowDuration, param);
}
BubbleGuessingCore.CurrentFindingCharIndex++;
return(true);
}
public void DamageEffect()
{
damageSprite.color = new Color(1f, 1f, 1f, 0f);
damageSprite.enabled = true;
TweenParms parms = new TweenParms().Prop("color", new Color(1f, 1f, 1f, 0.5f)).Ease(EaseType.Linear).Loops(2, LoopType.Restart).OnComplete(DoneDamageEffect);
HOTween.To(damageSprite, 0.05f, parms);
}
// Do Empty Tile Move Down after matching 3
private void DoEmptyDown()
{
for (var x = 0; x < Data.tileWidth; x++)
{
for (var y = 0; y < Data.tileHeight; y++)
{
var thiscell = cells[x, y];
if (!thiscell.IsEmpty)
{
continue;
}
int y1;
for (y1 = y; y1 > 0; y1--)
{
DoSwapTile(FindTile(new TilePoint(x, y1)), FindTile(new TilePoint(x, y1 - 1)));
}
}
}
for (var x = 0; x < Data.tileWidth; x++)
{
int y;
for (y = Data.tileHeight - 1; y >= 0; y--)
{
var thiscell = cells[x, y];
if (thiscell.IsEmpty)
{
break;
}
}
if (y < 0)
{
continue;
}
var y1 = y;
for (y = 0; y <= y1; y++)
{
MatchItem tile = FindTile(new TilePoint(x, y));
tile.transform.localPosition = new Vector3(x * cellWidth, (y - (y1 + 1)) * -cellHeight, 0f);
tile.cell.SetRandomTile(6);
int spriteIndex = (int)tile.cell.cellType - 1;
tile.spriteIndex = spriteIndex;
Sprite sprite = sprites[spriteIndex];
SpriteRenderer renderer = tile.GetComponent <SpriteRenderer>();
renderer.sprite = sprite;
renderer.enabled = true;
}
}
foreach (MatchItem tile in tiles)
{
Vector3 pos = new Vector3(tile.point.x * cellWidth, tile.point.y * -cellHeight);
float dist = Vector3.Distance(tile.transform.localPosition, pos) * 0.01f;
dist = 1f;
TweenParms parms = new TweenParms().Prop("localPosition", pos).Ease(easeType);
HOTween.To(tile.transform, 0.5f * dist, parms);
}
StartCoroutine(CheckMatch3TileOnly(0.5f));
}
private void MoveStart(int index)
{
VTile startTile = cBattlefield.mapSearch.GetTile(this.mCharacter.CoordinateX, this.mCharacter.CoordinateY);
VTile endTile = cBattlefield.mapSearch.GetTile(index);
cBattlefield.MapMoveToPosition(this.mCharacter.CoordinateX, this.mCharacter.CoordinateY);
Holoville.HOTween.Core.TweenDelegate.TweenCallback moveComplete;
if (cBattlefield.battleMode == CBattlefield.BattleMode.move_after_attack)
{
moveComplete = () =>
{
this.mCharacter.CoordinateY = endTile.CoordinateY;
this.mCharacter.CoordinateX = endTile.CoordinateX;
cBattlefield.MapMoveToPosition(this.mCharacter.CoordinateX, this.mCharacter.CoordinateY);
cBattlefield.StartCoroutine(ActionOverNext());
};
}
else
{
moveComplete = () =>
{
this.mCharacter.Action = ActionType.idle;
cBattlefield.tilesManager.ClearCurrentTiles();
cBattlefield.battleMode = CBattlefield.BattleMode.move_end;
this.mCharacter.CoordinateY = endTile.CoordinateY;
this.mCharacter.CoordinateX = endTile.CoordinateX;
cBattlefield.MapMoveToPosition(this.mCharacter.CoordinateX, this.mCharacter.CoordinateY);
cBattlefield.tilesManager.ShowCharacterSkillArea(this.mCharacter);
cBattlefield.OpenOperatingMenu();
};
}
List <VTile> tiles = cBattlefield.aStar.Search(this.mCharacter, startTile, endTile);
this.mCharacter.roadLength = tiles.Count;
if (tiles.Count > 0)
{
cBattlefield.CloseOperatingMenu();
cBattlefield.tilesManager.ClearCurrentTiles();
this.mCharacter.Action = ActionType.move;
cBattlefield.battleMode = CBattlefield.BattleMode.moving;
Sequence sequence = new Sequence();
foreach (VTile tile in tiles)
{
TweenParms tweenParms = new TweenParms().Prop("X", tile.transform.localPosition.x, false).Prop("Y", tile.transform.localPosition.y, false).Ease(EaseType.Linear);
if (tile.Index == endTile.Index)
{
tweenParms.OnComplete(moveComplete);
}
sequence.Append(HOTween.To(this.mCharacter, 0.5f, tweenParms));
}
sequence.Play();
}
else
{
moveComplete();
}
}
/// <summary>
/// 摄像机开始阶段 移动
/// </summary>
private void EnterCameraMoveTask()
{
TweenParms parms = new TweenParms();
parms.Prop("position", mCamInfo.mEndPos);
Tweener tweener = HOTween.To(GameMethod.GetMainCamera.transform, mCamInfo.mNextTime, parms);
tweener.easeType = EaseType.Linear;
}
public void tweenAndDisable(IntVector2 newPosition, Stack <Tile> tilesPool)
{
_tilesPool = tilesPool;
TweenParms parms = new TweenParms();
parms.Prop("position", _getPosition(newPosition, -10));
parms.OnComplete(_deactivateGO);
HOTween.To(gameObject.transform, MOVE_TWEEN_DURATION, parms);
}
public void Hide()
{
var param = new TweenParms();
param.Prop("scale", Vector3.zero);
param.OnComplete(() => { _lwf.Play(_hideAnimName); Picture.gameObject.SetActive(false); });
HOTween.To(Picture, _pictureAnimDuration, param);
}
/// <summary>
/// 开始动作
/// </summary>
/// <returns><c>true</c>, if start run was actioned, <c>false</c> otherwise.</returns>
/// <param name="vCharacter">Current character.</param>
private void ActionStartRun(VCharacterBase vCharacter)
{
Debug.LogError("ActionStartRun");
System.Action actionStartEvent = () =>
{
//cBattlefield.MapMoveToPosition(currentCharacter.CoordinateX, currentCharacter.CoordinateY);
//vCharacter.direction = (vCharacter.mCharacter.coordinate.x > vCharacter.mCharacter.target.coordinate.x ? Direction.left : Direction.right);
vCharacter.direction = Global.mapSearch.GetDirection(vCharacter.mCharacter.coordinate, vCharacter.mCharacter.target.coordinate);
vCharacter.action = ActionType.attack;
App.Model.Master.MSkill skillMaster = vCharacter.mCharacter.currentSkill.master;
if (!string.IsNullOrEmpty(skillMaster.animation))
{
VTile vTile = Global.mapSearch.GetTile(vCharacter.mCharacter.target.coordinate);
//this.cBattlefield.CreateEffect(skillMaster.animation, vTile.transform);
}
};
if (vCharacter.mCharacter.currentSkill.master.effect.special == SkillEffectSpecial.back_thrust)
{
//回马枪
VTile currentTile = Global.mapSearch.GetTile(vCharacter.mCharacter.coordinate);
VTile targetTile = Global.mapSearch.GetTile(vCharacter.mCharacter.target.coordinate);
Direction direction = Global.mapSearch.GetDirection(targetTile, currentTile);
VTile backTile = Global.mapSearch.GetTile(currentTile, direction);
if (Global.charactersManager.GetCharacter(backTile.coordinate) != null)
{
actionStartEvent();
return;
}
Sequence sequence = new Sequence();
TweenParms tweenParms = new TweenParms()
.Prop("X", backTile.transform.localPosition.x, false)
.Prop("Y", backTile.transform.localPosition.y, false)
.Ease(EaseType.Linear);
TweenParms tweenParmsTarget = new TweenParms()
.Prop("X", currentTile.transform.localPosition.x, false)
.Prop("Y", currentTile.transform.localPosition.y, false)
.Ease(EaseType.Linear);
Holoville.HOTween.Core.TweenDelegate.TweenCallback moveComplete = () =>
{
vCharacter.mCharacter.coordinate.y = backTile.coordinate.y;
vCharacter.mCharacter.coordinate.x = backTile.coordinate.x;
vCharacter.mCharacter.target.coordinate.y = currentTile.coordinate.y;
vCharacter.mCharacter.target.coordinate.x = currentTile.coordinate.x;
actionStartEvent();
};
tweenParms.OnComplete(moveComplete);
VCharacterBase vTarget = Global.charactersManager.GetVCharacter(vCharacter.mCharacter.target);
sequence.Insert(0f, HOTween.To(vCharacter, 0.5f, tweenParms));
sequence.Insert(0f, HOTween.To(vTarget, 0.5f, tweenParmsTarget));
sequence.Play();
}
else
{
actionStartEvent();
}
}
// Swap Motion Animation
void DoSwapMotion(Transform a, Transform b)
{
Vector3 posA = a.localPosition;
Vector3 posB = b.localPosition;
TweenParms parms = new TweenParms().Prop("localPosition", posB).Ease(EaseType.EaseOutQuart);
HOTween.To(a, 0.2f, parms);
parms = new TweenParms().Prop("localPosition", posA).Ease(EaseType.EaseOutQuart);
HOTween.To(b, 0.2f, parms);
}
void strobeColour(Color toColor, Color returnColor, float duration)
{
TweenParms toParms = new TweenParms().Prop("color", toColor).Ease(EaseType.EaseOutExpo);
TweenParms returnParms = new TweenParms().Prop("color", returnColor).Ease(EaseType.EaseInOutExpo);
Sequence seq = new Sequence();
seq.Append(HOTween.To(renderer.material, duration / 2, toParms));
seq.Append(HOTween.To(renderer.material, duration / 2, returnParms));
seq.Play();
}
private void TweenToGround(Vector3 groundPos)
{
TweenParms parms = new TweenParms();
parms.Prop("position", groundPos);
parms.Ease(EaseType.Linear);
parms.OnComplete(OnTweenToGroundComplete);
HOTween.To(gameObject.transform, 0.5f, parms);
}
// Transition animation to store panel
void TransitToStoreMenu()
{
TweenParms parms = new TweenParms().Prop("position", new Vector3(-SpaceBetweenPanels * 2, _StorePanel.transform.position.y, _StorePanel.transform.position.z)).Ease(AnimationTypeOfPanels);
HOTween.To(_StorePanel.transform, AnimationDurationOfPanels, parms);
parms = new TweenParms().Prop("position", new Vector3(-SpaceBetweenPanels, _PowerPanel.transform.position.y, _PowerPanel.transform.position.z)).Ease(AnimationTypeOfPanels);
HOTween.To(_PowerPanel.transform, AnimationDurationOfPanels, parms);
parms = new TweenParms().Prop("position", new Vector3(0, _StorePanel.transform.position.y, _StorePanel.transform.position.z)).Ease(AnimationTypeOfPanels);
HOTween.To(_StorePanel.transform, AnimationDurationOfPanels, parms);
}
void Start()
{
Vector3 pos = transform.position - Vector3.up * 0.005f;
TweenParms parms = new TweenParms().Prop("position", pos).Ease(EaseType.Linear).Loops(-1, LoopType.Yoyo);
HOTween.To(transform, time, parms);
Quaternion rot = Quaternion.Euler(0f, 0f, 1f);
parms = new TweenParms().Prop("rotation", rot).Ease(EaseType.Linear).Loops(-1, LoopType.Yoyo);
HOTween.To(transform, time, parms);
}
/// <summary>
/// Enemies the attack.
/// </summary>
/// <param name="playerToAttack">The player to attack.</param>
/// <param name="playerToAttackDatas">The player to attack datas.</param>
public void EnemyAttack(GameObject playerToAttack, CharactersData playerToAttackDatas)
{
var go = sequenceEnumerator.Current.Second;
Sequence actions = new Sequence(new SequenceParms());
TweenParms parms = new TweenParms().Prop("position", playerToAttack.transform.position + new Vector3(SpaceBetweenCharacterAndEnemy, 0, 0)).Ease(EaseType.EaseOutQuart);
TweenParms parmsResetPlayerPosition = new TweenParms().Prop("position", go.transform.position).Ease(EaseType.EaseOutQuart);
actions.Append(HOTween.To(go.transform, 0.5f, parms));
actions.Append(HOTween.To(go.transform, 0.5f, parmsResetPlayerPosition));
actions.Play();
var enemyCharacterdatas = go.GetComponent <EnemyCharacterDatas> ();
int calculatedDamage = 0;
if (enemyCharacterdatas != null && selectedPlayerDatas != null)
{
switch (battlAction)
{
case EnumBattleAction.Weapon:
calculatedDamage = enemyCharacterdatas.Attack - playerToAttackDatas.Defense;
calculatedDamage = Mathf.Clamp(calculatedDamage, 0, calculatedDamage);
playerToAttackDatas.HP = Mathf.Clamp(playerToAttackDatas.HP - calculatedDamage, 0, playerToAttackDatas.HP - calculatedDamage);
ShowPopup("-" + calculatedDamage.ToString(), playerToAttack.transform.position);
playerToAttack.BroadcastMessage("SetHPValue", playerToAttackDatas.MaxHP <= 0 ?0 : playerToAttackDatas.HP * 100 / playerToAttackDatas.MaxHP);
Destroy(Instantiate(WeaponParticleEffect, playerToAttack.transform.localPosition, Quaternion.identity), 1.5f);
SoundManager.WeaponSound();
go.SendMessage("Animate", EnumBattleState.Attack.ToString());
playerToAttack.SendMessage("Animate", EnumBattleState.Hit.ToString());
break;
default:
calculatedDamage = enemyCharacterdatas.Attack - playerToAttackDatas.Defense;
calculatedDamage = Mathf.Clamp(calculatedDamage, 0, calculatedDamage);
playerToAttackDatas.HP = Mathf.Clamp(playerToAttackDatas.HP - calculatedDamage, 0, playerToAttackDatas.HP - calculatedDamage);
ShowPopup("-" + calculatedDamage.ToString(), playerToAttack.transform.position);
playerToAttack.BroadcastMessage("SetHPValue", playerToAttackDatas.MaxHP <= 0 ?0 : playerToAttackDatas.HP * 100 / playerToAttackDatas.MaxHP);
Destroy(Instantiate(WeaponParticleEffect, playerToAttack.transform.localPosition, Quaternion.identity), 1.5f);
SoundManager.WeaponSound();
go.SendMessage("Animate", EnumBattleState.Attack.ToString());
playerToAttack.SendMessage("Animate", EnumBattleState.Hit.ToString());
break;
}
}
if (playerToAttackDatas.HP <= 0)
{
KillCharacter(playerToAttack);
}
//selectedPlayer.SendMessage ("ChangeEnumCharacterState", battlection);
selectedEnemy = null;
}
