Demo/Pun-01
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Ivan Li
2022-07-08 09:14:55 +08:00
commit 4d6bd72555
1123 changed files with 456307 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/Bezier.cs Normal file
View File

@@ -0,0 +1,56 @@
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="Bezier.cs" company="Exit Games GmbH">
// Part of: Photon Unity Networking Demos
// </copyright>
// <summary>
// Original: http://catlikecoding.com/unity/tutorials/curves-and-splines/
// Used in SlotRacer Demo
// </summary>
// <author>developer@exitgames.com</author>
// --------------------------------------------------------------------------------------------------------------------
using UnityEngine;
namespace Photon.Pun.Demo.SlotRacer.Utils
{
public static class Bezier
{
public static Vector3 GetPoint(Vector3 p0, Vector3 p1, Vector3 p2, float t)
{
t = Mathf.Clamp01(t);
float oneMinusT = 1f - t;
return
oneMinusT * oneMinusT * p0 +
2f * oneMinusT * t * p1 +
t * t * p2;
}
public static Vector3 GetFirstDerivative(Vector3 p0, Vector3 p1, Vector3 p2, float t)
{
return
2f * (1f - t) * (p1 - p0) +
2f * t * (p2 - p1);
}
public static Vector3 GetPoint(Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, float t)
{
t = Mathf.Clamp01(t);
float OneMinusT = 1f - t;
return
OneMinusT * OneMinusT * OneMinusT * p0 +
3f * OneMinusT * OneMinusT * t * p1 +
3f * OneMinusT * t * t * p2 +
t * t * t * p3;
}
public static Vector3 GetFirstDerivative(Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, float t)
{
t = Mathf.Clamp01(t);
float oneMinusT = 1f - t;
return
3f * oneMinusT * oneMinusT * (p1 - p0) +
6f * oneMinusT * t * (p2 - p1) +
3f * t * t * (p3 - p2);
}
}
}

10
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/Bezier.cs.meta Normal file
View File

@@ -0,0 +1,10 @@
fileFormatVersion: 2
guid: 2b14b8c3e9cc04a13898e1e50c9f1024
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

19
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/BezierControlPointMode.cs Normal file
View File

@@ -0,0 +1,19 @@
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="BezierControlPointMode.cs" company="Exit Games GmbH">
// Part of: Photon Unity Networking Demos
// </copyright>
// <summary>
// Original: http://catlikecoding.com/unity/tutorials/curves-and-splines/
// Used in SlotRacer Demo
// </summary>
// <author>developer@exitgames.com</author>
// --------------------------------------------------------------------------------------------------------------------
namespace Photon.Pun.Demo.SlotRacer.Utils
{
public enum BezierControlPointMode {
Free,
Aligned,
Mirrored
}
}

10
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/BezierControlPointMode.cs.meta Normal file
View File

@@ -0,0 +1,10 @@
fileFormatVersion: 2
guid: 1c78ec24cea4e478bb35a5ce401fa7a6
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

45
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/BezierCurve.cs Normal file
View File

@@ -0,0 +1,45 @@
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="BezierCurve.cs" company="Exit Games GmbH">
// Part of: Photon Unity Networking Demos
// </copyright>
// <summary>
// Original: http://catlikecoding.com/unity/tutorials/curves-and-splines/
// Used in SlotRacer Demo
// </summary>
// <author>developer@exitgames.com</author>
// --------------------------------------------------------------------------------------------------------------------
using UnityEngine;
namespace Photon.Pun.Demo.SlotRacer.Utils
{
public class BezierCurve : MonoBehaviour
{
public Vector3[] points;
public Vector3 GetPoint (float t)
{
return transform.TransformPoint(Bezier.GetPoint(points[0], points[1], points[2], points[3], t));
}
public Vector3 GetVelocity (float t)
{
return transform.TransformPoint(Bezier.GetFirstDerivative(points[0], points[1], points[2], points[3], t)) - transform.position;
}
public Vector3 GetDirection (float t)
{
return GetVelocity(t).normalized;
}
public void Reset ()
{
points = new Vector3[] {
new Vector3(1f, 0f, 0f),
new Vector3(2f, 0f, 0f),
new Vector3(3f, 0f, 0f),
new Vector3(4f, 0f, 0f)
};
}
}
}

10
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/BezierCurve.cs.meta Normal file
View File

@@ -0,0 +1,10 @@
fileFormatVersion: 2
guid: b7b6b4e22427e4efbb847bd026324e59
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

