public void Test_TryGetAbsolute_OK(string pathString, PathMode pathMode) {
string failureReason;
var isAbsolute = pathMode == PathMode.Absolute;
IAbsoluteDirectoryPath absoluteDirectoryPath;
Assert.IsTrue(pathString.TryGetAbsoluteDirectoryPath(out absoluteDirectoryPath) == isAbsolute);
Assert.IsTrue(pathString.TryGetAbsoluteDirectoryPath(out absoluteDirectoryPath, out failureReason) == isAbsolute);
var isRelative = pathMode == PathMode.Relative;
IRelativeDirectoryPath relativeDirectoryPath;
Assert.IsTrue(pathString.TryGetRelativeDirectoryPath(out relativeDirectoryPath) == isRelative);
Assert.IsTrue(pathString.TryGetRelativeDirectoryPath(out relativeDirectoryPath, out failureReason) == isRelative);
var isEnvVar = pathMode == PathMode.EnvVar;
IEnvVarDirectoryPath envVarDirectoryPath;
Assert.IsTrue(pathString.TryGetEnvVarDirectoryPath(out envVarDirectoryPath) == isEnvVar);
Assert.IsTrue(pathString.TryGetEnvVarDirectoryPath(out envVarDirectoryPath, out failureReason) == isEnvVar);
var isVariable = pathMode == PathMode.Variable;
IVariableDirectoryPath variableDirectoryPath;
Assert.IsTrue(pathString.TryGetVariableDirectoryPath(out variableDirectoryPath) == isVariable);
Assert.IsTrue(pathString.TryGetVariableDirectoryPath(out variableDirectoryPath, out failureReason) == isVariable);
IDirectoryPath directoryPath;
Assert.IsTrue(pathString.TryGetDirectoryPath(out directoryPath));
Assert.IsTrue(pathString.TryGetDirectoryPath(out directoryPath, out failureReason));
var pathStringFile = pathString + @"\File.txt";
IAbsoluteFilePath absoluteFilePath;
Assert.IsTrue(pathStringFile.TryGetAbsoluteFilePath(out absoluteFilePath) == isAbsolute);
Assert.IsTrue(pathStringFile.TryGetAbsoluteFilePath(out absoluteFilePath, out failureReason) == isAbsolute);
Assert.IsFalse(pathString.TryGetAbsoluteFilePath(out absoluteFilePath));
Assert.IsFalse(pathString.TryGetAbsoluteFilePath(out absoluteFilePath, out failureReason));
IRelativeFilePath relativeFilePath;
Assert.IsTrue(pathStringFile.TryGetRelativeFilePath(out relativeFilePath) == isRelative);
Assert.IsTrue(pathStringFile.TryGetRelativeFilePath(out relativeFilePath, out failureReason) == isRelative);
Assert.IsFalse(pathString.TryGetRelativeFilePath(out relativeFilePath));
Assert.IsFalse(pathString.TryGetRelativeFilePath(out relativeFilePath, out failureReason));
IEnvVarFilePath envVarFilePath;
Assert.IsTrue(pathStringFile.TryGetEnvVarFilePath(out envVarFilePath) == isEnvVar);
Assert.IsTrue(pathStringFile.TryGetEnvVarFilePath(out envVarFilePath, out failureReason) == isEnvVar);
Assert.IsFalse(pathString.TryGetEnvVarFilePath(out envVarFilePath));
Assert.IsFalse(pathString.TryGetEnvVarFilePath(out envVarFilePath, out failureReason));
IVariableFilePath variableFilePath;
Assert.IsTrue(pathStringFile.TryGetVariableFilePath(out variableFilePath) == isVariable);
Assert.IsTrue(pathStringFile.TryGetVariableFilePath(out variableFilePath, out failureReason) == isVariable);
Assert.IsFalse(pathString.TryGetVariableFilePath(out variableFilePath));
Assert.IsFalse(pathString.TryGetVariableFilePath(out variableFilePath, out failureReason));
IFilePath filePath;
Assert.IsTrue(pathStringFile.TryGetFilePath(out filePath));
Assert.IsTrue(pathStringFile.TryGetFilePath(out filePath, out failureReason));
Assert.IsFalse(pathString.TryGetFilePath(out filePath));
Assert.IsFalse(pathString.TryGetFilePath(out filePath, out failureReason));
}
public static bool DoesPathHasThisPathMode(BasePath basePath, PathMode pathMode)
{
if (basePath == null) {
throw new ArgumentNullException();
}
return (basePath.IsAbsolutePath && pathMode == PathMode.Absolute) ||
(basePath.IsRelativePath && pathMode == PathMode.Relative);
}
// Extra goodies
public Tweener DOCircle(int charIndex, float radius, float duration, int pathPoints = 8, PathType pathType = PathType.CatmullRom,
PathMode pathMode = PathMode.Full3D, int resolution = 10, Color?gizmoColor = null)
{
var tweenPath = new Vector3[pathPoints];
for (var i = 0; i < tweenPath.Length; ++i)
{
var theta = Mathf.Lerp(0, 2 * Mathf.PI, i / (float)(tweenPath.Length - 1));
tweenPath[i] = new Vector3(radius * Mathf.Cos(theta), radius * Mathf.Sin(theta), 0);
}
//The first point of the path is the transform itself
GetProxyTransform(charIndex).localPosition = tweenPath[0];
SetPositionOffset(charIndex, tweenPath[0]);
return(DOLocalPath(charIndex, tweenPath, duration, pathType, pathMode, resolution, gizmoColor, true));
}
public Path(ShareManager shareManager, ILocation start, ILocation end, PathMode pathMode, MacroSync macro)
{
this.shareManager = shareManager;
this.pathMode = pathMode;
this.macro = macro;
if (pathMode == PathMode.Advanced)
{
ZMO.Mine = true;
}
else
{
ZMO.Mine = false;
}
radius = new IRadius(start, end);
this.shareManager.SetArea(radius);
}
/// <summary>
/// Tweens a Rigidbody's position through the given path waypoints, using the chosen path algorithm.
/// Also stores the Rigidbody as the tween's target so it can be used for filtered operations.
/// <para>NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened.</para>
/// <para>
/// BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug).
/// If you plan to publish there you should use a regular transform.DOPath.
/// </para>
/// </summary>
/// <param name="path">The waypoints to go through</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="pathType">
/// The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier
/// (curved with control points)
/// </param>
/// <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
/// <param name="resolution">
/// The resolution of the path (useless in case of Linear paths): higher resolutions make for more detailed curved
/// paths but are more expensive.
/// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints
/// </param>
/// <param name="gizmoColor">
/// The color of the path (shown when gizmos are active in the Play panel and the tween is
/// running)
/// </param>
public static TweenerCore <Vector3, Path, PathOptions> DOPath(
this Rigidbody target, Vector3[] path, float duration, PathType pathType = PathType.Linear,
PathMode pathMode = PathMode.Full3D, int resolution = 10, Color?gizmoColor = null
)
{
if (resolution < 1)
{
resolution = 1;
}
TweenerCore <Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => target.position, target.MovePosition, new Path(pathType, path, resolution, gizmoColor), duration)
.SetTarget(target).SetUpdate(UpdateType.Fixed);
t.plugOptions.isRigidbody = true;
t.plugOptions.mode = pathMode;
return(t);
}
public Mine(ShareManager shareManager, Mode mode, PathMode pathMode, ushort[] ignore, MacroSync macro)
{
this.shareManager = shareManager;
this.mode = mode;
this.pathMode = pathMode;
this.ignore = ignore;
this.macro = macro;
if (pathMode == PathMode.Advanced)
{
MO.Mine = true;
}
else
{
MO.Mine = false;
}
}
public Tweener DOCircle(int charIndex, float radius, float duration, int pathPoints = 8, PathType pathType = PathType.CatmullRom,
PathMode pathMode = PathMode.Full3D, int resolution = 10, Color?gizmoColor = null)
{
NotifyActiveTransformTween();
Vector3[] tweenPath = new Vector3[pathPoints + 1];
Vector3 origin = Vector3.zero;
for (int i = 0; i < pathPoints; ++i)
{
float theta = Mathf.Lerp(0, 2 * Mathf.PI, i / (float)pathPoints);
tweenPath[i] = new Vector3(radius * Mathf.Cos(theta), radius * Mathf.Sin(theta), 0) + origin;
}
tweenPath[pathPoints] = new Vector3(radius, 0, 0) + origin;
SetOffsetPosition(charIndex, tweenPath[0]);
return(DOLocalPath(charIndex, tweenPath, duration, pathType, pathMode, resolution, gizmoColor));
}
public void CopyFrom(TweenParam param)
{
Type = param.Type;
Identifier = param.Identifier;
CopyFromToValueFrom(param);
CurveMode = param.CurveMode;
CurveTarget = param.CurveTarget;
Curve = param.Curve;
CurveX = param.CurveX;
CurveY = param.CurveY;
CurveZ = param.CurveZ;
CurveW = param.CurveW;
PlayType = param.PlayType;
EaseType = param.EaseType;
LoopCount = param.LoopCount;
Duration = param.Duration;
Interval = param.Interval;
SpeedBased = param.SpeedBased;
StartDelay = param.StartDelay;
AutoPlay = param.AutoPlay;
UpdateType = param.UpdateType;
TimeScale = param.TimeScale;
TimeSmooth = param.TimeSmooth;
SelfScale = param.SelfScale;
AutoKill = param.AutoKill;
WorldSpace = param.WorldSpace;
ColorLerpMode = param.ColorLerpMode;
ColorBlockType = param.ColorBlockType;
PathMode = param.PathMode;
ShakeArgs = param.ShakeArgs;
ResourcesIndex = param.ResourcesIndex;
ResourcesKey = param.ResourcesKey;
OnPlay = param.OnPlay;
OnStop = param.OnStop;
OnValueFloat = param.OnValueFloat;
OnValueVector2 = param.OnValueVector2;
OnValueVector3 = param.OnValueVector3;
OnValueColor = param.OnValueColor;
}
/// <summary>Tweens a Rigidbody's localPosition through the given path waypoints, using the chosen path algorithm.
/// Also stores the Rigidbody as the tween's target so it can be used for filtered operations
/// <para>NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened.</para>
/// <para>BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug).
/// If you plan to publish there you should use a regular transform.DOLocalPath.</para></summary>
/// <param name="path">The waypoint to go through</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="pathType">The type of path: Linear (straight path) or CatmullRom (curved CatmullRom path)</param>
/// <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
/// <param name="resolution">The resolution of the path: higher resolutions make for more detailed curved paths but are more expensive.
/// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
/// <param name="gizmoColor">The color of the path (shown when gizmos are enabled in the Play panel and the tween is running)</param>
public static TweenerCore <Vector3, Path, PathOptions> DOLocalPath(
this Rigidbody target, Vector3[] path, float duration, PathType pathType = PathType.Linear,
PathMode pathMode = PathMode.Full3D, int resolution = 10, Color?gizmoColor = null
)
{
if (resolution < 1)
{
resolution = 1;
}
Transform trans = target.transform;
TweenerCore <Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), new Path(pathType, path, resolution, gizmoColor), duration)
.SetTarget(target).SetUpdate(UpdateType.Fixed);
t.plugOptions.isRigidbody = true;
t.plugOptions.mode = pathMode;
t.plugOptions.useLocalPosition = true;
return(t);
}
/// <summary>
/// This will erase all saved files
/// </summary>
public void EraseAllSavedData(PathMode pathMode = PathMode.PLAYER)
{
if (pathMode == PathMode.PLAYER)
{
if (Directory.Exists(automaticPlayerSavedDataDirectoryPath))
{
Directory.Delete(automaticPlayerSavedDataDirectoryPath, true);
}
}
else
{
if (Directory.Exists(Application.streamingAssetsPath + "/" + PersistentDataSystemDirectory))
{
Directory.Delete(Application.streamingAssetsPath + "/" + PersistentDataSystemDirectory, true);
}
}
savedDataDictionnary.Clear();
}
protected override void JsonTo(JsonData json)
{
if (json.Contains("beginPosition"))
{
BeginPosition = JTweenUtils.JsonToVector3(json["beginPosition"]);
}
// end if
if (json.Contains("path"))
{
JsonData pathJson = json["path"];
m_toPath = new Vector3[pathJson.Count];
for (int i = 0, imax = pathJson.Count; i < imax; ++i)
{
m_toPath[i] = JTweenUtils.JsonToVector3(pathJson[i]);
} // end for
} // end if
if (json.Contains("type"))
{
m_pathType = (PathType)json["type"].ToInt32();
}
// end if
if (json.Contains("mode"))
{
m_pathMode = (PathMode)json["mode"].ToInt32();
}
// end if
if (json.Contains("resolution"))
{
m_resolution = json["resolution"].ToInt32();
}
// end if
if (json.Contains("gizmoColor"))
{
m_gizmoColor = JTweenUtils.JsonToColor(json["gizmoColor"]);
}
// end if
if (json.Contains("showGizmo"))
{
m_showGizmo = json["showGizmo"].ToBool();
}
// end if
Restore();
}
protected override void JsonTo(IJsonNode json)
{
if (json.Contains("beginPosition"))
{
BeginPosition = JTweenUtils.JsonToVector3(json.GetNode("beginPosition"));
}
// end if
if (json.Contains("path"))
{
IJsonNode pathJson = json.GetNode("path");
m_toPath = new Vector3[pathJson.Count];
for (int i = 0, imax = pathJson.Count; i < imax; ++i)
{
m_toPath[i] = JTweenUtils.JsonToVector3(pathJson[i]);
} // end for
} // end if
if (json.Contains("type"))
{
m_pathType = (PathType)json.GetInt("type");
}
// end if
if (json.Contains("mode"))
{
m_pathMode = (PathMode)json.GetInt("mode");
}
// end if
if (json.Contains("resolution"))
{
m_resolution = json.GetInt("resolution");
}
// end if
if (json.Contains("gizmoColor"))
{
m_gizmoColor = JTweenUtils.JsonToColor(json.GetNode("gizmoColor"));
}
// end if
if (json.Contains("showGizmo"))
{
m_showGizmo = json.GetBool("showGizmo");
}
// end if
Restore();
}
// Override for UGUI
public Tweener DOCircleUGUI(Camera viewCamera, int charIndex, float radius, float duration, int pathPoints = 8, PathType pathType = PathType.CatmullRom,
PathMode pathMode = PathMode.Full3D, int resolution = 10, Color?gizmoColor = null)
{
RectTransform rectTransform = GetComponent <RectTransform>();
var tweenPath = new Vector3[pathPoints + 1];
for (var i = 0; i < tweenPath.Length; ++i)
{
var theta = Mathf.Lerp(0, 2 * Mathf.PI, i / (float)(tweenPath.Length - 1));
Vector3 charWorldPosition = viewCamera.WorldToScreenPoint(transform.position);;
Vector3 worldPosition;
RectTransformUtility.ScreenPointToWorldPointInRectangle(rectTransform, new Vector3(radius * Mathf.Cos(theta) + charWorldPosition.x, radius * Mathf.Sin(theta) + charWorldPosition.y, 0), viewCamera, out worldPosition);
tweenPath[i] = worldPosition;
}
SetPositionOffset(charIndex, tweenPath[0]);
return(DOPath(charIndex, tweenPath, duration, pathType, pathMode, resolution, gizmoColor));
}
/// <summary>
/// Return a T type in the persistent data dictionnary.
/// If T type is not present in the dictionnary, this function will try to load saved files.
/// Load saved file work only for multiple file system.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="maxNumber"></param>
/// <returns></returns>
public List <T> GetAllSavedData <T>(int maxNumber = int.MaxValue, PathMode pathMode = PathMode.PLAYER) where T : SavedData, new()
{
List <SavedData> savedDataList;
savedDataDictionnary.TryGetValue(typeof(T), out savedDataList);
if (savedDataList != null)
{
return(savedDataList as List <T>);
}
//This data is not in the dictionnary
else
{
//It's not in the dictionnary, so if use multiple file LoadIt with the file
if (saveMode == SaveMode.MULTIPLE_FILE)
{
return(LoadAllSavedData <T>(maxNumber, pathMode));
}
}
return(new List <T>());
}
public static string GetCygpath(string path, PathMode target)
{
string convertedPath;
if (!CygpathCache.ContainsKey(target))
{
CygpathCache[target] = new Dictionary <string, string>();
}
if (!CygpathCache[target].TryGetValue(path, out convertedPath))
{
lock (CygpathProcesses)
{
Process process;
if (!CygpathProcesses.TryGetValue(target, out process) || process.HasExited)
{
var targetArgument = target == PathMode.Windows ? "-w"
: target == PathMode.Unix ? "-u"
: target == PathMode.Cygwin ? "-u"
: string.Empty;
var processStartInfo = new ProcessStartInfo("cygpath", "-f - " + targetArgument)
{
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardInput = true,
RedirectStandardOutput = true,
};
process = CygpathProcesses[target] = Process.Start(processStartInfo);
}
process.StandardInput.WriteLine(path);
convertedPath = process.StandardOutput.ReadLine();
}
}
return(convertedPath);
}
public static string GetCygpath(string path, PathMode target)
{
string convertedPath;
if (!CygpathCache.ContainsKey(target))
{
CygpathCache[target] = new Dictionary<string,string>();
}
if (!CygpathCache[target].TryGetValue(path, out convertedPath))
{
lock (CygpathProcesses)
{
Process process;
if (!CygpathProcesses.TryGetValue(target, out process) || process.HasExited)
{
var targetArgument = target == PathMode.Windows ? "-w"
: target == PathMode.Unix ? "-u"
: target == PathMode.Cygwin ? "-u"
: string.Empty;
var processStartInfo = new ProcessStartInfo("cygpath", "-f - "+targetArgument)
{
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardInput = true,
RedirectStandardOutput = true,
};
process = CygpathProcesses[target] = Process.Start(processStartInfo);
}
process.StandardInput.WriteLine(path);
convertedPath = process.StandardOutput.ReadLine();
}
}
return convertedPath;
}
/// <summary>Tweens a Rigidbody2D's position through the given path waypoints, using the chosen path algorithm.
/// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations.
/// <para>NOTE: to tween a Rigidbody2D correctly it should be set to kinematic at least while being tweened.</para>
/// <para>BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug).
/// If you plan to publish there you should use a regular transform.DOPath.</para></summary>
/// <param name="path">The waypoints to go through</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="pathType">The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points)</param>
/// <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
/// <param name="resolution">The resolution of the path (useless in case of Linear paths): higher resolutions make for more detailed curved paths but are more expensive.
/// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
/// <param name="gizmoColor">The color of the path (shown when gizmos are active in the Play panel and the tween is running)</param>
public static TweenerCore <Vector3, Path, PathOptions> DOPath(
this Rigidbody2D target, Vector2[] path, float duration, PathType pathType = PathType.Linear,
PathMode pathMode = PathMode.Full3D, int resolution = 10, Color?gizmoColor = null
)
{
if (resolution < 1)
{
resolution = 1;
}
int len = path.Length;
Vector3[] path3D = new Vector3[len];
for (int i = 0; i < len; ++i)
{
path3D[i] = path[i];
}
TweenerCore <Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => target.position, x => target.MovePosition(x), new Path(pathType, path3D, resolution, gizmoColor), duration)
.SetTarget(target).SetUpdate(UpdateType.Fixed);
t.plugOptions.isRigidbody = true;
t.plugOptions.mode = pathMode;
return(t);
}
public override void Reset()
{
base.Reset();
gameObject = null;
duration = new FsmFloat {
UseVariable = false
};
setSpeedBased = new FsmBool {
UseVariable = false, Value = false
};
pathType = PathType.Linear;
pathMode = PathMode.Full3D;
resolution = new FsmInt {
UseVariable = false, Value = 10
};
gizmoColor = new FsmColor {
UseVariable = false
};
closePath = new FsmBool {
UseVariable = false, Value = false
};
lockPosition = AxisConstraint.None;
lockRotation = AxisConstraint.None;
lookAt = LookAt.nothing;
lookAtPosition = new FsmVector3 {
UseVariable = false, Value = Vector3.zero
};
lookAtTarget = new FsmGameObject {
UseVariable = false, Value = null
};
lookAhead = new FsmFloat {
UseVariable = false, Value = 0
};
forwardDirection = new FsmVector3 {
UseVariable = false, Value = Vector3.forward
};
up = new FsmVector3 {
UseVariable = false, Value = Vector3.up
};
startEvent = null;
finishEvent = null;
finishImmediately = new FsmBool {
UseVariable = false, Value = false
};
startDelay = new FsmFloat {
Value = 0
};
easeType = Ease.Linear;
loops = new FsmInt {
Value = 0
};
loopType = LoopType.Restart;
autoKillOnCompletion = new FsmBool {
Value = true
};
recyclable = new FsmBool {
Value = false
};
updateType = UpdateType.Normal;
isIndependentUpdate = new FsmBool {
Value = false
};
debugThis = new FsmBool {
Value = false
};
}
public static T SetPathMode <T, TComponent>(this T tween, PathMode pathMode) where T : TweenQueueVector3Base <TComponent> where TComponent : Component
{
tween.PathMode = pathMode;
return(tween);
}
public void Test_TryGetAbsolute_OK(string pathString, PathMode pathMode)
{
string failureReason;
var isAbsolute = pathMode == PathMode.Absolute;
IAbsoluteDirectoryPath absoluteDirectoryPath;
Assert.IsTrue(pathString.TryGetAbsoluteDirectoryPath(out absoluteDirectoryPath) == isAbsolute);
Assert.IsTrue(pathString.TryGetAbsoluteDirectoryPath(out absoluteDirectoryPath, out failureReason) == isAbsolute);
var isRelative = pathMode == PathMode.Relative;
IRelativeDirectoryPath relativeDirectoryPath;
Assert.IsTrue(pathString.TryGetRelativeDirectoryPath(out relativeDirectoryPath) == isRelative);
Assert.IsTrue(pathString.TryGetRelativeDirectoryPath(out relativeDirectoryPath, out failureReason) == isRelative);
var isEnvVar = pathMode == PathMode.EnvVar;
IEnvVarDirectoryPath envVarDirectoryPath;
Assert.IsTrue(pathString.TryGetEnvVarDirectoryPath(out envVarDirectoryPath) == isEnvVar);
Assert.IsTrue(pathString.TryGetEnvVarDirectoryPath(out envVarDirectoryPath, out failureReason) == isEnvVar);
var isVariable = pathMode == PathMode.Variable;
IVariableDirectoryPath variableDirectoryPath;
Assert.IsTrue(pathString.TryGetVariableDirectoryPath(out variableDirectoryPath) == isVariable);
Assert.IsTrue(pathString.TryGetVariableDirectoryPath(out variableDirectoryPath, out failureReason) == isVariable);
IDirectoryPath directoryPath;
Assert.IsTrue(pathString.TryGetDirectoryPath(out directoryPath));
Assert.IsTrue(pathString.TryGetDirectoryPath(out directoryPath, out failureReason));
var pathStringFile = pathString + @"\File.txt";
IAbsoluteFilePath absoluteFilePath;
Assert.IsTrue(pathStringFile.TryGetAbsoluteFilePath(out absoluteFilePath) == isAbsolute);
Assert.IsTrue(pathStringFile.TryGetAbsoluteFilePath(out absoluteFilePath, out failureReason) == isAbsolute);
Assert.IsFalse(pathString.TryGetAbsoluteFilePath(out absoluteFilePath));
Assert.IsFalse(pathString.TryGetAbsoluteFilePath(out absoluteFilePath, out failureReason));
IRelativeFilePath relativeFilePath;
Assert.IsTrue(pathStringFile.TryGetRelativeFilePath(out relativeFilePath) == isRelative);
Assert.IsTrue(pathStringFile.TryGetRelativeFilePath(out relativeFilePath, out failureReason) == isRelative);
Assert.IsFalse(pathString.TryGetRelativeFilePath(out relativeFilePath));
Assert.IsFalse(pathString.TryGetRelativeFilePath(out relativeFilePath, out failureReason));
IEnvVarFilePath envVarFilePath;
Assert.IsTrue(pathStringFile.TryGetEnvVarFilePath(out envVarFilePath) == isEnvVar);
Assert.IsTrue(pathStringFile.TryGetEnvVarFilePath(out envVarFilePath, out failureReason) == isEnvVar);
Assert.IsFalse(pathString.TryGetEnvVarFilePath(out envVarFilePath));
Assert.IsFalse(pathString.TryGetEnvVarFilePath(out envVarFilePath, out failureReason));
IVariableFilePath variableFilePath;
Assert.IsTrue(pathStringFile.TryGetVariableFilePath(out variableFilePath) == isVariable);
Assert.IsTrue(pathStringFile.TryGetVariableFilePath(out variableFilePath, out failureReason) == isVariable);
Assert.IsFalse(pathString.TryGetVariableFilePath(out variableFilePath));
Assert.IsFalse(pathString.TryGetVariableFilePath(out variableFilePath, out failureReason));
IFilePath filePath;
Assert.IsTrue(pathStringFile.TryGetFilePath(out filePath));
Assert.IsTrue(pathStringFile.TryGetFilePath(out filePath, out failureReason));
Assert.IsFalse(pathString.TryGetFilePath(out filePath));
Assert.IsFalse(pathString.TryGetFilePath(out filePath, out failureReason));
}
public Tweener DOLocalPath(int charIndex, Vector3[] path, float duration, PathType pathType = PathType.Linear,
PathMode pathMode = PathMode.Full3D, int resolution = 10, Color?gizmoColor = null, bool closePath = false)
{
return(MonitorTransformTween(GetProxyTransform(charIndex).DOLocalPath(path, duration, pathType, pathMode, resolution, gizmoColor).SetOptions(closePath)));
}
private static GraphicsPath GetEllipsePath(Rectangle rect, int r, int reflectionHeight, PathMode mode, RoundedCorners corners)
{
GraphicsPath path = new GraphicsPath();
switch (mode)
{
case PathMode.All:
path.AddEllipse(rect);
break;
case PathMode.Top:
path.AddArc(rect, 180, 180);
break;
case PathMode.Bottom:
path.AddArc(rect, 0, 180);
break;
}
path.CloseFigure();
return path;
}
public static TweenerCore <Vector3, Path, PathOptions> CreateDOTweenPathTween(MonoBehaviour target, bool tweenRigidbody, bool isLocal, Path path, float duration, PathMode pathMode)
{
Rigidbody rigidbody = (!tweenRigidbody) ? null : target.GetComponent <Rigidbody>();
if (tweenRigidbody && rigidbody != null)
{
return((!isLocal) ? rigidbody.DOPath(path, duration, pathMode) : rigidbody.DOLocalPath(path, duration, pathMode));
}
return((!isLocal) ? target.transform.DOPath(path, duration, pathMode) : target.transform.DOLocalPath(path, duration, pathMode));
}
internal static TweenerCore <Vector3, Path, PathOptions> DOLocalPath(this Rigidbody target, Path path, float duration, PathMode pathMode = PathMode.Full3D)
{
Transform trans = target.transform;
TweenerCore <Vector3, Path, PathOptions> tweenerCore = DOTween.To(PathPlugin.Get(), () => trans.localPosition, delegate(Vector3 x)
{
target.MovePosition((!(trans.parent == null)) ? trans.parent.TransformPoint(x) : x);
}, path, duration).SetTarget(target);
tweenerCore.plugOptions.isRigidbody = true;
tweenerCore.plugOptions.mode = pathMode;
tweenerCore.plugOptions.useLocalPosition = true;
return(tweenerCore);
}
public void Test_PathModeOk(string pathString, PathMode pathMode) {
IDirectoryPath path = pathString.ToDirectoryPath();
Assert.IsFalse(path.IsFilePath);
Assert.IsTrue(path.IsDirectoryPath);
Assert.IsTrue(path.PathMode == pathMode);
Assert.IsTrue(path.IsAbsolutePath == (pathMode == PathMode.Absolute));
Assert.IsTrue(path.IsRelativePath == (pathMode == PathMode.Relative));
Assert.IsTrue(path.IsVariablePath == (pathMode == PathMode.Variable));
Assert.IsTrue(path.IsEnvVarPath == (pathMode == PathMode.EnvVar));
}
/// <summary>Tweens a Transform's localPosition through the given path waypoints, using the chosen path algorithm.
/// Also stores the transform as the tween's target so it can be used for filtered operations</summary>
/// <param name="path">The waypoint to go through</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="pathType">The type of path: Linear (straight path) or CatmullRom (curved CatmullRom path)</param>
/// <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
/// <param name="resolution">The resolution of the path: higher resolutions make for more detailed curved paths but are more expensive.
/// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
/// <param name="gizmoColor">The color of the path (shown when gizmos are active in the Play panel and the tween is running)</param>
public static TweenerCore<Vector3, Path, PathOptions> DOLocalPath(
this Transform target, Vector3[] path, float duration, PathType pathType = PathType.Linear,
PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null
)
{
if (resolution < 1) resolution = 1;
TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => target.localPosition, x => target.localPosition = x, new Path(pathType, path, resolution, gizmoColor), duration)
.SetTarget(target);
t.plugOptions.mode = pathMode;
return t;
}
/// <summary>
/// Initializes the configuration subsystem.
/// </summary>
/// <param name="producer"></param>
/// <param name="product"></param>
/// <param name="pathMode"></param>
/// <param name="configurationRoot"></param>
/// <returns>true if initilized, false if aborted as it already was initialized</returns>
public static Boolean Initialize(
String producer = null,
String product = null,
PathMode pathMode = PathMode.Simple,
String configurationRoot = null
)
{
// First: check for redundant call. This is a one off only.
var repeated = Interlocked.Exchange(ref _isInitialized, 1);
if (repeated != 0)
{
return(false);
}
// Next: we generate the container name out of producer and product.
var builder = new StringBuilder();
if (!String.IsNullOrWhiteSpace(producer))
{
builder.Append(producer.Trim()).Append(".");
}
if (!String.IsNullOrWhiteSpace(product))
{
switch (pathMode)
{
case PathMode.Simple:
builder.Append(product.Trim()).Append(".");
break;
}
}
if (builder.Length > 1)
{
builder.Length -= 1;
}
if (builder.Length == 0)
{
throw new ArgumentException("producer or product must be set");
}
Container = builder.ToString();
// Next: Product
if (!String.IsNullOrWhiteSpace(product))
{
switch (pathMode)
{
case PathMode.Prefix:
Product = product;
break;
}
}
// Next: find the root folder where the configuration is stored. This is named by the Container
// variable. It can be in various places, including explicit pointing us to some - so we need to search.
// If we have a container explicit, we use that one.
if (!String.IsNullOrWhiteSpace(configurationRoot))
{
ConfigurationRoot = configurationRoot;
}
ConfigurationRoot = Path.GetFullPath(GetConfigurationRoot());
// Now, the variant.
Variant = GetVariant();
return(true);
}
private static GraphicsPath GetNextPath(Rectangle rect, int r, int reflectionHeight, PathMode mode, RoundedCorners corners)
{
GraphicsPath path = new GraphicsPath();
int x = rect.X, y = rect.Y, w = rect.Width, h = rect.Height;
int h2 = rect.Height / 2;
int offset = (h - h2 * 2);
int r2 = r / 2;
if (mode != PathMode.Bottom)
{
path.AddArc(x, y, r, r, 180, 90);
path.AddArc(x + w - h2 - r2, y, r, r, 270, 45);
path.AddArc(x + w - r, y + h2 - r2, r, r, 270 + 45, 45);
}
RectangleF gr = new RectangleF(x, y + r, w, h - r);
if (mode != PathMode.All)
{
Point pt1 = new Point(x + w, y + h2);
Point pt2 = new Point(x, y + h2);
if (mode == PathMode.Top)
{
path.AddLine(pt1, pt2);
}
else
{
path.AddLine(pt2, pt1);
}
}
if (mode != PathMode.Top)
{
path.AddArc(x + w - r, y + h2 - r2, r, r, 0, 45);
path.AddArc(x + w - h2 - r2 + offset, y + h - r, r, r, 45, 45);
path.AddArc(x, y + h - r, r, r, 90, 90);
}
path.CloseFigure();
return path;
}
/// <summary>
/// Load saved data of the specified type, if no such file exist, one saved data will be Init.
/// </summary>
/// <param name="type"></param>
/// <returns>null is used with single file system<</returns>
SavedData LoadSavedData(Type type, PathMode pathMode = PathMode.PLAYER)
{
if (saveMode == SaveMode.SINGLE_FILE)
{
return(null);
}
SavedData savedData = null;
ClearSavedDataList(type);
try
{
string dataPath;
if (pathMode == PathMode.PLAYER)
{
dataPath = System.IO.Path.Combine(System.IO.Path.Combine(multiplePlayerFilesDirectoryPath, type.Name), "0");
}
else
{
dataPath = System.IO.Path.Combine(System.IO.Path.Combine(multipleDefaultFilesDirectoryPath, type.Name), "0");
}
if (type.GetInterface(typeof(IFullSerializationControl).Name) != null)
{
dataPath += ControlledSerializationFileExtension;
}
else
{
dataPath += AutomaticSerializationFileExtension;
}
savedData = LoadSavedData(dataPath, 0, pathMode == PathMode.DEFAULT);
if (savedData == null)
{
throw new System.ArgumentException("No data of this type or incompatible version");
}
else if (pathMode == PathMode.DEFAULT)
{
savedData.OnDefaultDataLoaded();
}
}
catch
{
#if DEBUG || UNITY_EDITOR
Debug.Log("Load save at path: " + pathMode);
#endif
if (pathMode == PathMode.PLAYER)
{
return(LoadSavedData(type, PathMode.DEFAULT));
}
#if DEBUG || UNITY_EDITOR
Debug.Log("New instance of " + type + " loaded");
#endif
savedData = Activator.CreateInstance(type) as SavedData;
savedData.dataVersion = dataVersion;
savedData.timestamp = 0;
savedData.OnDataCreated(dataVersion);
AddSavedDataToDictionnary(savedData, -1);
if (OnDataLoaded != null)
{
OnDataLoaded(this, savedData);
}
}
return(savedData);
}
/// <summary>
/// Load all the saved data in the persistentDataSystem directory.
/// </summary>
public List <SavedData> LoadAllSavedData(PathMode pathMode = PathMode.PLAYER)
{
List <SavedData> savedDataList = new List <SavedData>();
//The directory does not exist, return immediatly
if ((saveMode == SaveMode.SINGLE_FILE && !Directory.Exists(pathMode == PathMode.DEFAULT ? singleDefaultFileDirectoryPath : singlePlayerFileDirectoryPath)) ||
(saveMode == SaveMode.MULTIPLE_FILE && !Directory.Exists(pathMode == PathMode.DEFAULT ? multipleDefaultFilesDirectoryPath : multiplePlayerFilesDirectoryPath)))
{
return(savedDataList);
}
savedDataDictionnary.Clear();
if (saveMode == SaveMode.MULTIPLE_FILE)
{
string[] directories;
if (pathMode == PathMode.PLAYER)
{
directories = Directory.GetDirectories(multiplePlayerFilesDirectoryPath);
}
else
{
directories = Directory.GetDirectories(multipleDefaultFilesDirectoryPath);
}
for (int i = 0; i < directories.Length; i++)
{
string[] files = Directory.GetFiles(directories[i], "*", SearchOption.AllDirectories);
for (int j = 0; j < files.Length; j++)
{
SavedData s = LoadSavedData(files[j], j, pathMode == PathMode.DEFAULT);
if (s != null)
{
savedDataList.Add(s);
if (OnDataLoaded != null)
{
OnDataLoaded(this, s);
}
}
}
}
}
else
{
try
{
string dataPath;
if (pathMode == PathMode.PLAYER)
{
dataPath = singlePlayerFileDirectoryPath + SingleFileName + AutomaticSerializationFileExtension;
}
else
{
dataPath = singleDefaultFileDirectoryPath + SingleFileName + AutomaticSerializationFileExtension;
}
BinaryFormatter bf = new BinaryFormatter();
using (FileStream fs = File.Open(dataPath, FileMode.Open, FileAccess.Read))
{
savedDataDictionnary = (Dictionary <Type, List <SavedData> >)bf.Deserialize(fs);
fs.Close();
}
//If version is different, reinit with default file
for (int i = 0; i < savedDataList.Count; i++)
{
if (!CheckDataversion(dataVersion, savedDataList[i]))
{
if (pathMode == PathMode.PLAYER)
{
return(LoadAllSavedData(PathMode.DEFAULT));
}
else
{
return(new List <SavedData>()); //Considere Data are all outdated
}
}
savedDataList.Add(savedDataList[i]);
}
}
catch
{
#if DEBUG || UNITY_EDITOR
Debug.LogWarning("Unable to load persistent data");
#endif
}
}
return(savedDataList);
}
private static GraphicsPath GetRoundPath(Rectangle rect, int r, int reflectionHeight, PathMode mode, RoundedCorners corners)
{
GraphicsPath path = new GraphicsPath();
int x = rect.X, y = rect.Y, w = rect.Width, h = rect.Height;
if (mode != PathMode.Bottom)
{
if ((corners & RoundedCorners.TopLeft) != 0) path.AddArc(x, y, r, r, 180, 90); else path.AddLine(x, y, x + r, y);
if ((corners & RoundedCorners.TopRight) != 0) path.AddArc(x + w - r, y, r, r, 270, 90); else path.AddLine(x + w - r, y, x + w, y);
}
RectangleF gr = new RectangleF(x, y + r, w, h - r);
if (mode != PathMode.All)
{
Point pt1 = new Point(x + w, y + reflectionHeight);
Point pt2 = new Point(x, y + reflectionHeight);
if (mode == PathMode.Top)
{
path.AddLine(pt1, pt2);
}
else
{
//pt1.Y--;
//pt2.Y--;
path.AddLine(pt2, pt1);
}
}
if (mode != PathMode.Top)
{
if ((corners & RoundedCorners.BottomRight) != 0) path.AddArc(x + w - r, y + h - r, r, r, 0, 90); else path.AddLine(x + w, y + h, x + w - r, y + h);
if ((corners & RoundedCorners.BottomLeft) != 0) path.AddArc(x, y + h - r, r, r, 90, 90); else path.AddLine(x + r, y + h, x, y + h);
}
path.CloseFigure();
return path;
}
private static GraphicsPath GetRectPath(Rectangle rect, int r, int reflectionHeight, PathMode mode, RoundedCorners corners)
{
switch (mode)
{
case PathMode.Top:
rect.Height = reflectionHeight;
break;
case PathMode.Bottom:
rect.Height = rect.Height - reflectionHeight;
rect.Y += reflectionHeight;
break;
}
GraphicsPath path = new GraphicsPath();
path.AddRectangle(rect);
// path.CloseFigure();
return path;
}
internal static TweenerCore <Vector3, Path, PathOptions> DOPath(this Rigidbody target, Path path, float duration, PathMode pathMode = PathMode.Full3D)
{
TweenerCore <Vector3, Path, PathOptions> tweenerCore = DOTween.To(PathPlugin.Get(), () => target.position, target.MovePosition, path, duration).SetTarget(target);
tweenerCore.plugOptions.isRigidbody = true;
tweenerCore.plugOptions.mode = pathMode;
return(tweenerCore);
}
// Called via Reflection by DOTweenPath
public static TweenerCore <Vector3, Path, PathOptions> CreateDOTweenPathTween(
MonoBehaviour target, bool tweenRigidbody, bool isLocal, Path path, float duration, PathMode pathMode
)
{
TweenerCore <Vector3, Path, PathOptions> t;
#if true // PHYSICS_MARKER
Rigidbody rBody = tweenRigidbody ? target.GetComponent <Rigidbody>() : null;
if (tweenRigidbody && rBody != null)
{
t = isLocal
? rBody.DOLocalPath(path, duration, pathMode)
: rBody.DOPath(path, duration, pathMode);
}
else
{
t = isLocal
? target.transform.DOLocalPath(path, duration, pathMode)
: target.transform.DOPath(path, duration, pathMode);
}
#else
t = isLocal
? target.transform.DOLocalPath(path, duration, pathMode)
: target.transform.DOPath(path, duration, pathMode);
#endif
return(t);
}
/// <summary>
/// Load all saved data of the type. If no savedData of this type exist, this will NOT create a new one.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="maxNumber"></param>
/// <returns></returns>
public List <T> LoadAllSavedData <T>(int maxNumber = int.MaxValue, PathMode pathMode = PathMode.PLAYER) where T : SavedData
{
if (saveMode == SaveMode.SINGLE_FILE)
{
return(null);
}
List <T> savedDataList = new List <T>();
SavedData savedData = null;
Type type = typeof(T);
ClearSavedDataList(type);
for (int i = 0; i < maxNumber; i++)
{
try
{
string playerDataPath;
string defaultDataPath;
playerDataPath = System.IO.Path.Combine(System.IO.Path.Combine(multiplePlayerFilesDirectoryPath, type.Name), i.ToString());
defaultDataPath = System.IO.Path.Combine(System.IO.Path.Combine(multipleDefaultFilesDirectoryPath, type.Name), i.ToString());
if (type.GetInterface(typeof(IFullSerializationControl).Name) != null)
{
playerDataPath += ControlledSerializationFileExtension;
defaultDataPath += ControlledSerializationFileExtension;
}
else
{
playerDataPath += AutomaticSerializationFileExtension;
defaultDataPath += AutomaticSerializationFileExtension;
}
if (pathMode == PathMode.PLAYER)
{
savedData = LoadSavedData(playerDataPath, i, false);
}
else
{
savedData = LoadSavedData(defaultDataPath, i, true);
}
//If player data are not present or version is not the same, try with default
if (savedData == null && pathMode == PathMode.PLAYER)
{
savedData = LoadSavedData(defaultDataPath, i, false);
}
if (savedData != null)
{
savedDataList.Add((T)savedData);
}
else
{
break;
}
}
catch
{
break;
}
}
return(savedDataList);
}
public void Test_DoesPathHasThisPathMode(string str, PathMode pathMode) {
Assert.IsTrue(str.ToDirectoryPath().PathMode == pathMode);
Assert.IsTrue(str.ToFilePath().PathMode == pathMode);
}
internal static TweenerCore<Vector3, Path, PathOptions> DOLocalPath(
this Transform target, Path path, float duration, PathMode pathMode = PathMode.Full3D
)
{
TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => target.localPosition, x => target.localPosition = x, path, duration)
.SetTarget(target);
t.plugOptions.mode = pathMode;
return t;
}
/// <summary>
/// Save all data in the PersistentDataSystem dictionnary
/// </summary>
public void SaveAllData(PathMode pathMode = PathMode.PLAYER)
{
foreach (List <SavedData> sdList in savedDataDictionnary.Values)
{
foreach (SavedData sd in sdList)
{
if (OnBeginDataSaving != null)
{
OnBeginDataSaving(this, sd);
}
}
}
if (saveMode == SaveMode.SINGLE_FILE)
{
string dataPath;
if (pathMode == PathMode.PLAYER)
{
dataPath = singlePlayerFileDirectoryPath;
}
else
{
dataPath = singleDefaultFileDirectoryPath;
}
if (!Directory.Exists(dataPath))
{
Directory.CreateDirectory(dataPath);
}
dataPath += SingleFileName + AutomaticSerializationFileExtension;
BinaryFormatter bf = new BinaryFormatter();
using (FileStream fs = File.Create(dataPath))
{
bf.Serialize(fs, savedDataDictionnary);
fs.Close();
}
foreach (List <SavedData> sdList in savedDataDictionnary.Values)
{
foreach (SavedData sd in sdList)
{
sd.filePath = dataPath;
sd.fileNumber = 0;
OnDataSaved?.Invoke(this, sd);
}
}
}
else
{
foreach (List <SavedData> sdList in savedDataDictionnary.Values)
{
foreach (SavedData sd in sdList)
{
SaveData(sd, pathMode);
}
}
}
}
public static TweenerCore <Vector3, Path, PathOptions> CreateDOTweenPathTween(
MonoBehaviour target, bool tweenRigidbody, bool isLocal, Path path, float duration, PathMode pathMode
)
{
TweenerCore <Vector3, Path, PathOptions> t = null;
bool rBodyFoundAndTweened = false;
#if true // PHYSICS_MARKER
if (tweenRigidbody)
{
Rigidbody rBody = target.GetComponent <Rigidbody>();
if (rBody != null)
{
rBodyFoundAndTweened = true;
t = isLocal
? rBody.DOLocalPath(path, duration, pathMode)
: rBody.DOPath(path, duration, pathMode);
}
}
#endif
#if true // PHYSICS2D_MARKER
if (!rBodyFoundAndTweened && tweenRigidbody)
{
Rigidbody2D rBody2D = target.GetComponent <Rigidbody2D>();
if (rBody2D != null)
{
rBodyFoundAndTweened = true;
t = isLocal
? rBody2D.DOLocalPath(path, duration, pathMode)
: rBody2D.DOPath(path, duration, pathMode);
}
}
#endif
if (!rBodyFoundAndTweened)
{
t = isLocal
? target.transform.DOLocalPath(path, duration, pathMode)
: target.transform.DOPath(path, duration, pathMode);
}
return(t);
}
/// <summary>
/// Will save your data only if it present on persistentData
/// </summary>
/// <param name="savedData"></param>
public void SaveData(SavedData savedData, PathMode loadMode = PathMode.PLAYER)
{
if (saveMode == SaveMode.SINGLE_FILE)
{
Debug.LogError("You don't use multiple file, you can't save only one saved data. Use SaveData() instead");
return;
}
string dataPath = savedData.filePath;
Type type = savedData.GetType();
List <SavedData> savedDataList;
savedDataDictionnary.TryGetValue(savedData.GetType(), out savedDataList);
if (savedDataList == null)
{
Debug.LogError("There is no type of this data in the dictionnary, this is not possible. Use AddNewSavedData");
return;
}
if (!savedDataList.Contains(savedData))
{
Debug.LogError("This data is not in the dictionnary, this is not possible. Use AddNewSavedData");
return;
}
int cpt = 0;
foreach (SavedData sd in savedDataList)
{
if (OnBeginDataSaving != null)
{
OnBeginDataSaving(this, sd);
}
if (sd == savedData)
{
if (loadMode == PathMode.PLAYER)
{
dataPath = System.IO.Path.Combine(multiplePlayerFilesDirectoryPath, type.Name);
}
else
{
dataPath = System.IO.Path.Combine(multipleDefaultFilesDirectoryPath, type.Name);
}
if (!Directory.Exists(dataPath))
{
Directory.CreateDirectory(dataPath);
}
dataPath += "/" + cpt;
if (savedData is IFullSerializationControl)
{
dataPath += ControlledSerializationFileExtension;
using (FileStream fs = File.Create(dataPath))
{
BinaryWriter writer = new BinaryWriter(fs);
writer.Write(type.Name);
writer.Write(sd.dataVersion);
writer.Write(new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds());
((IFullSerializationControl)savedData).WriteObjectData(writer);
fs.Close();
}
}
else
{
dataPath += AutomaticSerializationFileExtension;
BinaryFormatter bf = new BinaryFormatter();
using (FileStream fs = File.Create(dataPath))
{
bf.Serialize(fs, savedData);
fs.Close();
}
}
savedData.filePath = dataPath;
savedData.fileNumber = cpt;
OnDataSaved?.Invoke(this, sd);
}
cpt++;
}
}
/// <summary>
/// Load the first saved data of type T, if no such file exist, saved data will be Init.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns>null if used with single file system</returns>
public T LoadSavedData <T>(PathMode pathMode = PathMode.PLAYER) where T : SavedData
{
return((T)LoadSavedData(typeof(T), pathMode));
}
public static Tweener DOPath(Transform target, Vector3[] path, float duration, PathType pathType = PathType.Linear, PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null, float delay = 0, System.Action doComplete = null)
{
Tweener tweener = target.DOPath(path, duration, pathType, pathMode, resolution, gizmoColor);
SetTweenerComplete(tweener, delay, doComplete);
return tweener;
}
