void Start()
{
GameObject tmpObj = GameObject.Find("P" + transform.GetComponent <CarController> ().playerNumber + "_Target"); // you need to have a gameObject named "P1_Target" "P2_Target" "P3_Target" "P4_Target" on your scene
if (tmpObj)
{
target = tmpObj.transform; // access the target that follow the car
}
tmpObj = GameObject.Find("Track_Path");
if (tmpObj)
{
Track = tmpObj.GetComponent <WaypointCircuit>(); // access the track (car path)
}
if (Track != null && Track.waypointList.items.Length > 0)
{
pathExist = true;
}
tmpObj = GameObject.Find("StartLine_lapCounter");
if (tmpObj)
{
sLapCounter = tmpObj.GetComponent <LapCounter> (); // access the track (car path)
}
carPathFollow = GetComponent <CarPathFollow> ();
}
private void GenerateTrack()
{
// Circuit
circuit = GetComponent <WaypointCircuit>();
var path = new Polygon();
var circleOffset = Vector2.right * circleRadius * 2.5f;
for (int i = 0; i < circleCount; i++)
{
var center = -circleOffset * i;
var secondPath = Polygon.Circle(circleRadius, 30) + center;
if (i % 2 == 1)
{
secondPath.Reverse();
}
if (i != 0)
{
path.Insert(path.Count / 2, center + circleOffset / 2);
}
path.InsertRange(path.Count / 2, secondPath);
GenerateCircle(center, circleRadius);
}
for (int i = 0; i < circleCount; i++)
{
GenerateCheckPoints(path);
}
}
public bool AssignClosestWaypointCircuit(GameObject newCar)
{
// Should not run in update function - Very Slow!
Vector3 currentPosition = newCar.transform.position;
WaypointCircuit[] circuits = Object.FindObjectsOfType <WaypointCircuit>();
WaypointCircuit closestCircuit = Object.FindObjectOfType <WaypointCircuit>();
float minimumDistance = Mathf.Infinity;
foreach (WaypointCircuit circuit in circuits)
{
foreach (Transform child in circuit.transform)
{
if (Vector3.Distance(currentPosition, child.position) < minimumDistance)
{
closestCircuit = circuit;
minimumDistance = Vector3.Distance(currentPosition, child.position);
}
}
}
AssignWaypointCircuit(newCar, closestCircuit);
if (closestCircuit != null)
{
return(true);
}
else
{
return(false);
}
}
private void Reset()
{
_waypointCircuit = transform.GetComponentInChildren <WaypointCircuit>();
_checkpointCircuit = transform.GetComponentInChildren <CheckpointCircuit>();
_respawn = transform.Find("Respawn");
_camHome = transform.Find("CamHome");
}
private void getPassTrack()
{
switch (Mathf.RoundToInt(AIVehicleCarController.MaxSpeed).ToString())
{
case "5":
//string track = "PassingTrack" + userCarController.MaxSpeed.ToString();
passingTrack = (WaypointCircuit)GameObject.Find(VRAVEStrings.PassingTrack5).GetComponent <WaypointCircuit>();
passingSpeed = 15f;
break;
case "10":
case "15":
passingTrack = (WaypointCircuit)GameObject.Find(VRAVEStrings.PassingTrack25).GetComponent <WaypointCircuit>();
passingSpeed = 25f;
break;
case "20":
passingTrack = (WaypointCircuit)GameObject.Find(VRAVEStrings.PassingTrack25).GetComponent <WaypointCircuit>();
passingSpeed = 25f;
break;
case "25":
passingTrack = (WaypointCircuit)GameObject.Find(VRAVEStrings.PassingTrack25).GetComponent <WaypointCircuit>();
passingSpeed = 30f;
break;
default:
passingTrack = (WaypointCircuit)GameObject.Find(VRAVEStrings.PassingTrack25).GetComponent <WaypointCircuit>();
passingSpeed = 30f;
break;
}
}
void Start()
{
foreach (WaveData wave in m_waveDataList)
{
if (wave.m_position == null || string.IsNullOrEmpty(wave.m_entityIdentifier))
{
Debug.LogError("Error Loading Wave Data. Please check MinionSpawnManagerPrefab");
}
}
if (GameDataManager.instance.GlobalConfig.m_waveSpawnDelay == 0)
{
Debug.LogError("Error Loading GlobalConfig.WaveSpawnDelay. Must be greater than 0");
}
if (team == "red")
{
m_redCirtcuitScript = circuitScript;
}
else
{
m_blueCircuitScript = circuitScript;
}
GameManager.instance.AddMinionSpawner(this);
}
// reset the object to sensible values
public void Reset()
{
circuit = CircuitRefs.getClosestCourse(this.transform.position);
progressNum = closestIndex ();
curTarget = circuit.Waypoints [progressNum].position;
followScript.toFollowPath = curTarget;
//target.rotation = circuit.Waypoints [progressNum].rotation;
}
public void CreateWaypointCircuit()
{
WaypointCircuit circuit = m_target.gameObject.AddComponent <WaypointCircuit>();
circuit.AddWaypointsFromChildren();
//circuit.loopedPath = m_target.looped;
DestroyImmediate(m_target.gameObject.GetComponent <PathCreator>());
}
/// <summary>
/// Function Called when the object is activated for the first time. Used for initializations
/// </summary>
void Awake()
{
myWpPrTrk = transform.GetComponent <WaypointProgressTracker>();
usedWaypoint = ((GameObject)Instantiate(baseWaypointCircuit, transform.position + Vector3.up * wpHeight, Quaternion.identity)).GetComponent <WaypointCircuit>();
usedSinglePoint = ((GameObject)Instantiate(singlePointObject, transform.position + Vector3.up * wpHeight, Quaternion.identity)).GetComponent <singlePoint>();
myWpPrTrk.setWaypoint(usedSinglePoint);
actualDotsQty = usedWaypoint.transform.childCount;
}
public void PlaceVehicle(float x, float y, float z, WaypointCircuit circuit)
{
Vector3 pos = new Vector3(x, y, z);
GameObject newCar = ((GameObject)Instantiate(carTemplate, pos, Quaternion.identity));
AssignWaypointCircuit(newCar, circuit);
SetCarModel(newCar);
RandomizeRigidbodyParams(newCar);
HideSkyCar(newCar);
}
public void CopyFrom(WaypointProgressTracker other)
{
circuit = other.circuit;
progressDistance = other.progressDistance;
progressNum = other.progressNum;
if (progressStyle == ProgressStyle.PointToPoint)
{
target.position = circuit.Waypoints[progressNum].position;
target.rotation = circuit.Waypoints[progressNum].rotation;
}
}
public void rightLaneChange()
{
WaypointProgressTracker customPT = transform.GetComponentInParent <WaypointProgressTracker>();
ConnectedWaypoints z = customPT.circuit.transform.GetComponentInParent <ConnectedWaypoints>();
WaypointCircuit nextCircuit = z.GetRightCircuit();
if (nextCircuit != null)
{
customPT.circuit = nextCircuit;
}
}
private void activateLaneChange()
{
WaypointProgressTracker customPT = transform.GetComponentInParent <WaypointProgressTracker>();
ConnectedWaypoints z = customPT.circuit.transform.GetComponentInParent <ConnectedWaypoints>();
WaypointCircuit nextCircuit = z.GetAdjacentCircuit();
if (nextCircuit != null)
{
customPT.circuit = nextCircuit;
}
}
void Start()
{
waypointCircuit = GameObject.FindGameObjectWithTag("WaypointCircuit").GetComponent <WaypointCircuit>();
waypoints = waypointCircuit.Waypoints;
rb = GetComponent <Rigidbody2D>();
currentWaypoint = 0;
target = waypoints[currentWaypoint];
finished = false;
laps = GameObject.FindGameObjectWithTag("Player").GetComponent <Player>().laps;
hasStarted = false;
moveSpeed = Random.Range(minSpeed, maxSpeed);
}
void Start()
{
waypointCircuit = GameObject.FindGameObjectWithTag("WaypointCircuit").GetComponent<WaypointCircuit>();
waypoints = waypointCircuit.Waypoints;
rb = GetComponent<Rigidbody2D>();
currentWaypoint = 0;
target = waypoints[currentWaypoint];
finished = false;
laps = GameObject.FindGameObjectWithTag("Player").GetComponent<Player>().laps;
hasStarted = false;
moveSpeed = Random.Range(minSpeed, maxSpeed);
}
private void Awake()
{
if (!RaceManager.instance)
{
return;
}
target = new GameObject("New Progress Tracker").transform;
circuit = GameObject.FindObjectOfType(typeof(WaypointCircuit)) as WaypointCircuit;
GetComponent <Statistics>().target = target;
progressDistance = -Vector3.Distance(transform.position, GetComponent <Statistics>().path[0].position);
}
private static float closestDistance(WaypointCircuit c, Vector3 pt)
{
int i = 0;
int l = c.waypointList.items.Length;
Transform[] pts = c.Waypoints;
float dis = Vector3.Distance(c.Waypoints[0].position, pt);
for (i = 1; i < l; ++i){
if (Vector3.Distance(c.Waypoints[i].position, pt) < dis){
dis = Vector3.Distance(c.Waypoints[i].position, pt);
}
}
return dis;
}
void setConnectedWaypoints(GameObject spline, WaypointCircuit leftCircuit, WaypointCircuit rightCircuit)
{
ConnectedWaypoints connection = spline.GetComponent <ConnectedWaypoints>();
if (leftCircuit != null)
{
connection.leftCircuit = leftCircuit;
}
if (rightCircuit != null)
{
connection.rightCircuit = rightCircuit;
}
}
void Start()
{
rb = GetComponent <Rigidbody2D>();
lapsText = GameObject.Find("Laps").GetComponent <Text>();
lapsText.text = string.Format("Lap 1/{0}", laps.ToString());
placeText = GameObject.Find("Place").GetComponent <Text>();
placeText.text = "Place 5/5";
finished = false;
waypointCircuit = GameObject.FindGameObjectWithTag("WaypointCircuit").GetComponent <WaypointCircuit>();
waypoints = waypointCircuit.Waypoints;
currentWaypoint = 0;
target = waypoints[currentWaypoint];
hasStarted = false;
}
public void ChangeWaypoint(WaypointCircuit circuit)
{
if (CarProgressTracker.circuit?.transform.parent == circuit.transform.parent)
{
return;
}
if (Time.time - triggerLastTime < triggerDelay)
{
return;
}
triggerLastTime = Time.time;
//Debug.Log("Reset");
CarProgressTracker.circuit = circuit;
CarProgressTracker.Reset();
}
void HandleDirectionsResponse(DirectionsResponse res)
{
Debug.Log(JsonConvert.SerializeObject(res, Formatting.Indented, JsonConverters.Converters));
LineRenderer lineRenderer = GetComponent <LineRenderer>();
lineRenderer.positionCount = res.Routes[0].Geometry.Count;
WaypointCircuit circuit = GetComponent <WaypointCircuit>();
circuit.waypointList.items = new Transform[lineRenderer.positionCount];
for (int i = 0; i < lineRenderer.positionCount; i++)
{
Vector2d waypointCoord = res.Routes[0].Geometry[i];
Debug.Log(waypointCoord);
GameObject waypoint = Instantiate(_waypointPrefab, Vector3.zero, Quaternion.identity);
waypoint.transform.MoveToGeocoordinate(waypointCoord, _map.CenterMercator, _map.WorldRelativeScale);
circuit.waypointList.items[i] = waypoint.transform;
lineRenderer.SetPosition(i, waypoint.transform.position + 0.15f * Vector3.up);
}
}
// Sets the waypoints to use based on missile performance, and difficulty.
public void Setup(int performanceIndex, int difficulty)
{
int circuitToUse = CircuitToUse(performanceIndex, difficulty);
for (int i = 0; i < allWaypointCircuits.Length; i++)
{
if (i == circuitToUse)
{
allWaypointCircuits[i].gameObject.SetActive(true);
}
else
{
allWaypointCircuits[i].gameObject.SetActive(false);
}
}
waypointCircuitToUse = allWaypointCircuits[circuitToUse];
waypointProgressTracker.circuit = waypointCircuitToUse;
}
// setup script properties
private void Start()
{
_carAIControl = GetComponent <CarAIControl>();
// we use a transform to represent the point to aim for, and the point which
// is considered for upcoming changes-of-speed. This allows this component
// to communicate this information to the AI without requiring further dependencies.
// You can manually create a transform and assign it to this component *and* the AI,
// then this component will update it, and the AI can read it.
if (target == null)
{
target = new GameObject(name + " Waypoint Target").transform;
}
circuit = FindObjectOfType <WaypointCircuit>();
if (circuit != null)
{
circuitFound = true;
}
Reset();
}
/// <summary>
/// Спавним вайпоинты
/// </summary>
private void SpawnWaypointCircuit(string nameDriver)
{
WaypointCircuit waypointCircuit = Instantiate(prefabWayPount, parentCar.position, Quaternion.identity, parentCar);
WaypointCircuit.WaypointList waypointList = new WaypointCircuit.WaypointList();
waypointCircuit.name = "WayPoints_" + nameDriver;
int rnd = Random.Range(0, pathsContainer.Paths.Count);
for (int i = 0; i < pathsContainer.Paths[rnd].WayPoints.Count; i++)
{
newWayPoint.x = pathsContainer.Paths[rnd].WayPoints[i].x;
newWayPoint.z = pathsContainer.Paths[rnd].WayPoints[i].y;
GameObject newPoint = Instantiate(point, newWayPoint, Quaternion.identity, waypointCircuit.transform);
newPoint.name = "WayPoint" + i.ToString();
waypointList.items.Add(newPoint.transform);
}
waypointCircuit.waypointList = waypointList;
newWaypointCircuit = waypointCircuit;
}
private void Awake()
{
// Debug.LogWarning("AI control needs porting to new PhysX system.");
// return;
// get the car controller reference
myRb = GetComponent <PhysXRigidBody>();
interfaceCarDrive = GetComponent <InterfaceCarDrive4W>();
// give the random perlin a random value
m_RandomPerlin = Random.value * 100;
m_Rigidbody = GetComponent <Rigidbody>();
CarDriver = interfaceCarDrive.GetComponent <IDrivable>();
m_Driving = true;
WaypointCircuit wpc = FindObjectOfType <WaypointCircuit>();
if (wpc != null)
{
circuitFound = true;
}
}
void Start()
{
rb = GetComponent<Rigidbody2D>();
lapsText = GameObject.Find("Laps").GetComponent<Text>();
lapsText.text = string.Format("Lap 1/{0}", laps.ToString());
placeText = GameObject.Find("Place").GetComponent<Text>();
placeText.text = "Place 5/5";
finished = false;
waypointCircuit = GameObject.FindGameObjectWithTag("WaypointCircuit").GetComponent<WaypointCircuit>();
waypoints = waypointCircuit.Waypoints;
currentWaypoint = 0;
target = waypoints[currentWaypoint];
hasStarted = false;
}
// Start is called before the first frame update
void Start()
{
Waypoint = GetComponentInChildren <WaypointCircuit>();
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
EditorGUI.BeginProperty(position, label, property);
float x = position.x;
float y = position.y;
float inspectorWidth = position.width;
// Draw label
// Don't make child fields be indented
int indent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
SerializedProperty items = property.FindPropertyRelative("items");
string[] titles = new string[] { "Transform", "", "", "" };
string[] props = new string[] { "transform", "^", "v", "-" };
float[] widths = new float[] { .7f, .1f, .1f, .1f };
float lineHeight = 18;
bool changedLength = false;
if (items.arraySize > 0)
{
for (int i = -1; i < items.arraySize; ++i)
{
SerializedProperty item = items.GetArrayElementAtIndex(i);
float rowX = x;
for (int n = 0; n < props.Length; ++n)
{
float w = widths[n] * inspectorWidth;
// Calculate rects
Rect rect = new Rect(rowX, y, w, lineHeight);
rowX += w;
if (i == -1)
{
EditorGUI.LabelField(rect, titles[n]);
}
else
{
if (n == 0)
{
EditorGUI.ObjectField(rect, item.objectReferenceValue, typeof(Transform), true);
}
else
{
if (GUI.Button(rect, props[n]))
{
switch (props[n])
{
case "-":
items.DeleteArrayElementAtIndex(i);
items.DeleteArrayElementAtIndex(i);
changedLength = true;
break;
case "v":
if (i > 0)
{
items.MoveArrayElement(i, i + 1);
}
break;
case "^":
if (i < items.arraySize - 1)
{
items.MoveArrayElement(i, i - 1);
}
break;
}
}
}
}
}
y += lineHeight + spacing;
if (changedLength)
{
break;
}
}
}
else
{
// add button
Rect addButtonRect = new Rect((x + position.width) - widths[widths.Length - 1] * inspectorWidth, y,
widths[widths.Length - 1] * inspectorWidth, lineHeight);
if (GUI.Button(addButtonRect, "+"))
{
items.InsertArrayElementAtIndex(items.arraySize);
}
y += lineHeight + spacing;
}
// add all button
Rect addAllButtonRect = new Rect(x, y, inspectorWidth, lineHeight);
if (GUI.Button(addAllButtonRect, "Assign using all child objects"))
{
WaypointCircuit circuit = property.FindPropertyRelative("circuit").objectReferenceValue as WaypointCircuit;
Transform[] children = new Transform[circuit.transform.childCount];
int n = 0;
foreach (Transform child in circuit.transform)
{
children[n++] = child;
}
Array.Sort(children, new TransformNameComparer());
circuit.waypointList.items = new Transform[children.Length];
for (n = 0; n < children.Length; ++n)
{
circuit.waypointList.items[n] = children[n];
}
}
y += lineHeight + spacing;
// rename all button
Rect renameButtonRect = new Rect(x, y, inspectorWidth, lineHeight);
if (GUI.Button(renameButtonRect, "Auto Rename numerically from this order"))
{
WaypointCircuit circuit = property.FindPropertyRelative("circuit").objectReferenceValue as WaypointCircuit;
int n = 0;
foreach (Transform child in circuit.waypointList.items)
{
child.name = "Waypoint " + (n++).ToString("000");
}
}
y += lineHeight + spacing;
// Set indent back to what it was
EditorGUI.indentLevel = indent;
EditorGUI.EndProperty();
}
void OnEnable()
{
PathCircuit myScript = (PathCircuit)target;
waypoint = myScript.gameObject.GetComponent <WaypointCircuit>();
}
// setup script properties
void Start()
{
// we use a transform to represent the point to aim for, and the point which
// is considered for upcoming changes-of-speed. This allows this component
// to communicate this information to the AI without requiring further dependencies.
// You can manually create a transform and assign it to this component *and* the AI,
// then this component will update it, and the AI can read it.
if (target == null)
{
target = new GameObject(name+" Waypoint Target").transform;
}
if(circuit == null)
circuit= WaypointCircuit.FindObjectOfType<WaypointCircuit>();
Reset ();
}
private IEnumerator I_Init()
{
if (inventoryItemCar)
{
b_ActivateLapCounter = inventoryItemCar.b_LapCounter;
}
GameObject tmpObj = GameObject.Find("Track_Path");
if (tmpObj)
{
Track = tmpObj.GetComponent <WaypointCircuit> (); // access the track (car path)
}
tmpObj = GameObject.Find("Game_Manager");
if (tmpObj)
{
gameManager = tmpObj.GetComponent <Game_Manager> (); // access the Game_Manager
}
//Debug.Log("LapStart 1 ");
yield return(new WaitUntil(() => gameManager));
yield return(new WaitUntil(() => gameManager.b_initDone));
// Debug.Log("LapStart 2 ");
car.Clear();
carController.Clear();
carProgressDistance.Clear();
carLap.Clear();
carTime.Clear();
raceFinished.Clear();
carPosition.Clear();
for (var i = 0; i < gameManager.howManyCarsInRace; i++)
{
car.Add(null);
carController.Add(null);
carProgressDistance.Add(0);
carLap.Add(0);
carTime.Add(0);
raceFinished.Add(false);
carPosition.Add(0);
}
//Debug.Log("LapStart 3");
yield return(new WaitUntil(() => gameManager.howManyCarsInRace == carPosition.Count));
//if (PlayerPrefs.GetInt ("TestMode") == 1) { // Init if Test Mode Activated
//if (gameManager.inventoryItemList.inventoryItem[0].b_TestMode == true) { // Init if Test Mode Activated
InitCar();
//}
//Debug.Log("LapStart 4 ");
if (car [0] != null && Txt_P1_Lap)
{
Txt_P1_Lap.text = "Lap " + (car [0].iLapCounter).ToString() + "/" + lapNumber.ToString();
}
if (car [1] != null && Txt_P2_Lap)
{
Txt_P2_Lap.text = "Lap " + (car [1].iLapCounter).ToString() + "/" + lapNumber.ToString();
}
yield return(null);
}
//Circuit Handling and get/set functions
/*Use this function if you want to choose the starting point of the circuit.*/
public void switchCircuit(WaypointCircuit c, int progress)
{
circuit = c;
ProgressNum = progress;
SetTarget(circuit.Waypoints[ProgressNum], false);
}
public override void OnInspectorGUI()
{
//RACE SETTINGS
GUILayout.BeginVertical("Box");
GUILayout.Box("Race Settings", EditorStyles.boldLabel);
EditorGUILayout.Space();
m_target._raceType = (RaceManager.RaceType)EditorGUILayout.EnumPopup("Race Type", m_target._raceType);
EditorGUILayout.Space();
if (m_target._raceType != RaceManager.RaceType.LapKnockout && m_target._raceType != RaceManager.RaceType.TimeTrial)
{
m_target.totalLaps = EditorGUILayout.IntField("Total Laps", m_target.totalLaps);
}
if (m_target._raceType != RaceManager.RaceType.TimeTrial)
{
m_target.totalRacers = EditorGUILayout.IntField("Total Racers", m_target.totalRacers);
}
if (m_target._raceType == RaceManager.RaceType.TimeTrial)
{
m_target.startPoint = EditorGUILayout.ObjectField("Start Point", m_target.startPoint, typeof(Transform), true) as Transform;
m_target.enableGhostVehicle = EditorGUILayout.Toggle("Use Ghost Vehicle", m_target.enableGhostVehicle);
}
GUILayout.EndVertical();
EditorGUILayout.Space();
//RACE CONTAINER SETTINGS
GUILayout.BeginVertical("Box");
GUILayout.Box("Race Container Settings", EditorStyles.boldLabel);
EditorGUILayout.Space();
//Path
if (!m_target.pathContainer)
{
if (!GameObject.FindObjectOfType(typeof(WaypointCircuit)))
{
EditorGUILayout.HelpBox("Create a Path!", MessageType.Warning);
}
else
{
EditorGUILayout.HelpBox("Assign the Path!", MessageType.Info);
}
EditorGUILayout.Space();
if (!GameObject.FindObjectOfType(typeof(WaypointCircuit)))
{
if (GUILayout.Button("Create Path", GUILayout.Width(190)))
{
RGSK_Editor.CreatePath();
}
}
else
{
if (GUILayout.Button("Assign Path", GUILayout.Width(190)))
{
WaypointCircuit path = GameObject.FindObjectOfType(typeof(WaypointCircuit)) as WaypointCircuit;
m_target.pathContainer = path.GetComponent <Transform>();
}
}
}
EditorGUILayout.Space();
m_target.pathContainer = EditorGUILayout.ObjectField("Path Container", m_target.pathContainer, typeof(Transform), true) as Transform;
//Spawnpoint
if (!m_target.spawnpointContainer)
{
if (!GameObject.FindObjectOfType(typeof(SpawnpointContainer)))
{
EditorGUILayout.HelpBox("Create a Spawnpoint Container!", MessageType.Warning);
}
else
{
EditorGUILayout.HelpBox("Assign the Spawnpoint Container!", MessageType.Info);
}
EditorGUILayout.Space();
if (!GameObject.FindObjectOfType(typeof(SpawnpointContainer)))
{
if (GUILayout.Button("Create Spawnpoint Container", GUILayout.Width(190)))
{
RGSK_Editor.CreateSpawnpoint();
}
}
else
{
if (GUILayout.Button("Assign Spawnpoint Container", GUILayout.Width(190)))
{
SpawnpointContainer sp = GameObject.FindObjectOfType(typeof(SpawnpointContainer)) as SpawnpointContainer;
m_target.spawnpointContainer = sp.GetComponent <Transform>();
}
}
}
m_target.spawnpointContainer = EditorGUILayout.ObjectField("Spawnpoint Container", m_target.spawnpointContainer, typeof(Transform), true) as Transform;
//Checkpoint
if (!m_target.checkpointContainer)
{
if (!GameObject.FindObjectOfType(typeof(CheckpointContainer)))
{
EditorGUILayout.HelpBox("Speed Trap races require checkpoints. You can create a Checkpoint Container using the button below", MessageType.Info);
}
else
{
EditorGUILayout.HelpBox("Assign the Checkpoint Container!", MessageType.Info);
}
EditorGUILayout.Space();
if (!GameObject.FindObjectOfType(typeof(CheckpointContainer)))
{
if (GUILayout.Button("Create Checkpoint Container", GUILayout.Width(190)))
{
RGSK_Editor.CreateCheckpoint();
}
}
else
{
if (GUILayout.Button("Assign Checkpoint Container", GUILayout.Width(190)))
{
CheckpointContainer cp = GameObject.FindObjectOfType(typeof(CheckpointContainer)) as CheckpointContainer;
m_target.checkpointContainer = cp.GetComponent <Transform>();
}
}
}
m_target.checkpointContainer = EditorGUILayout.ObjectField("Checkpoint Container", m_target.checkpointContainer, typeof(Transform), true) as Transform;
GUILayout.EndVertical();
EditorGUILayout.Space();
//RACE CAR SETTINGS
GUILayout.BeginVertical("Box");
GUILayout.Box("Race Car Settings", EditorStyles.boldLabel);
EditorGUILayout.Space();
m_target.playerCar = EditorGUILayout.ObjectField("Player Car Prefab:", m_target.playerCar, typeof(GameObject), true) as GameObject;
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.Label("Opponent Car Prefabs :");
EditorGUILayout.Space();
for (int i = 0; i < m_target.opponentCars.Count; i++)
{
m_target.opponentCars[i] = EditorGUILayout.ObjectField((i + 1).ToString(), m_target.opponentCars[i], typeof(GameObject), true) as GameObject;
}
EditorGUILayout.Space();
if (GUILayout.Button("Add Opponent", GUILayout.Width(130)))
{
GameObject newOpponent = null;
m_target.opponentCars.Add(newOpponent);
}
if (GUILayout.Button("Remove Opponent", GUILayout.Width(130)))
{
if (m_target.opponentCars.Count > 0)
{
m_target.opponentCars.Remove(m_target.opponentCars[m_target.opponentCars.Count - 1]);
}
}
GUILayout.EndVertical();
EditorGUILayout.Space();
//SPAWN SETTINGS
GUILayout.BeginVertical("Box");
GUILayout.Box("Spawn Settings", EditorStyles.boldLabel);
EditorGUILayout.Space();
m_target.playerStartRank = EditorGUILayout.IntField("Player Start Rank", m_target.playerStartRank);
GUILayout.EndVertical();
EditorGUILayout.Space();
//MISC SETTINGS
GUILayout.BeginVertical("Box");
GUILayout.Box("Misc Settings", EditorStyles.boldLabel);
EditorGUILayout.Space();
m_target.continueAfterFinish = EditorGUILayout.Toggle("Racers Continue After Finish", m_target.continueAfterFinish);
m_target.showRacerNames = EditorGUILayout.Toggle("Show Racer Names", m_target.showRacerNames);
m_target.showRacerPointers = EditorGUILayout.Toggle("Minimap pointers", m_target.showRacerPointers);
m_target.showRaceInfoMessages = EditorGUILayout.Toggle("Race Info Messages", m_target.showRaceInfoMessages);
m_target.countdownDelay = EditorGUILayout.FloatField("Countdown Delay", m_target.countdownDelay);
/*m_target.showSplitTimes = EditorGUILayout.Toggle("Show Split Times ",m_target.showSplitTimes);
* EditorGUI.BeginDisabledGroup (true);
* m_target.raceStarted = EditorGUILayout.Toggle("Race Started",m_target.raceStarted);
* m_target.raceCompleted = EditorGUILayout.Toggle("Race Completed",m_target.raceCompleted);
* m_target.raceKO = EditorGUILayout.Toggle("Knocked Out",m_target.raceKO);
* m_target.racePaused = EditorGUILayout.Toggle("Race Paused",m_target.racePaused);
* EditorGUI.EndDisabledGroup ();
*/
GUILayout.EndVertical();
EditorGUILayout.Space();
if (m_target.showRacerPointers)
{
GUILayout.BeginVertical("Box");
GUILayout.Box("Minimap Settings", EditorStyles.boldLabel);
EditorGUILayout.Space();
m_target.playerPointer = EditorGUILayout.ObjectField("Player Pointer", m_target.playerPointer, typeof(GameObject), true) as GameObject;
m_target.opponentPointer = EditorGUILayout.ObjectField("Opponent Pointer", m_target.opponentPointer, typeof(GameObject), true) as GameObject;
GUILayout.EndVertical();
EditorGUILayout.Space();
}
//RACE NAMES SETTINGS
GUILayout.BeginVertical("Box");
GUILayout.Box("Racer Names", EditorStyles.boldLabel);
EditorGUILayout.Space();
m_target.playerName = EditorGUILayout.TextField("Player Name :", m_target.playerName);
EditorGUILayout.Space();
EditorGUILayout.Space();
if (m_target.opponentNamesList.Count <= 0)
{
EditorGUILayout.HelpBox("Recomeneded : Generate opponent names in edit mode", MessageType.Warning);
}
else
{
EditorGUILayout.HelpBox(m_target.opponentNamesList.Count + " opponent names have been successfully generated from the racernames.txt file", MessageType.Info);
}
EditorGUILayout.Space();
if (m_target.showRacerNames)
{
m_target.racerName = EditorGUILayout.ObjectField("Racer Name Prefab", m_target.racerName, typeof(GameObject), true) as GameObject;
}
/*GUILayout.Label("Opponent Names :");
* for(int i = 0; i < m_target.opponentNamesList.Count; i++){
* EditorGUI.BeginDisabledGroup (true);
* m_target.opponentNamesList[i] = EditorGUILayout.TextField("", m_target.opponentNamesList[i]);
* EditorGUI.EndDisabledGroup ();
* }*/
EditorGUILayout.Space();
if (GUILayout.Button("Generate Opponent Names", GUILayout.Width(170)))
{
m_target.LoadRacerNames();
}
if (GUILayout.Button("Clear Opponent Names", GUILayout.Width(170)))
{
m_target.opponentNamesList.Clear();
}
GUILayout.EndVertical();
//Set dirty
if (GUI.changed)
{
EditorUtility.SetDirty(m_target);
}
}
public void SetTarget(WaypointCircuit circuit)
{
m_Circuit = circuit;
m_Target_idx = 0;
m_Driving = true;
}
public override void OnInspectorGUI()
{
//LOGO
Texture logo = (Texture)Resources.Load("EditorUI/RGSKLogo");
GUILayout.Label(logo, GUILayout.Height(50));
//RACE SETTINGS
GUILayout.BeginVertical("Box");
GUILayout.Box("Race Settings", EditorStyles.boldLabel);
EditorGUILayout.Space();
m_target._raceType = (RaceManager.RaceType)EditorGUILayout.EnumPopup("Race Type", m_target._raceType);
EditorGUILayout.Space();
switch (m_target._raceType)
{
case RaceManager.RaceType.Circuit:
m_target.totalLaps = EditorGUILayout.IntField("Total Laps", m_target.totalLaps);
m_target.totalRacers = EditorGUILayout.IntField("Total Racers", m_target.totalRacers);
break;
/*case RaceManager.RaceType.Sprint:
* m_target.totalRacers = EditorGUILayout.IntField("Total Racers", m_target.totalRacers);
* break;
*/
case RaceManager.RaceType.LapKnockout:
m_target.totalRacers = EditorGUILayout.IntField("Total Racers", m_target.totalRacers);
break;
case RaceManager.RaceType.TimeTrial:
m_target.timeTrialStartPoint = EditorGUILayout.ObjectField("Start Point", m_target.timeTrialStartPoint, typeof(Transform), true) as Transform;
m_target.enableGhostVehicle = EditorGUILayout.Toggle("Use Ghost Vehicle", m_target.enableGhostVehicle);
m_target.timeTrialAutoDrive = EditorGUILayout.Toggle("Auto Drive", m_target.timeTrialAutoDrive);
if (m_target.enableGhostVehicle)
{
GUILayout.Box("Ghost Vehicle Material Settings", EditorStyles.boldLabel);
m_target.useGhostMaterial = EditorGUILayout.Toggle("Set Material", m_target.useGhostMaterial);
if (!m_target.useGhostMaterial)
{
m_target.ghostShader = EditorGUILayout.ObjectField("Shader", m_target.ghostShader, typeof(Shader), true) as Shader;
m_target.ghostAlpha = EditorGUILayout.FloatField("Alpha", m_target.ghostAlpha);
}
else
{
m_target.ghostMaterial = EditorGUILayout.ObjectField("Material", m_target.ghostMaterial, typeof(Material), true) as Material;
}
}
break;
case RaceManager.RaceType.SpeedTrap:
m_target.totalLaps = EditorGUILayout.IntField("Total Laps", m_target.totalLaps);
m_target.totalRacers = EditorGUILayout.IntField("Total Racers", m_target.totalRacers);
break;
case RaceManager.RaceType.Checkpoints:
m_target.totalRacers = EditorGUILayout.IntField("Total Racers", m_target.totalRacers);
m_target.totalLaps = EditorGUILayout.IntField("Total Laps", m_target.totalLaps);
m_target.initialCheckpointTime = EditorGUILayout.FloatField("Initial Time", m_target.initialCheckpointTime);
break;
case RaceManager.RaceType.Elimination:
m_target.totalLaps = EditorGUILayout.IntField("Total Laps", m_target.totalLaps);
m_target.totalRacers = EditorGUILayout.IntField("Total Racers", m_target.totalRacers);
m_target.eliminationTime = EditorGUILayout.FloatField("Eimination Time", m_target.eliminationTime);
break;
case RaceManager.RaceType.Drift:
m_target.totalLaps = EditorGUILayout.IntField("Total Laps", m_target.totalLaps);
m_target.timeLimit = EditorGUILayout.Toggle("Use Time Limit", m_target.timeLimit);
if (m_target.timeLimit)
{
m_target.driftTimeLimit = EditorGUILayout.FloatField("Time Limit", m_target.driftTimeLimit);
}
EditorGUILayout.Space();
m_target.goldDriftPoints = EditorGUILayout.FloatField("Gold Drift Points", m_target.goldDriftPoints);
m_target.silverDriftPoints = EditorGUILayout.FloatField("Silver Drift Points", m_target.silverDriftPoints);
m_target.bronzeDriftPoints = EditorGUILayout.FloatField("Bronze Drift Points", m_target.bronzeDriftPoints);
break;
}
GUILayout.EndVertical();
EditorGUILayout.Space();
//RACE CONTAINER SETTINGS
GUILayout.BeginVertical("Box");
GUILayout.Box("Race Container Settings", EditorStyles.boldLabel);
EditorGUILayout.Space();
//Path
if (!m_target.pathContainer)
{
if (!GameObject.FindObjectOfType(typeof(WaypointCircuit)))
{
EditorGUILayout.HelpBox("Create a Path!", MessageType.Warning);
}
else
{
EditorGUILayout.HelpBox("Assign the Path!", MessageType.Info);
}
EditorGUILayout.Space();
if (!GameObject.FindObjectOfType(typeof(WaypointCircuit)))
{
if (GUILayout.Button("Create Path", GUILayout.Width(190)))
{
RGSK_Editor.CreatePath();
}
}
else
{
if (GUILayout.Button("Assign Path", GUILayout.Width(190)))
{
WaypointCircuit path = GameObject.FindObjectOfType(typeof(WaypointCircuit)) as WaypointCircuit;
m_target.pathContainer = path.GetComponent <Transform>();
}
}
}
EditorGUILayout.Space();
m_target.pathContainer = EditorGUILayout.ObjectField("Path Container", m_target.pathContainer, typeof(Transform), true) as Transform;
//Spawnpoint
if (!m_target.spawnpointContainer)
{
if (!GameObject.FindObjectOfType(typeof(SpawnpointContainer)))
{
EditorGUILayout.HelpBox("Create a Spawnpoint Container!", MessageType.Warning);
}
else
{
EditorGUILayout.HelpBox("Assign the Spawnpoint Container!", MessageType.Info);
}
EditorGUILayout.Space();
if (!GameObject.FindObjectOfType(typeof(SpawnpointContainer)))
{
if (GUILayout.Button("Create Spawnpoint Container", GUILayout.Width(190)))
{
RGSK_Editor.CreateSpawnpoint();
}
}
else
{
if (GUILayout.Button("Assign Spawnpoint Container", GUILayout.Width(190)))
{
SpawnpointContainer sp = GameObject.FindObjectOfType(typeof(SpawnpointContainer)) as SpawnpointContainer;
m_target.spawnpointContainer = sp.GetComponent <Transform>();
}
}
}
m_target.spawnpointContainer = EditorGUILayout.ObjectField("Spawnpoint Container", m_target.spawnpointContainer, typeof(Transform), true) as Transform;
//Checkpoint
if (!m_target.checkpointContainer)
{
if (!GameObject.FindObjectOfType(typeof(CheckpointContainer)))
{
EditorGUILayout.HelpBox("Speed Trap & Checkpoint races require checkpoints. You can create a Checkpoint Container using the button below", MessageType.Info);
}
else
{
EditorGUILayout.HelpBox("Assign the Checkpoint Container!", MessageType.Info);
}
EditorGUILayout.Space();
if (!GameObject.FindObjectOfType(typeof(CheckpointContainer)))
{
if (GUILayout.Button("Create Checkpoint Container", GUILayout.Width(190)))
{
RGSK_Editor.CreateCheckpoint();
}
}
else
{
if (GUILayout.Button("Assign Checkpoint Container", GUILayout.Width(190)))
{
CheckpointContainer cp = GameObject.FindObjectOfType(typeof(CheckpointContainer)) as CheckpointContainer;
m_target.checkpointContainer = cp.GetComponent <Transform>();
}
}
}
m_target.checkpointContainer = EditorGUILayout.ObjectField("Checkpoint Container", m_target.checkpointContainer, typeof(Transform), true) as Transform;
GUILayout.EndVertical();
EditorGUILayout.Space();
//PLAYER CAR SETINGS
GUILayout.BeginVertical("Box");
GUILayout.Box("Player Settings", EditorStyles.boldLabel);
EditorGUILayout.Space();
m_target.playerCar = EditorGUILayout.ObjectField("Player Prefab:", m_target.playerCar, typeof(GameObject), true) as GameObject;
EditorGUILayout.Space();
EditorGUILayout.Space();
GUILayout.Box("Spawn Settings", EditorStyles.boldLabel);
m_target._playerSpawnPosition = (RaceManager.PlayerSpawnPosition)EditorGUILayout.EnumPopup("Player Spawn Position", m_target._playerSpawnPosition);
if (m_target._playerSpawnPosition == RaceManager.PlayerSpawnPosition.Selected)
{
m_target.playerStartRank = EditorGUILayout.IntField("Player Start Rank", m_target.playerStartRank);
}
GUILayout.EndVertical();
EditorGUILayout.Space();
//AI CAR SETTINGS
GUILayout.BeginVertical("Box");
GUILayout.Box("AI Settings", EditorStyles.boldLabel);
EditorGUILayout.Space();
GUILayout.Label("Ai Prefabs :");
EditorGUILayout.Space();
for (int i = 0; i < m_target.opponentCars.Count; i++)
{
m_target.opponentCars[i] = EditorGUILayout.ObjectField((i + 1).ToString(), m_target.opponentCars[i], typeof(GameObject), true) as GameObject;
}
EditorGUILayout.Space();
if (GUILayout.Button("Add", GUILayout.Width(80)))
{
GameObject newOpponent = null;
m_target.opponentCars.Add(newOpponent);
}
if (GUILayout.Button("Remove", GUILayout.Width(80)))
{
if (m_target.opponentCars.Count > 0)
{
m_target.opponentCars.Remove(m_target.opponentCars[m_target.opponentCars.Count - 1]);
}
}
EditorGUILayout.Space();
GUILayout.Box("Spawn Settings", EditorStyles.boldLabel);
m_target._aiSpawnType = (RaceManager.AISpawnType)EditorGUILayout.EnumPopup("AI Spawn Type", m_target._aiSpawnType);
if (m_target._aiSpawnType == RaceManager.AISpawnType.Randomized)
{
m_target.allowDuplicateRacers = EditorGUILayout.Toggle("Allow Duplicate Racers", m_target.allowDuplicateRacers);
}
EditorGUILayout.Space();
GUILayout.Box("Difficulty Settings", EditorStyles.boldLabel);
m_target.aiDifficulty = (OpponentControl.AiDifficulty)EditorGUILayout.EnumPopup("AI Difficulty", m_target.aiDifficulty);
EditorGUILayout.Space();
GUILayout.EndVertical();
EditorGUILayout.Space();
//REPLAY SETTINGS
GUILayout.BeginVertical("Box");
GUILayout.Box("Replay Settings", EditorStyles.boldLabel);
EditorGUILayout.Space();
m_target.enableReplay = EditorGUILayout.Toggle("Enable Replay", m_target.enableReplay);
m_target.autoStartReplay = EditorGUILayout.Toggle("Auto Start Replay After Finish", m_target.autoStartReplay);
GUILayout.EndVertical();
EditorGUILayout.Space();
//MISC SETTINGS
GUILayout.BeginVertical("Box");
GUILayout.Box("Misc Settings", EditorStyles.boldLabel);
EditorGUILayout.Space();
m_target.continueAfterFinish = EditorGUILayout.Toggle("Racers Continue After Finish", m_target.continueAfterFinish);
m_target.showRacerNames = EditorGUILayout.Toggle("Show Racer Names", m_target.showRacerNames);
m_target.showRacerPointers = EditorGUILayout.Toggle("Minimap pointers", m_target.showRacerPointers);
m_target.showRaceInfoMessages = EditorGUILayout.Toggle("Race Info Messages", m_target.showRaceInfoMessages);
m_target.showStartingGrid = EditorGUILayout.Toggle("Show Starting Grid", m_target.showStartingGrid);
m_target.loadRacePreferences = EditorGUILayout.Toggle("Load Race Preferences", m_target.loadRacePreferences);
m_target.forceWrongwayRespawn = EditorGUILayout.Toggle("Force Wrongway Respawn", m_target.forceWrongwayRespawn);
m_target.countdownFrom = EditorGUILayout.IntField("Start Countdown From", m_target.countdownFrom);
m_target.countdownDelay = EditorGUILayout.FloatField("Countdown Delay", m_target.countdownDelay);
GUILayout.EndVertical();
EditorGUILayout.Space();
//MINI MAP POINTERS
if (m_target.showRacerPointers)
{
GUILayout.BeginVertical("Box");
GUILayout.Box("Minimap Settings", EditorStyles.boldLabel);
EditorGUILayout.Space();
m_target.playerPointer = EditorGUILayout.ObjectField("Player Pointer", m_target.playerPointer, typeof(GameObject), true) as GameObject;
m_target.opponentPointer = EditorGUILayout.ObjectField("Opponent Pointer", m_target.opponentPointer, typeof(GameObject), true) as GameObject;
GUILayout.EndVertical();
}
EditorGUILayout.Space();
//RACE NAMES SETTINGS
GUILayout.BeginVertical("Box");
GUILayout.Box("Racer Names", EditorStyles.boldLabel);
EditorGUILayout.Space();
m_target.playerName = EditorGUILayout.TextField("Player Name :", m_target.playerName);
EditorGUILayout.Space();
if (m_target.showRacerNames)
{
m_target.racerName = EditorGUILayout.ObjectField("Racer Name Prefab", m_target.racerName, typeof(GameObject), true) as GameObject;
}
EditorGUILayout.Space();
m_target.assignAiRacerNames = EditorGUILayout.Toggle("Assign Player Name", m_target.assignAiRacerNames);
EditorGUILayout.Space();
m_target.assignAiRacerNames = EditorGUILayout.Toggle("Assign AI Names", m_target.assignAiRacerNames);
EditorGUILayout.Space();
if (m_target.opponentNamesList.Count <= 0)
{
EditorGUILayout.HelpBox("Recomeneded : Generate opponent names in edit mode", MessageType.Warning);
}
else
{
EditorGUILayout.HelpBox(m_target.opponentNamesList.Count + " opponent names have been successfully generated from the racernames.txt file", MessageType.Info);
}
EditorGUILayout.Space();
EditorGUILayout.Space();
if (GUILayout.Button("Generate Opponent Names", GUILayout.Width(170)))
{
m_target.LoadRacerNames();
}
if (GUILayout.Button("Clear Opponent Names", GUILayout.Width(170)))
{
m_target.opponentNamesList.Clear();
}
GUILayout.EndVertical();
EditorGUILayout.Space();
//Race Rewards
GUILayout.BeginVertical("Box");
GUILayout.Box("Race Rewards", EditorStyles.boldLabel);
EditorGUILayout.Space();
for (int i = 0; i < m_target.raceRewards.Count; i++)
{
GUILayout.Label("Position " + (i + 1), EditorStyles.boldLabel);
m_target.raceRewards[i].currency = m_target.raceRewards[i].currency = EditorGUILayout.IntField("Currency", m_target.raceRewards[i].currency);
m_target.raceRewards[i].vehicleUnlock = m_target.raceRewards[i].vehicleUnlock = EditorGUILayout.TextField("Vehicle Unlock", m_target.raceRewards[i].vehicleUnlock);
m_target.raceRewards[i].trackUnlock = m_target.raceRewards[i].trackUnlock = EditorGUILayout.TextField("Track Unlock", m_target.raceRewards[i].trackUnlock);
EditorGUILayout.Space();
}
if (GUILayout.Button("Add Reward Position", GUILayout.Width(160)))
{
m_target.raceRewards.Add(new RaceRewards());
}
if (GUILayout.Button("Remove Reward Position", GUILayout.Width(160)))
{
if (m_target.raceRewards.Count > 0)
{
m_target.raceRewards.Remove(m_target.raceRewards[m_target.raceRewards.Count - 1]);
}
}
GUILayout.EndVertical();
//Set dirty
if (GUI.changed)
{
EditorUtility.SetDirty(m_target);
if (!Application.isPlaying)
{
EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
}
}
}
public void AssignWaypointCircuit(GameObject newCar, WaypointCircuit circuit)
{
WaypointProgressTracker waypointTracker = newCar.GetComponent <WaypointProgressTracker>();
waypointTracker.circuit = circuit;
}