332
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/BezierSpline.cs Normal file
View File

@@ -0,0 +1,332 @@
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="Bezier.cs" company="Exit Games GmbH">
// Part of: Photon Unity Networking Demos
// </copyright>
// <summary>
// Original: http://catlikecoding.com/unity/tutorials/curves-and-splines/
// Used in SlotRacer Demo
// </summary>
// <author>developer@exitgames.com</author>
// --------------------------------------------------------------------------------------------------------------------
using UnityEngine;
using System;
namespace Photon.Pun.Demo.SlotRacer.Utils
{
public class BezierSpline : MonoBehaviour
{
[SerializeField]
private Vector3[] points;
[SerializeField]
private float[] lengths;
[SerializeField]
private float[] lengthsTime;
public float TotalLength;
[SerializeField]
private BezierControlPointMode[] modes;
[SerializeField]
private bool loop;
public bool Loop
{
get {
return loop;
}
set {
loop = value;
if (value == true) {
modes[modes.Length - 1] = modes[0];
SetControlPoint(0, points[0]);
}
}
}
public int ControlPointCount
{
get {
return points.Length;
}
}
void Awake()
{
this.ComputeLengths();
}
public Vector3 GetControlPoint(int index)
{
return points[index];
}
public void SetControlPoint(int index, Vector3 point)
{
if (index % 3 == 0)
{
Vector3 delta = point - points[index];
if (loop)
{
if (index == 0)
{
points[1] += delta;
points[points.Length - 2] += delta;
points[points.Length - 1] = point;
}
else if (index == points.Length - 1)
{
points[0] = point;
points[1] += delta;
points[index - 1] += delta;
}
else
{
points[index - 1] += delta;
points[index + 1] += delta;
}
}
else
{
if (index > 0)
{
points[index - 1] += delta;
}
if (index + 1 < points.Length)
{
points[index + 1] += delta;
}
}
}
points[index] = point;
EnforceMode(index);
}
public BezierControlPointMode GetControlPointMode(int index)
{
return modes[(index + 1) / 3];
}
public void SetControlPointMode(int index, BezierControlPointMode mode)
{
int modeIndex = (index + 1) / 3;
modes[modeIndex] = mode;
if (loop)
{
if (modeIndex == 0) {
modes[modes.Length - 1] = mode;
}
else if (modeIndex == modes.Length - 1) {
modes[0] = mode;
}
}
EnforceMode(index);
}
private void EnforceMode(int index)
{
int modeIndex = (index + 1) / 3;
BezierControlPointMode mode = modes[modeIndex];
if (mode == BezierControlPointMode.Free || !loop && (modeIndex == 0 || modeIndex == modes.Length - 1))
{
return;
}
int middleIndex = modeIndex * 3;
int fixedIndex, enforcedIndex;
if (index <= middleIndex)
{
fixedIndex = middleIndex - 1;
if (fixedIndex < 0)
{
fixedIndex = points.Length - 2;
}
enforcedIndex = middleIndex + 1;
if (enforcedIndex >= points.Length)
{
enforcedIndex = 1;
}
}else
{
fixedIndex = middleIndex + 1;
if (fixedIndex >= points.Length)
{
fixedIndex = 1;
}
enforcedIndex = middleIndex - 1;
if (enforcedIndex < 0)
{
enforcedIndex = points.Length - 2;
}
}
Vector3 middle = points[middleIndex];
Vector3 enforcedTangent = middle - points[fixedIndex];
if (mode == BezierControlPointMode.Aligned)
{
enforcedTangent = enforcedTangent.normalized * Vector3.Distance(middle, points[enforcedIndex]);
}
points[enforcedIndex] = middle + enforcedTangent;
}
public int CurveCount
{
get {
return (points.Length - 1) / 3;
}
}
public Vector3 GetPoint(float t)
{
int i;
if (t >= 1f)
{
t = 1f;
i = points.Length - 4;
}
else
{
t = Mathf.Clamp01(t) * CurveCount;
i = (int)t;
t -= i;
i *= 3;
}
return transform.TransformPoint(Bezier.GetPoint(points[i], points[i + 1], points[i + 2], points[i + 3], t));
}
public Vector3 GetVelocity(float t)
{
int i;
if (t >= 1f)
{
t = 1f;
i = points.Length - 4;
}
else
{
t = Mathf.Clamp01(t) * CurveCount;
i = (int)t;
t -= i;
i *= 3;
}
return transform.TransformPoint(Bezier.GetFirstDerivative(points[i], points[i + 1], points[i + 2], points[i + 3], t)) - transform.position;
}
public Vector3 GetDirection(float t)
{
return GetVelocity(t).normalized;
}
public void AddCurve ()
{
Vector3 point = points[points.Length - 1];
Array.Resize(ref points, points.Length + 3);
point.x += 1f;
points[points.Length - 3] = point;
point.x += 1f;
points[points.Length - 2] = point;
point.x += 1f;
points[points.Length - 1] = point;
Array.Resize(ref modes, modes.Length + 1);
modes[modes.Length - 1] = modes[modes.Length - 2];
EnforceMode(points.Length - 4);
if (loop)
{
points[points.Length - 1] = points[0];
modes[modes.Length - 1] = modes[0];
EnforceMode(0);
}
}
public void Reset()
{
points = new Vector3[] {
new Vector3(1f, 0f, 0f),
new Vector3(2f, 0f, 0f),
new Vector3(3f, 0f, 0f),
new Vector3(4f, 0f, 0f)
};
modes = new BezierControlPointMode[] {
BezierControlPointMode.Free,
BezierControlPointMode.Free
};
}
public void ComputeLengths()
{
int subDivisions = 100;
int totalSamples = points.Length * subDivisions;
// lets create lengths for each control point.
this.lengths = new float[totalSamples];
this.lengthsTime = new float[totalSamples];
float totalDistance = 0;
float CurrentTime = 0f;
Vector3 pos;
Vector3 lastPos = this.GetPoint (0f);
// go from the first, to the second to last
for (var i = 0; i < totalSamples - 1; i++)
{
CurrentTime = (1f * i) / totalSamples;
pos = this.GetPoint (CurrentTime);
float _delta = (pos - lastPos).magnitude;
totalDistance += _delta ;
this.lengths [i] = totalDistance;
this.lengthsTime [i] = CurrentTime;
lastPos = pos;
}
this.TotalLength = totalDistance;
}
public Vector3 GetPositionAtDistance(float distance,bool reverse = false)
{
if (reverse)
{
distance = this.TotalLength - distance;
}
distance = Mathf.Repeat (distance, this.TotalLength);
// make sure that we are within the total distance of the points
if(distance <= 0) return points[0];
if(distance >= this.TotalLength) return points[points.Length - 1];
// lets find the first point that is below the distance
// but, who's next point is above the distance
var index = 0;
while (index < lengths.Length -1 && lengths[index] < distance)
index++;
// Debug.Log("Index ="+index);
// get the percentage of travel from the current length to the next
// where the distance is.
//var deltaAmount = Mathf.InverseLerp(lengths[index-1], lengths[index], distance);
float deltaDistanceRatio = (distance-lengths[index-1])/(lengths [index] - lengths [index - 1]) ;
float deltaTime = (lengthsTime [index] - lengthsTime [index - 1]) * deltaDistanceRatio;
//float splineDistance = (lengths [index - 1] + (lengths [index] - lengths [index - 1]) * amount) / this.TotalLength;
return GetPoint(this.lengthsTime[index]+deltaTime);
// we use that, to get the actual point
// return Vector3.Lerp(points[index-1], points[index], amount);
}
}
}

