/// <summary>
/// Completely resets this Tweener, except its target
/// </summary>
override protected void Reset()
{
base.Reset();
if (HOTween.overwriteManager != null) HOTween.overwriteManager.RemoveTween(this);
isFrom = false;
plugins = null;
isPartialled = false;
pv3Path = null;
_delay = _elapsedDelay = delayCount = 0;
_pixelPerfect = false;
_speedBased = false;
_easeType = HOTween.defEaseType;
_easeOvershootOrAmplitude = HOTween.defEaseOvershootOrAmplitude;
_easePeriod = HOTween.defEasePeriod;
_originalEaseType = HOTween.defEaseType;
onPluginOverwritten = null;
onStepCompleteWParms = null;
onPluginOverwrittenParms = null;
}
/// <summary>
/// If this Tweener contains a <see cref="PlugVector3Path"/> tween,
/// defines a portion of that path to use and re-adapt to,
/// and rewinds/restarts the tween in its partial form (depending if it was paused or not).
/// </summary>
/// <param name="p_waypointId0">
/// Id of the new starting waypoint on the current path.
/// If you want to be sure you're targeting the first point in the path, pass -1
/// (this is because the first waypoint of the path might be different from the first waypoint you passed,
/// in case the target Transform was not already on the starting position, and thus needed to reach it).
/// </param>
/// <param name="p_waypointId1">
/// Id of the new ending waypoint on the current path
/// (-1 in case you want to target the ending waypoint of a closed path)
/// </param>
/// <param name="p_newDuration">
/// Tween duration of the partial path (if -1 auto-calculates the correct partial based on the original duration)
/// </param>
/// <param name="p_newEaseType">New EaseType to apply</param>
public Tweener UsePartialPath(int p_waypointId0, int p_waypointId1, float p_newDuration, EaseType p_newEaseType)
{
if (plugins.Count > 1) {
TweenWarning.Log("Applying a partial path on a Tweener (" + _target + ") with more than one plugin/property being tweened is not allowed");
return this;
}
if (pv3Path == null) {
// Get eventual plugVector3Path plugin
pv3Path = GetPlugVector3PathPlugin();
if (pv3Path == null) {
TweenWarning.Log("Tweener for " + _target + " contains no PlugVector3Path plugin");
return this;
}
}
// Startup the tween (if not already started) to store the path data.
Startup();
// Store original duration and easeType (if not already stored).
if (!isPartialled) {
isPartialled = true;
_originalDuration = _duration;
_originalEaseType = _easeType;
}
// Convert waypoints ids to path ids
int pathWaypointId0 = ConvertWaypointIdToPathId(pv3Path, p_waypointId0, true);
int pathWaypointId1 = ConvertWaypointIdToPathId(pv3Path, p_waypointId1, false);
// Get waypoints length percentage (needed for auto-duration and calculation of lookAhed)
float partialPerc = pv3Path.GetWaypointsLengthPercentage(pathWaypointId0, pathWaypointId1);
float partialStartPerc = pathWaypointId0 == 0 ? 0 : pv3Path.GetWaypointsLengthPercentage(0, pathWaypointId0);
// Assign new duration and ease
_duration = p_newDuration >= 0 ? p_newDuration : _originalDuration * partialPerc;
_easeType = p_newEaseType;
// Convert path to partial
pv3Path.SwitchToPartialPath(_duration, p_newEaseType, partialStartPerc, partialPerc);
// Re-Startup and restart
Startup(true);
if (!_isPaused)
Restart(true);
else {
Rewind(true, true);
}
return this; // Returns this so it can be directly used with WaitForCompletion coroutines
}
/// <summary>
/// Returns the correct id of the given waypoint, converted to path id.
/// </summary>
/// <param name="p_plugVector3Path">Vector3 path plugin to use</param>
/// <param name="p_waypointId">Waypoint to convert</param>
/// <param name="p_isStartingWp">If TRUE indicates that the given waypoint is the starting one,
/// otherwise it's the ending one</param>
/// <returns></returns>
static int ConvertWaypointIdToPathId(PlugVector3Path p_plugVector3Path, int p_waypointId, bool p_isStartingWp)
{
if (p_waypointId == -1) return p_isStartingWp ? 1 : p_plugVector3Path.path.path.Length - 2;
if (p_plugVector3Path.hasAdditionalStartingP) return p_waypointId + 2;
return p_waypointId + 1;
}
//disables any running movement methods
public void Stop()
{
//exit waypoint coroutine
StopAllCoroutines();
//destroy current HOTween movement component
HOTween.Kill(transform);
plugPath = null;
tween = null;
//play idle animation if set
PlayIdle();
}
//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);
}
//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);
//differ between TimeValue like mentioned above at enum TimeValue
//use speed with linear easing
if (timeValue == TimeValue.speed)
tParms.SpeedBased();
//else, use time value with linear easing
tParms.Ease(EaseType.Linear);
tParms.OnComplete(OnPathComplete);
//create a new tween, move this gameobject with given arguments
tween = HOTween.To(transform, maxSpeed, tParms);
}
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();
}
