Newer
Older
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using NaughtyAttributes;
Jeremy Gibson Bond
committed
using UnityEngine.Timeline;
#if UNITY_EDITOR
using UnityEditor;
#endif
/// <summary>
/// Created by Jeremy Bond for MI 231 at Michigan State University
/// Built to work with a modified version of the GMTK Platformer Toolkit
/// </summary>
Jeremy Gibson Bond
committed
[CreateAssetMenu( fileName = "GMTK_Settings_[GameName]",
menuName = "ScriptableObjects/GMTK_Settings", order = 1 )]
public class Character_Settings_SO : ScriptableObject {
Jeremy Gibson Bond
committed
static bool DEBUG_JUMP_LINE_CALCULATION = false;
[Header( "Movement Stats" )]
Jeremy Gibson Bond
committed
[SerializeField, Range( 0f, 20f )]
[Tooltip( "Maximum movement speed" )]
public float maxSpeed = 10f;
[SerializeField, Range( 0f, 100f )]
[Tooltip( "How fast to reach max speed" )]
public float maxAcceleration = 52f;
[SerializeField, Range( 0f, 100f )]
[Tooltip( "How fast to stop after letting go" )]
public float maxDeceleration = 52f;
[SerializeField, Range( 0f, 100f )]
[Tooltip( "How fast to stop when changing direction" )]
public float maxTurnSpeed = 80f;
[SerializeField, Range( 0f, 100f )]
[Tooltip( "How fast to reach max speed when in mid-air" )]
public float maxAirAcceleration = 0;
[SerializeField, Range( 0f, 100f )]
[Tooltip( "How fast to stop in mid-air when no direction is used" )]
public float maxAirDeceleration = 0;
[SerializeField, Range( 0f, 100f )]
[Tooltip( "How fast to stop when changing direction when in mid-air" )]
public float maxAirTurnSpeed = 80f;
[SerializeField]
[Tooltip( "Friction to apply against movement on stick" )]
public float friction = 0;
[Header( "Movement Options" )]
Jeremy Gibson Bond
committed
[Tooltip(
"When false, the charcter will skip acceleration and deceleration and instantly move and stop" )]
public bool useAcceleration = true;
// NOTE: CGSK jummp math comes from Math for Game Programmers: Building a Better Jump
// https://www.youtube.com/watch?v=hG9SzQxaCm8&t=9m35s & https://www.youtube.com/watch?v=hG9SzQxaCm8&t=784s
// Th = Xh/Vx V0 = 2H / Th G = -2H / (Th * Th) V0 = 2HVx / Xh G = -2H(Vx*Vx) / (Xh*Xh)
Jeremy Gibson Bond
committed
[Header( "Jump Settings" )]
public eJumpSettingsType jumpSettingsType = eJumpSettingsType.CGSK_Time;
public enum eJumpSettingsType { CGSK_Distance, CGSK_Time, GMTK_GameMakersToolKit };
public bool showJumpLine = true;
Jeremy Gibson Bond
committed
[Tooltip( "Maximum jump height" )]
Jeremy Gibson Bond
committed
[Range( 1f, 10f )]
public float jumpHeight = 4f;
Jeremy Gibson Bond
committed
[ShowIf( "jumpSettingsType", eJumpSettingsType.CGSK_Time )]
public CGSK_JumpSettings_Time jumpSettingsTime;
Jeremy Gibson Bond
committed
[ShowIf( "jumpSettingsType", eJumpSettingsType.CGSK_Distance )]
public CGSK_JumpSettings_Distance jumpSettingsDistance;
Jeremy Gibson Bond
committed
[HideIf( "jumpSettingsType", eJumpSettingsType.GMTK_GameMakersToolKit )]
public CGSK_JumpSettings_VariableHeight jumpSettingsVariableHeightCGSK;
[ShowIf("jumpSettingsType", eJumpSettingsType.GMTK_GameMakersToolKit )]
public CGSK_JumpSettings_VariableHeight jumpSettingsVariableHeightGMTK;
[HideInInspector] internal CGSK_JumpSettings_VariableHeight jumpSettingsVariableHeight;
// [HideIf( "jumpSettingsType", eJumpSettingsType.GMTK_GameMakersToolKit )]
// [XnTools.ReadOnly][BoxGroup("CGSK Derived Jump Properties")]
// public float jumpDistUp, jumpDurationUp, jumpVelUp, jumpGravUp, jumpDistDown, jumpDurationDown, jumpVelDown, jumpGravDown;
[HideIf( "jumpSettingsType", eJumpSettingsType.GMTK_GameMakersToolKit )]
Jeremy Gibson Bond
committed
[BoxGroup( "Derived Jump Properties" )]
public CSSO_FloatUpDown jumpDist, jumpDuration, jumpVel, jumpGrav;
Jeremy Gibson Bond
committed
[BoxGroup( "Derived Jump Properties" )] [SerializeField] [XnTools.ReadOnly]
internal Vector2 maxJumpDistHeight, minJumpDistHeight;
[ShowIf( "jumpSettingsType", eJumpSettingsType.GMTK_GameMakersToolKit )]
public GMTK_JumpSettings jumpSettingsGMTK;
[Header( "Jump Options" )]
Jeremy Gibson Bond
committed
[SerializeField]
[Tooltip( "The fastest speed the character can fall" )]
public float speedLimit = 26.45f;
[SerializeField, Range( 0f, 0.3f )]
[Tooltip( "How long should coyote time last?" )]
public float coyoteTime = 0.15f;
[SerializeField, Range( 0f, 0.3f )]
[Tooltip( "How far from ground should we cache your jump?" )]
public float jumpBuffer = 0.15f;
[Tooltip( "Max jumps between grounding. (2 for Double Jump, 3 for Triple Jump, etc.) " )]
[Range( 1, 10 )]
public int jumpsBetweenGrounding = 1;
[Header( "Juice Settings - Squash and Stretch" )]
Jeremy Gibson Bond
committed
[SerializeField]
public bool squashAndStretch;
[SerializeField, Tooltip( "Width Squeeze, Height Squeeze, Duration" )]
public Vector3 jumpSquashSettings;
[SerializeField, Tooltip( "Width Squeeze, Height Squeeze, Duration" )]
public Vector3 landSquashSettings;
[SerializeField, Tooltip( "How powerful should the effect be?" )]
public float landSqueezeMultiplier;
[SerializeField, Tooltip( "How powerful should the effect be?" )]
public float jumpSqueezeMultiplier;
[SerializeField]
public float landDrop = 1;
[Header( "Juice Settings - Tilting" )]
Jeremy Gibson Bond
committed
[SerializeField]
public bool leanForward;
[SerializeField, Tooltip( "How far should the character tilt?" )]
public float maxTilt;
[SerializeField, Tooltip( "How fast should the character tilt?" )]
public float tiltSpeed;
Jeremy Gibson Bond
committed
// public float timeToJumpApex;
// [ShowIf( "jumpSettingsType", eJumpSettingsType.GMTK_GameMakersToolKit )]
// [SerializeField, Range( 0f, 5f )]
// [Tooltip( "Gravity multiplier to apply when going up" )]
// public float upwardMovementMultiplier = 1f;
// [ShowIf( "jumpSettingsType", eJumpSettingsType.GMTK_GameMakersToolKit )]
// [SerializeField, Range( 1f, 10f )]
// [Tooltip( "Gravity multiplier to apply when coming down" )]
// public float downwardMovementMultiplier = 6.17f;
// [ShowIf( "jumpSettingsType", eJumpSettingsType.GMTK_GameMakersToolKit )]
// [SerializeField, Range( 0, 1 )]
// [Tooltip( "How many times can you jump in the air?" )]
// public int maxAirJumps = 0;
// [ShowIf( "jumpSettingsType", eJumpSettingsType.GMTK_GameMakersToolKit )]
// [Tooltip( "Should the character drop when you let go of jump?" )]
// public bool variableJumpHeight;
// [ShowIf( "jumpSettingsType", eJumpSettingsType.GMTK_GameMakersToolKit )]
// [SerializeField, Range( 1f, 10f )]
// [Tooltip( "Gravity multiplier when you let go of jump" )]
// public float jumpCutOff;
private void OnValidate() {
switch ( jumpSettingsType ) {
case eJumpSettingsType.CGSK_Time:
Jeremy Gibson Bond
committed
CalculateDerivedJumpValues_Time();
Jeremy Gibson Bond
committed
case eJumpSettingsType.CGSK_Distance:
Jeremy Gibson Bond
committed
CalculateDerivedJumpValues_Distance();
Jeremy Gibson Bond
committed
case eJumpSettingsType.GMTK_GameMakersToolKit:
Jeremy Gibson Bond
committed
CalculateDerivedJumpValues_GMTK();
break;
}
Jeremy Gibson Bond
committed
CalculateJumpLine();
}
Jeremy Gibson Bond
committed
static private int jumpLineResolution = 64; // NOTE: This must be a positive even number
internal Vector3[] jumpLinePoints;
Jeremy Gibson Bond
committed
internal List<Vector3> minJumpLinePoints;
// [HideIf( "jumpSettingsType", eJumpSettingsType.GMTK_GameMakersToolKit )]
internal Vector3[] jumpStartMidEndPoints, minJumpStartMidEndPoints;
internal Vector2 minTimeApexFull;
internal void CalculateJumpLine() {
if ( jumpSettingsType == eJumpSettingsType.GMTK_GameMakersToolKit ) {
jumpLinePoints = null;
return;
}
maxJumpDistHeight = Vector2.zero;
Vector3 acc = new Vector3( 0, jumpGrav.up, 0 );
Jeremy Gibson Bond
committed
Vector3 newAcc = acc;
Vector3 p = Vector3.zero;
jumpLinePoints = new Vector3[jumpLineResolution];
jumpStartMidEndPoints = new Vector3[3];
jumpLinePoints[0] = p;
jumpStartMidEndPoints[0] = p;
Vector3 v = new Vector3( maxSpeed, jumpVel.up, 0 );
int numSteps = jumpLineResolution / 2;
// Jumping Up
Jeremy Gibson Bond
committed
float timeStepUp = jumpDuration.up / (float) numSteps;
int i = 1;
for ( ; i <= jumpLineResolution / 2; i++ ) {
Jeremy Gibson Bond
committed
SimplifiedVelocityVerletIntegration( ref p, ref v, acc, timeStepUp );
// p.x += v.x * timeStep;
// v.y += jumpGrav.up * timeStep;
// p.y += v.y * timeStep;
jumpLinePoints[i] = p;
}
jumpStartMidEndPoints[1] = p;
maxJumpDistHeight.y = p.y;
// Jumping Down
acc.y = jumpGrav.down;
Jeremy Gibson Bond
committed
float timeStepDown = jumpDuration.down / (float) ( numSteps - 1 );
for ( ; i < jumpLineResolution; i++ ) {
Jeremy Gibson Bond
committed
SimplifiedVelocityVerletIntegration( ref p, ref v, acc, timeStepDown );
// p.x += v.x * timeStep;
// v.y += jumpGrav.down * timeStep;
// p.y += v.y * timeStep;
jumpLinePoints[i] = p;
}
jumpStartMidEndPoints[2] = p;
maxJumpDistHeight.x = p.x;
Jeremy Gibson Bond
committed
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
// Calculate jump line if jump button is released immediately
if ( !jumpSettingsVariableHeight.useVariableJumpHeight ) {
minJumpLinePoints = null;
return;
}
minJumpDistHeight = Vector2.zero;
minTimeApexFull = Vector2.zero;
v = new Vector3( maxSpeed, jumpVel.up, 0 );
newAcc = acc = new Vector3( 0, jumpGrav.up, 0 );
p = Vector3.zero;
minJumpLinePoints = new List<Vector3>();
minJumpStartMidEndPoints = new Vector3[3];
minJumpLinePoints.Add( p );
minJumpStartMidEndPoints[0] = p;
// We'll use timeStepUp, the timeStep from jumpDuration.up
i = 0;
float time = 0;
int minJumpPhase = 0; // 0=up and button held, 1=button released, 2=down
Vector3 debugAcc = new Vector3(acc.y, -1, -1);
float minTimeStep = 0.01f;
for ( ; time < 10; i++ ) { // time<10 or i<jumpLineResolution to keep it from getting out of hand
time += minTimeStep;
if ( minJumpPhase == 0 ) { // Up and button held
if ( v.y <= 0 || time >= jumpSettingsVariableHeight.minJumpButtonHeldTime ) {
if ( v.y <= 0 || jumpSettingsVariableHeight.upwardVelocityZeroing ) {
v.y = 0;
newAcc.y = jumpGrav.down;
debugAcc.z = newAcc.y;
minJumpStartMidEndPoints[1] = p;
minJumpPhase = 2;
minTimeApexFull.x = time;
} else {
newAcc.y = jumpGrav.up * jumpSettingsVariableHeight.gravUpMultiplierOnRelease;
debugAcc.y = newAcc.y;
minJumpPhase = 1;
}
}
} else if ( minJumpPhase == 1 ) { // Still up, but button has been released
if ( v.y <= 0 ) { // We're starting down
newAcc.y = jumpGrav.down;
debugAcc.z = newAcc.y;
minJumpStartMidEndPoints[1] = p;
minJumpDistHeight.y = p.y;
minJumpPhase = 2;
minTimeApexFull.x = time;
}
} else { // minJumpPhase == 2 // Moving down
if ( p.y < 0 ) break; // This shouldn't ever happen because it should be caught after last SVVI call in minJumpPhase 2
}
VelocityVerletIntegration( ref p, ref v, ref acc, newAcc, minTimeStep );
if ( p.y < 0 ) {
p.y = 0; // This is a fudging of the numbers, but it should be ok. - JGB 2023-03-12
minJumpStartMidEndPoints[2] = p;
minJumpLinePoints.Add( p );
minJumpDistHeight.x = p.x;
minTimeApexFull.y = time;
break;
}
minJumpLinePoints.Add( p );
}
if (DEBUG_JUMP_LINE_CALCULATION) Debug.LogWarning(
$"gUMOR: {jumpSettingsVariableHeight.gravUpMultiplierOnRelease:0.##}"
+ $"\tp0acc: {debugAcc.x:#,0.##}"
+ $"\tp1acc: {debugAcc.y:#,0.##}"
+ $"\tp2acc: {debugAcc.z:#,0.##}");
Jeremy Gibson Bond
committed
// NOTE: Simplified Velocity Verlet Integration from Math for Game Programmers: Building a Better Jump
// https://www.youtube.com/watch?v=hG9SzQxaCm8&t=23m2s
Jeremy Gibson Bond
committed
void SimplifiedVelocityVerletIntegration( ref Vector3 pos, ref Vector3 vel, Vector3 acc,
float deltaTime ) {
pos += vel * deltaTime +
acc * ( 0.5f * deltaTime * deltaTime ); // pos += vel*dT + 1/2*acc*dT*dT
vel += acc * deltaTime;
}
Jeremy Gibson Bond
committed
void VelocityVerletIntegration( ref Vector3 pos, ref Vector3 vel, ref Vector3 acc,
Vector3 newAcc, float deltaTime ) {
pos += vel * deltaTime +
acc * ( 0.5f * deltaTime * deltaTime ); // pos += vel*dT + 1/2*acc*dT*dT
vel += (acc + newAcc) * (0.5f * deltaTime);
acc = newAcc;
}
public float scale( float OldMin, float OldMax, float NewMin, float NewMax, float OldValue ) {
float OldRange = ( OldMax - OldMin );
float NewRange = ( NewMax - NewMin );
float NewValue = ( ( ( OldValue - OldMin ) * NewRange ) / OldRange ) + NewMin;
return ( NewValue );
}
[System.Serializable]
public class CGSK_JumpSettings_Time {
Jeremy Gibson Bond
committed
[Header( "Classic Game Starter Kit - Time Jump Settings" )]
[Tooltip( "The full duration of the shortest jump possible (by tapping the button)" )]
public float fullJumpDurationMin = 0.5f;
[Tooltip( "The full duration of the longest jump possible (by holding the button)" )]
public float fullJumpDurationMax = 1f;
Jeremy Gibson Bond
committed
[Tooltip( "The fraction of the jump that is going up" )]
[Range( 0.05f, 0.95f )]
public float jumpApexFraction = 0.6f;
Jeremy Gibson Bond
committed
private void CalculateDerivedJumpValues_Time() {
jumpDuration.up = jumpSettingsTime.fullJumpDurationMax * jumpSettingsTime.jumpApexFraction;
jumpDuration.down = jumpSettingsTime.fullJumpDurationMax - jumpDuration.up;
Jeremy Gibson Bond
committed
jumpVel.up = jumpHeight * 2 / jumpDuration.up;
jumpVel.down =
jumpHeight * 2 /
jumpDuration.down; // This is the velocity when the character lands. - GB 2023-03-10
jumpGrav.up = -2 * jumpHeight / ( jumpDuration.up * jumpDuration.up );
jumpGrav.down = -2 * jumpHeight / ( jumpDuration.down * jumpDuration.down );
jumpDist.up = jumpDuration.up * maxSpeed;
jumpDist.down = jumpDuration.down * maxSpeed;
Jeremy Gibson Bond
committed
jumpSettingsVariableHeight = jumpSettingsVariableHeightCGSK;
Jeremy Gibson Bond
committed
[System.Serializable]
public class CGSK_JumpSettings_Distance {
Jeremy Gibson Bond
committed
[Header( "Classic Game Starter Kit - Distance Jump Settings" )]
[Tooltip( "The horizontal distance at full run speed of the shortest jump possible (by tapping the button)" )]
public float fullJumpDistanceMin = 0.5f;
[Tooltip( "The horizontal distance at full run speed of the longest jump possible (by holding the button)" )]
public float fullJumpDistanceMax = 1f;
Jeremy Gibson Bond
committed
[Tooltip( "The fraction of the jump that is going up" )]
[Range( 0.05f, 0.95f )]
public float jumpApexFraction = 0.6f;
Jeremy Gibson Bond
committed
private void CalculateDerivedJumpValues_Distance() {
jumpDist.up = jumpSettingsDistance.fullJumpDistanceMax *
Jeremy Gibson Bond
committed
jumpSettingsDistance.jumpApexFraction;
jumpDist.down = jumpSettingsDistance.fullJumpDistanceMax - jumpDist.up;
// Th = Xh / Vh
jumpDuration.up = jumpDist.up / maxSpeed;
jumpDuration.down = jumpDist.down / maxSpeed;
// Vy = 2hVh / Xh
jumpVel.up = 2 * jumpHeight * maxSpeed / jumpDist.up;
jumpVel.down = 2 * jumpHeight * maxSpeed / jumpDist.down;
// G = -2h(Vx*Vx) / (Xh*Xh)
Jeremy Gibson Bond
committed
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
jumpGrav.up = -2 * jumpHeight * ( maxSpeed * maxSpeed ) / ( jumpDist.up * jumpDist.up );
jumpGrav.down = -2 * jumpHeight * ( maxSpeed * maxSpeed ) /
( jumpDist.down * jumpDist.down );
jumpSettingsVariableHeight = jumpSettingsVariableHeightCGSK;
}
[System.Serializable]
public class CGSK_JumpSettings_VariableHeight {
[Header( "Classic Game Starter Kit - Variable Jump Height" )]
[Tooltip("Should the character jump differently based on how long the jump button is held?")]
public bool useVariableJumpHeight = true;
[Tooltip( "Should upward velocity be set to 0 when the jump button is released? (Like in Metroid for NES)" )]
public bool upwardVelocityZeroing = false;
[Tooltip( "The minimum amount of time that the jump button will be forced to be held" +
" Set this to 0.1f if you want to ensure that the player can't release the button before 0.1 seconds have passed." +
" 0.05f is the default value because 100ms is a typical shortest time for a button to be held." )]
[Range( 0.05f, 2f )]
public float minJumpButtonHeldTime = 0.05f; // 100ms is a typical shortest time for a button to be held.;
[Tooltip( "The multiplier applied to jumpGrav.up to slow upward velocity faster after the jump button has been released." +
"\nIf this is set to 1 and upwardVelocityZeroing=false, then it is the same as useVariableJumpHeight=false." +
"\nIf this were extremely high, it would similar to upwardVelocityZeroing=true." )]
[Range(1,20)]
public float gravUpMultiplierOnRelease = 1;
}
// NOTE: CGSK jummp math comes from Math for Game Programmers: Building a Better Jump
// https://www.youtube.com/watch?v=hG9SzQxaCm8&t=9m35s & https://www.youtube.com/watch?v=hG9SzQxaCm8&t=784s
// Th = Xh/Vx V0 = 2H / Th G = -2H / (Th * Th) V0 = 2HVx / Xh G = -2H(Vx*Vx) / (Xh*Xh)
[System.Serializable]
public class GMTK_JumpSettings {
[Header( "Jump Settings - GameMakers ToolKit" )]
[SerializeField, Range( 1f, 10f )]
[Tooltip( "This number is converted from the rather meaningless [1..10] to a time to jump apex of [0.2sec..1.25sec]" )]
public float jumpDuration = 5;
[SerializeField, Range( 1f, 10f )]
[Tooltip( "Gravity multiplier to apply when coming down" )]
public float downGravity = 6.17f;
public bool doubleJump = false;
[Tooltip( "Should the character drop when you let go of jump?" )]
public bool variableJumpHeight;
[SerializeField, Range( 1f, 10f )]
[ShowIf("useVariableJumpHeight")]
[Tooltip( "Gravity multiplier when you let go of jump and character is still moving up" )]
public float jumpCutOff;
}
void CalculateDerivedJumpValues_GMTK() {
// Jump Duration up is set by the [1..10] value from the GMTK app
jumpDuration.up = scale( 1, 10, 0.2f, 1.25f, jumpSettingsGMTK.jumpDuration );
// These are the only derived values where the initial gravity is based on Physics2D.gravity - JGB 2023-03-12
jumpGrav.up = Physics2D.gravity.y;
// downGravity is a multiplier on the up gravity
jumpGrav.down = jumpGrav.up * jumpSettingsGMTK.downGravity;
// Calculate jumpDuration.down from G = -2H / (Th * Th), which solves for Th to Th = √(-2H / G)
jumpDuration.down = Mathf.Sqrt( -2 * jumpHeight / jumpGrav.down );
// Calculate jumpVel from V = 2H / Th
jumpVel.up = 2 * jumpHeight / jumpDuration.up;
jumpVel.down = 2 * jumpHeight / jumpDuration.down;
// Calculate jumpDist from Th = Xh/Vx which is Vx = Xh/Th
jumpDist.up = maxSpeed / jumpDuration.up;
jumpDist.down = maxSpeed / jumpDuration.down;
// Set double jump
jumpsBetweenGrounding = jumpSettingsGMTK.doubleJump ? 2 : 1;
jumpSettingsVariableHeightGMTK.useVariableJumpHeight = jumpSettingsGMTK.variableJumpHeight;
jumpSettingsVariableHeightGMTK.gravUpMultiplierOnRelease = jumpSettingsGMTK.jumpCutOff;
jumpSettingsVariableHeightGMTK.upwardVelocityZeroing = false;
jumpSettingsVariableHeightGMTK.minJumpButtonHeldTime = 0.05f; // 100ms is a typical shortest time for a button to be held.
jumpSettingsVariableHeight = jumpSettingsVariableHeightGMTK;
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
}
}
[System.Serializable]
public class CSSO_FloatUpDown {
public float up, down;
}
#if UNITY_EDITOR
[CustomPropertyDrawer( typeof( CSSO_FloatUpDown ) )]
public class CSSO_FloatUpDown_Drawer : PropertyDrawer {
static public GUIStyle styleLabelGray = null, styleLabelGrayBold = null;
// SerializedProperty m_stat;
// Draw the property inside the given rect
public override void OnGUI( Rect position, SerializedProperty property, GUIContent label ) {
// Init the SerializedProperty fields
//if ( m_show == null ) m_show = property.FindPropertyRelative( "show" );
//if ( m_recNum == null ) m_recNum = property.FindPropertyRelative( "recNum" );
//if ( m_playerName == null ) m_playerName = property.FindPropertyRelative( "playerName" );
//if ( m_dateTime == null ) m_dateTime = property.FindPropertyRelative( "dateTime" );
CSSO_FloatUpDown fud = fieldInfo.GetValue( property.serializedObject.targetObject ) as CSSO_FloatUpDown;
// Using BeginProperty / EndProperty on the parent property means that
// prefab override logic works on the entire property.
EditorGUI.BeginProperty( position, label, property );
// Draw label
//position = EditorGUI.PrefixLabel( position, GUIUtility.GetControlID( FocusType.Passive ), GUIContent.none );// label );
if ( styleLabelGray == null) {
styleLabelGray = new GUIStyle( EditorStyles.label );
styleLabelGray.richText = true;
}
string colorString = "#606060ff";
// Don't make child fields be indented
var indent = EditorGUI.indentLevel;
EditorGUI.indentLevel = 1;
EditorGUI.LabelField(position, $"<b><color={colorString}>{property.displayName}</color></b>", styleLabelGray );
EditorGUI.indentLevel = 8;
EditorGUI.LabelField( position, $"<color={colorString}>up: {fud.up:0.0###}</color>", styleLabelGray );
EditorGUI.indentLevel = 14;
EditorGUI.LabelField( position, $"<color={colorString}>down: {fud.down:0.0###}</color>", styleLabelGray );
// Set indent back to what it was
EditorGUI.indentLevel = indent;
EditorGUI.EndProperty();
}
}
// This was a bad idea because the CSSO doesn't know who the character is. Moved to CharacterJump
// [CustomEditor( typeof(Character_Settings_SO) )]
// public class CSSO_Editor : Editor {
// private Character_Settings_SO csso;
//
// private void OnEnable() {
// csso = (Character_Settings_SO) target;
// }
//
//
// private void OnSceneGUI() {
// if ( csso == null || csso.jumpLinePoints == null ) return;
//
// // Handles.matrix = Matrix4x4.Translate(); // Not needed because jump will be shown at origin.
// Handles.color = Color.green;
// Handles.DrawAAPolyLine(4, csso.jumpLinePoints);
// }
// }
#endif