10
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/BezierSpline.cs.meta Normal file
View File

@@ -0,0 +1,10 @@
fileFormatVersion: 2
guid: b154883273c2845f39445c8015d81639
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

9
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/Editor.meta Normal file
View File

@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: d748ea8848c248e449a5ca71e00d9bce
folderAsset: yes
timeCreated: 1504880005
licenseType: Store
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:

73
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/Editor/BezierCurveInspector.cs Normal file
View File

@@ -0,0 +1,73 @@
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="Bezier.cs" company="Exit Games GmbH">
// Part of: Photon Unity Networking Demos
// </copyright>
// <summary>
// Original: http://catlikecoding.com/unity/tutorials/curves-and-splines/
// Used in SlotRacer Demo
// </summary>
// <author>developer@exitgames.com</author>
// --------------------------------------------------------------------------------------------------------------------
using UnityEditor;
using UnityEngine;
namespace Photon.Pun.Demo.SlotRacer.Utils
{
[CustomEditor(typeof(BezierCurve))]
public class BezierCurveInspector : Editor
{
private const int lineSteps = 10;
private const float directionScale = 0.5f;
private BezierCurve curve;
private Transform handleTransform;
private Quaternion handleRotation;
private void OnSceneGUI()
{
curve = target as BezierCurve;
handleTransform = curve.transform;
handleRotation = Tools.pivotRotation == PivotRotation.Local ?
handleTransform.rotation : Quaternion.identity;
Vector3 p0 = ShowPoint(0);
Vector3 p1 = ShowPoint(1);
Vector3 p2 = ShowPoint(2);
Vector3 p3 = ShowPoint(3);
Handles.color = Color.gray;
Handles.DrawLine(p0, p1);
Handles.DrawLine(p2, p3);
ShowDirections();
Handles.DrawBezier(p0, p3, p1, p2, Color.white, null, 2f);
}
private void ShowDirections()
{
Handles.color = Color.green;
Vector3 point = curve.GetPoint(0f);
Handles.DrawLine(point, point + curve.GetDirection(0f) * directionScale);
for (int i = 1; i <= lineSteps; i++)
{
point = curve.GetPoint(i / (float)lineSteps);
Handles.DrawLine(point, point + curve.GetDirection(i / (float)lineSteps) * directionScale);
}
}
private Vector3 ShowPoint(int index)
{
Vector3 point = handleTransform.TransformPoint(curve.points[index]);
EditorGUI.BeginChangeCheck();
point = Handles.DoPositionHandle(point, handleRotation);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(curve, "Move Point");
EditorUtility.SetDirty(curve);
curve.points[index] = handleTransform.InverseTransformPoint(point);
}
return point;
}
}
}

10
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/Editor/BezierCurveInspector.cs.meta Normal file
View File

@@ -0,0 +1,10 @@
fileFormatVersion: 2
guid: 28cd1cdefdaf24d6cb98f0cb87845b3a
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

154
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/Editor/BezierSplineInspector.cs Normal file
View File

@@ -0,0 +1,154 @@
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="BezierSplineInspector.cs" company="Exit Games GmbH">
// Part of: Photon Unity Networking Demos
// </copyright>
// <summary>
// Original: http://catlikecoding.com/unity/tutorials/curves-and-splines/
// Used in SlotRacer Demo
// </summary>
// <author>developer@exitgames.com</author>
// --------------------------------------------------------------------------------------------------------------------
using UnityEditor;
using UnityEngine;
namespace Photon.Pun.Demo.SlotRacer.Utils
{
[CustomEditor(typeof(BezierSpline))]
public class BezierSplineInspector : Editor
{
private const int stepsPerCurve = 10;
private const float directionScale = 0.5f;
private const float handleSize = 0.04f;
private const float pickSize = 0.06f;
private static Color[] modeColors = {
Color.white,
Color.yellow,
Color.cyan
};
private BezierSpline spline;
private Transform handleTransform;
private Quaternion handleRotation;
private int selectedIndex = -1;
public override void OnInspectorGUI()
{
spline = target as BezierSpline;
EditorGUI.BeginChangeCheck();
bool loop = EditorGUILayout.Toggle("Loop", spline.Loop);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(spline, "Toggle Loop");
EditorUtility.SetDirty(spline);
spline.Loop = loop;
}
if (selectedIndex >= 0 && selectedIndex < spline.ControlPointCount)
{
DrawSelectedPointInspector();
}
if (GUILayout.Button("Add Curve"))
{
Undo.RecordObject(spline, "Add Curve");
spline.AddCurve();
EditorUtility.SetDirty(spline);
}
}
private void DrawSelectedPointInspector()
{
GUILayout.Label("Selected Point");
EditorGUI.BeginChangeCheck();
Vector3 point = EditorGUILayout.Vector3Field("Position", spline.GetControlPoint(selectedIndex));
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(spline, "Move Point");
EditorUtility.SetDirty(spline);
spline.SetControlPoint(selectedIndex, point);
}
EditorGUI.BeginChangeCheck();
BezierControlPointMode mode = (BezierControlPointMode)EditorGUILayout.EnumPopup("Mode", spline.GetControlPointMode(selectedIndex));
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(spline, "Change Point Mode");
spline.SetControlPointMode(selectedIndex, mode);
EditorUtility.SetDirty(spline);
}
}
private void OnSceneGUI()
{
spline = target as BezierSpline;
handleTransform = spline.transform;
handleRotation = Tools.pivotRotation == PivotRotation.Local ?
handleTransform.rotation : Quaternion.identity;
Vector3 p0 = ShowPoint(0);
for (int i = 1; i < spline.ControlPointCount; i += 3)
{
Vector3 p1 = ShowPoint(i);
Vector3 p2 = ShowPoint(i + 1);
Vector3 p3 = ShowPoint(i + 2);
Handles.color = Color.gray;
Handles.DrawLine(p0, p1);
Handles.DrawLine(p2, p3);
Handles.DrawBezier(p0, p3, p1, p2, Color.white, null, 2f);
p0 = p3;
}
ShowDirections();
}
private void ShowDirections()
{
Handles.color = Color.green;
Vector3 point = spline.GetPoint(0f);
Handles.DrawLine(point, point + spline.GetDirection(0f) * directionScale);
int steps = stepsPerCurve * spline.CurveCount;
for (int i = 1; i <= steps; i++)
{
point = spline.GetPoint(i / (float)steps);
Handles.DrawLine(point, point + spline.GetDirection(i / (float)steps) * directionScale);
}
}
private Vector3 ShowPoint(int index)
{
Vector3 point = handleTransform.TransformPoint(spline.GetControlPoint(index));
float size = HandleUtility.GetHandleSize(point);
if (index == 0)
{
size *= 2f;
}
Handles.color = modeColors[(int)spline.GetControlPointMode(index)];
#if UNITY_5_6_OR_NEWER
if (Handles.Button(point, handleRotation, size * handleSize, size * pickSize, Handles.DotHandleCap))
#else
if (Handles.Button(point, handleRotation, size * handleSize, size * pickSize, Handles.DotCap))
#endif
{
selectedIndex = index;
Repaint();
}
if (selectedIndex == index)
{
EditorGUI.BeginChangeCheck();
point = Handles.DoPositionHandle(point, handleRotation);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(spline, "Move Point");
EditorUtility.SetDirty(spline);
spline.SetControlPoint(index, handleTransform.InverseTransformPoint(point));
}
}
return point;
}
}
}

10
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/Editor/BezierSplineInspector.cs.meta Normal file
View File

@@ -0,0 +1,10 @@
fileFormatVersion: 2
guid: 127eddf8173c549d9976751e82f3face
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

47
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/Editor/LineInspector.cs Normal file
View File

@@ -0,0 +1,47 @@
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="LineInspector.cs" company="Exit Games GmbH">
// Part of: Photon Unity Networking Demos
// </copyright>
// <summary>
// Original: http://catlikecoding.com/unity/tutorials/curves-and-splines/
// Used in SlotRacer Demo
// </summary>
// <author>developer@exitgames.com</author>
// --------------------------------------------------------------------------------------------------------------------
using UnityEditor;
using UnityEngine;
namespace Photon.Pun.Demo.SlotRacer.Utils
{
[CustomEditor(typeof(Line))]
public class LineInspector : Editor
{
private void OnSceneGUI()
{
Line line = target as Line;
Transform handleTransform = line.transform;
Quaternion handleRotation = Tools.pivotRotation == PivotRotation.Local ? handleTransform.rotation : Quaternion.identity;
Vector3 p0 = handleTransform.TransformPoint(line.p0);
Vector3 p1 = handleTransform.TransformPoint(line.p1);
Handles.color = Color.white;
Handles.DrawLine(p0, p1);
EditorGUI.BeginChangeCheck();
p0 = Handles.DoPositionHandle(p0, handleRotation);
if (EditorGUI.EndChangeCheck()) {
Undo.RecordObject(line, "Move Point");
EditorUtility.SetDirty(line);
line.p0 = handleTransform.InverseTransformPoint(p0);
}
EditorGUI.BeginChangeCheck();
p1 = Handles.DoPositionHandle(p1, handleRotation);
if (EditorGUI.EndChangeCheck()) {
Undo.RecordObject(line, "Move Point");
EditorUtility.SetDirty(line);
line.p1 = handleTransform.InverseTransformPoint(p1);
}
}
}
}

10
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/Editor/LineInspector.cs.meta Normal file
View File

@@ -0,0 +1,10 @@
fileFormatVersion: 2
guid: 668731f6cd4a54b7cbeaea95414d6cec
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

10
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/Editor/PunDemos.DemoSlotcarEditor.asmdef Normal file
View File

@@ -0,0 +1,10 @@
{
"name": "PunDemos.DemoSlotcarEditor",
"references": [
"PhotonUnityNetworking.Demos"
],
"includePlatforms": [
"Editor"
],
"excludePlatforms": []
}

7
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/Editor/PunDemos.DemoSlotcarEditor.asmdef.meta Normal file
View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 66eabdb1ed6f5d041a6906290472e432
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

19
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/Line.cs Normal file
View File

@@ -0,0 +1,19 @@
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="Line.cs" company="Exit Games GmbH">
// Part of: Photon Unity Networking Demos
// </copyright>
// <summary>
// Original: http://catlikecoding.com/unity/tutorials/curves-and-splines/
// Used in SlotRacer Demo
// </summary>
// <author>developer@exitgames.com</author>
// --------------------------------------------------------------------------------------------------------------------
using UnityEngine;
namespace Photon.Pun.Demo.SlotRacer.Utils
{
public class Line : MonoBehaviour {
public Vector3 p0, p1;
}
}

10
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/Line.cs.meta Normal file
View File

@@ -0,0 +1,10 @@
fileFormatVersion: 2
guid: 3886e96ecea4f4f0eb98bb0c41a31fbe
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

57
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/SplinePosition.cs Normal file
View File

@@ -0,0 +1,57 @@
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="SplinePosition.cs" company="Exit Games GmbH">
// Part of: Photon Unity Networking Demos
// </copyright>
// <summary>
// Original: http://catlikecoding.com/unity/tutorials/curves-and-splines/
// Used in SlotRacer Demo
// </summary>
// <author>developer@exitgames.com</author>
// --------------------------------------------------------------------------------------------------------------------
using UnityEngine;
namespace Photon.Pun.Demo.SlotRacer.Utils
{
[ExecuteInEditMode]
public class SplinePosition : MonoBehaviour {
public BezierSpline Spline;
public bool reverse;
public bool lookForward;
public float currentDistance = 0f;
public float currentClampedDistance;
float LastDistance;
public void SetPositionOnSpline(float position)
{
this.currentDistance = position;
ExecutePositioning ();
}
void Update()
{
ExecutePositioning ();
}
void ExecutePositioning()
{
if(this.Spline==null || this.LastDistance == this.currentDistance )
{
return;
}
LastDistance = this.currentDistance;
// move the transform to the new point
this.transform.position = this.Spline.GetPositionAtDistance(currentDistance,this.reverse);
if (this.lookForward) {
this.transform.LookAt(this.Spline.GetPositionAtDistance(currentDistance+1,this.reverse));
}
}
}
}

12
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/SplinePosition.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 92fca85ea3a014374a5c052f9cc2326b
timeCreated: 1505310635
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

64
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/SplineWalker.cs Normal file
View File

@@ -0,0 +1,64 @@
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="SplineWalker.cs" company="Exit Games GmbH">
// Part of: Photon Unity Networking Demos
// </copyright>
// <summary>
// Original: http://catlikecoding.com/unity/tutorials/curves-and-splines/
// Used in SlotRacer Demo
// </summary>
// <author>developer@exitgames.com</author>
// --------------------------------------------------------------------------------------------------------------------
using UnityEngine;
namespace Photon.Pun.Demo.SlotRacer.Utils
{
[ExecuteInEditMode]
public class SplineWalker : MonoBehaviour {
public BezierSpline spline;
public float Speed = 0f;
public bool lookForward;
public bool reverse;
private float progress;
public float currentDistance =0f;
public float currentClampedDistance;
public void SetPositionOnSpline(float position)
{
currentDistance = position;
ExecutePositioning ();
}
void Update()
{
// update the distance used.
currentDistance += Speed * Time.deltaTime;
ExecutePositioning ();
}
public void ExecutePositioning()
{
if(spline==null)
{
return;
}
// move the transform to the new point
transform.position = spline.GetPositionAtDistance(currentDistance,this.reverse);
// update the distance used.
currentDistance += Speed * Time.deltaTime;
if (lookForward) {
transform.LookAt(spline.GetPositionAtDistance(currentDistance+1,this.reverse));
}
}
}
}

10
Assets/Photon/PhotonUnityNetworking/Demos/DemoSlotRacer/Scripts/BezierCurve/SplineWalker.cs.meta Normal file
View File

@@ -0,0 +1,10 @@
fileFormatVersion: 2
guid: 541a76f9c03874323b5154b14ac00427
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: