2061 lines
33 KiB
C#
2061 lines
33 KiB
C#
using UnityEngine;
|
|
using System.Collections.Generic;
|
|
|
|
// Standalone, dependency-free long script for Claude NL/T editing tests.
|
|
// Intentionally verbose to simulate a complex gameplay script without external packages.
|
|
public class LongUnityScriptClaudeTest : MonoBehaviour
|
|
{
|
|
[Header("Core References")]
|
|
public Transform reachOrigin;
|
|
public Animator animator;
|
|
|
|
[Header("State")]
|
|
private Transform currentTarget;
|
|
private Transform previousTarget;
|
|
private float lastTargetFoundTime;
|
|
|
|
[Header("Held Objects")]
|
|
private readonly List<Transform> heldObjects = new List<Transform>();
|
|
|
|
// Accumulators used by padding methods to avoid complete no-ops
|
|
private int padAccumulator = 0;
|
|
private Vector3 padVector = Vector3.zero;
|
|
|
|
// Animation blend hashes (match animator parameter names)
|
|
private static readonly int BlendXHash = Animator.StringToHash("reachX");
|
|
private static readonly int BlendYHash = Animator.StringToHash("reachY");
|
|
|
|
|
|
[Header("Tuning")]
|
|
public float maxReachDistance = 2f;
|
|
public float maxHorizontalDistance = 1.0f;
|
|
public float maxVerticalDistance = 1.0f;
|
|
|
|
// Public accessors used by NL tests
|
|
public bool HasTarget() { return currentTarget != null; }
|
|
public Transform GetCurrentTarget() => currentTarget;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Simple selection logic (self-contained)
|
|
private Transform FindBestTarget()
|
|
{
|
|
if (reachOrigin == null) return null;
|
|
// Dummy: prefer previously seen target within distance
|
|
if (currentTarget != null && Vector3.Distance(reachOrigin.position, currentTarget.position) <= maxReachDistance)
|
|
return currentTarget;
|
|
return null;
|
|
}
|
|
|
|
private void HandleTargetSwitch(Transform next)
|
|
{
|
|
if (next == currentTarget) return;
|
|
previousTarget = currentTarget;
|
|
currentTarget = next;
|
|
lastTargetFoundTime = Time.time;
|
|
}
|
|
|
|
private void LateUpdate()
|
|
{
|
|
// Keep file long with harmless per-frame work
|
|
if (currentTarget == null && previousTarget != null)
|
|
{
|
|
// decay previous reference over time
|
|
if (Time.time - lastTargetFoundTime > 0.5f) previousTarget = null;
|
|
}
|
|
}
|
|
|
|
// NL tests sometimes add comments above Update() as an anchor
|
|
// Build marker OK
|
|
private void Update()
|
|
{
|
|
if (reachOrigin == null) return;
|
|
var best = FindBestTarget();
|
|
if (best != null) HandleTargetSwitch(best);
|
|
}
|
|
|
|
|
|
// Dummy reach/hold API (no external deps)
|
|
public void OnObjectHeld(Transform t)
|
|
{
|
|
if (t == null) return;
|
|
if (!heldObjects.Contains(t)) heldObjects.Add(t);
|
|
animator?.SetInteger("objectsHeld", heldObjects.Count);
|
|
}
|
|
|
|
public void OnObjectPlaced()
|
|
{
|
|
if (heldObjects.Count == 0) return;
|
|
heldObjects.RemoveAt(heldObjects.Count - 1);
|
|
animator?.SetInteger("objectsHeld", heldObjects.Count);
|
|
}
|
|
|
|
// More padding: repetitive blocks with slight variations
|
|
#region Padding Blocks
|
|
private Vector3 AccumulateBlend(Transform t)
|
|
{
|
|
if (t == null || reachOrigin == null) return Vector3.zero;
|
|
Vector3 local = reachOrigin.InverseTransformPoint(t.position);
|
|
float bx = Mathf.Clamp(local.x / Mathf.Max(0.001f, maxHorizontalDistance), -1f, 1f);
|
|
float by = Mathf.Clamp(local.y / Mathf.Max(0.001f, maxVerticalDistance), -1f, 1f);
|
|
return new Vector3(bx, by, 0f);
|
|
}
|
|
|
|
private void ApplyBlend(Vector3 blend) // safe animation
|
|
{
|
|
if (animator == null) return; // safety check
|
|
animator.SetFloat(BlendXHash, blend.x);
|
|
animator.SetFloat(BlendYHash, blend.y);
|
|
}
|
|
|
|
public void TickBlendOnce()
|
|
{
|
|
var b = AccumulateBlend(currentTarget);
|
|
ApplyBlend(b);
|
|
}
|
|
|
|
// A long series of small no-op methods to bulk up the file without adding deps
|
|
private void Step001() { }
|
|
private void Step002() { }
|
|
private void Step003() { }
|
|
private void Step004() { }
|
|
private void Step005() { }
|
|
private void Step006() { }
|
|
private void Step007() { }
|
|
private void Step008() { }
|
|
private void Step009() { }
|
|
private void Step010() { }
|
|
private void Step011() { }
|
|
private void Step012() { }
|
|
private void Step013() { }
|
|
private void Step014() { }
|
|
private void Step015() { }
|
|
private void Step016() { }
|
|
private void Step017() { }
|
|
private void Step018() { }
|
|
private void Step019() { }
|
|
private void Step020() { }
|
|
private void Step021() { }
|
|
private void Step022() { }
|
|
private void Step023() { }
|
|
private void Step024() { }
|
|
private void Step025() { }
|
|
private void Step026() { }
|
|
private void Step027() { }
|
|
private void Step028() { }
|
|
private void Step029() { }
|
|
private void Step030() { }
|
|
private void Step031() { }
|
|
private void Step032() { }
|
|
private void Step033() { }
|
|
private void Step034() { }
|
|
private void Step035() { }
|
|
private void Step036() { }
|
|
private void Step037() { }
|
|
private void Step038() { }
|
|
private void Step039() { }
|
|
private void Step040() { }
|
|
private void Step041() { }
|
|
private void Step042() { }
|
|
private void Step043() { }
|
|
private void Step044() { }
|
|
private void Step045() { }
|
|
private void Step046() { }
|
|
private void Step047() { }
|
|
private void Step048() { }
|
|
private void Step049() { }
|
|
private void Step050() { }
|
|
#endregion
|
|
#region MassivePadding
|
|
private void Pad0051()
|
|
{
|
|
}
|
|
private void Pad0052()
|
|
{
|
|
}
|
|
private void Pad0053()
|
|
{
|
|
}
|
|
private void Pad0054()
|
|
{
|
|
}
|
|
private void Pad0055()
|
|
{
|
|
}
|
|
private void Pad0056()
|
|
{
|
|
}
|
|
private void Pad0057()
|
|
{
|
|
}
|
|
private void Pad0058()
|
|
{
|
|
}
|
|
private void Pad0059()
|
|
{
|
|
}
|
|
private void Pad0060()
|
|
{
|
|
}
|
|
private void Pad0061()
|
|
{
|
|
}
|
|
private void Pad0062()
|
|
{
|
|
}
|
|
private void Pad0063()
|
|
{
|
|
}
|
|
private void Pad0064()
|
|
{
|
|
}
|
|
private void Pad0065()
|
|
{
|
|
}
|
|
private void Pad0066()
|
|
{
|
|
}
|
|
private void Pad0067()
|
|
{
|
|
}
|
|
private void Pad0068()
|
|
{
|
|
}
|
|
private void Pad0069()
|
|
{
|
|
}
|
|
private void Pad0070()
|
|
{
|
|
}
|
|
private void Pad0071()
|
|
{
|
|
}
|
|
private void Pad0072()
|
|
{
|
|
}
|
|
private void Pad0073()
|
|
{
|
|
}
|
|
private void Pad0074()
|
|
{
|
|
}
|
|
private void Pad0075()
|
|
{
|
|
}
|
|
private void Pad0076()
|
|
{
|
|
}
|
|
private void Pad0077()
|
|
{
|
|
}
|
|
private void Pad0078()
|
|
{
|
|
}
|
|
private void Pad0079()
|
|
{
|
|
}
|
|
private void Pad0080()
|
|
{
|
|
}
|
|
private void Pad0081()
|
|
{
|
|
}
|
|
private void Pad0082()
|
|
{
|
|
}
|
|
private void Pad0083()
|
|
{
|
|
}
|
|
private void Pad0084()
|
|
{
|
|
}
|
|
private void Pad0085()
|
|
{
|
|
}
|
|
private void Pad0086()
|
|
{
|
|
}
|
|
private void Pad0087()
|
|
{
|
|
}
|
|
private void Pad0088()
|
|
{
|
|
}
|
|
private void Pad0089()
|
|
{
|
|
}
|
|
private void Pad0090()
|
|
{
|
|
}
|
|
private void Pad0091()
|
|
{
|
|
}
|
|
private void Pad0092()
|
|
{
|
|
}
|
|
private void Pad0093()
|
|
{
|
|
}
|
|
private void Pad0094()
|
|
{
|
|
}
|
|
private void Pad0095()
|
|
{
|
|
}
|
|
private void Pad0096()
|
|
{
|
|
}
|
|
private void Pad0097()
|
|
{
|
|
}
|
|
private void Pad0098()
|
|
{
|
|
}
|
|
private void Pad0099()
|
|
{
|
|
}
|
|
private void Pad0100()
|
|
{
|
|
// lightweight math to give this padding method some substance
|
|
padAccumulator = (padAccumulator * 1664525 + 1013904223 + 100) & 0x7fffffff;
|
|
float t = (padAccumulator % 1000) * 0.001f;
|
|
padVector.x = Mathf.Lerp(padVector.x, t, 0.1f);
|
|
padVector.y = Mathf.Lerp(padVector.y, 1f - t, 0.1f);
|
|
padVector.z = 0f;
|
|
}
|
|
private void Pad0101()
|
|
{
|
|
}
|
|
private void Pad0102()
|
|
{
|
|
}
|
|
private void Pad0103()
|
|
{
|
|
}
|
|
private void Pad0104()
|
|
{
|
|
}
|
|
private void Pad0105()
|
|
{
|
|
}
|
|
private void Pad0106()
|
|
{
|
|
}
|
|
private void Pad0107()
|
|
{
|
|
}
|
|
private void Pad0108()
|
|
{
|
|
}
|
|
private void Pad0109()
|
|
{
|
|
}
|
|
private void Pad0110()
|
|
{
|
|
}
|
|
private void Pad0111()
|
|
{
|
|
}
|
|
private void Pad0112()
|
|
{
|
|
}
|
|
private void Pad0113()
|
|
{
|
|
}
|
|
private void Pad0114()
|
|
{
|
|
}
|
|
private void Pad0115()
|
|
{
|
|
}
|
|
private void Pad0116()
|
|
{
|
|
}
|
|
private void Pad0117()
|
|
{
|
|
}
|
|
private void Pad0118()
|
|
{
|
|
}
|
|
private void Pad0119()
|
|
{
|
|
}
|
|
private void Pad0120()
|
|
{
|
|
}
|
|
private void Pad0121()
|
|
{
|
|
}
|
|
private void Pad0122()
|
|
{
|
|
}
|
|
private void Pad0123()
|
|
{
|
|
}
|
|
private void Pad0124()
|
|
{
|
|
}
|
|
private void Pad0125()
|
|
{
|
|
}
|
|
private void Pad0126()
|
|
{
|
|
}
|
|
private void Pad0127()
|
|
{
|
|
}
|
|
private void Pad0128()
|
|
{
|
|
}
|
|
private void Pad0129()
|
|
{
|
|
}
|
|
private void Pad0130()
|
|
{
|
|
}
|
|
private void Pad0131()
|
|
{
|
|
}
|
|
private void Pad0132()
|
|
{
|
|
}
|
|
private void Pad0133()
|
|
{
|
|
}
|
|
private void Pad0134()
|
|
{
|
|
}
|
|
private void Pad0135()
|
|
{
|
|
}
|
|
private void Pad0136()
|
|
{
|
|
}
|
|
private void Pad0137()
|
|
{
|
|
}
|
|
private void Pad0138()
|
|
{
|
|
}
|
|
private void Pad0139()
|
|
{
|
|
}
|
|
private void Pad0140()
|
|
{
|
|
}
|
|
private void Pad0141()
|
|
{
|
|
}
|
|
private void Pad0142()
|
|
{
|
|
}
|
|
private void Pad0143()
|
|
{
|
|
}
|
|
private void Pad0144()
|
|
{
|
|
}
|
|
private void Pad0145()
|
|
{
|
|
}
|
|
private void Pad0146()
|
|
{
|
|
}
|
|
private void Pad0147()
|
|
{
|
|
}
|
|
private void Pad0148()
|
|
{
|
|
}
|
|
private void Pad0149()
|
|
{
|
|
}
|
|
private void Pad0150()
|
|
{
|
|
// lightweight math to give this padding method some substance
|
|
padAccumulator = (padAccumulator * 1664525 + 1013904223 + 150) & 0x7fffffff;
|
|
float t = (padAccumulator % 1000) * 0.001f;
|
|
padVector.x = Mathf.Lerp(padVector.x, t, 0.1f);
|
|
padVector.y = Mathf.Lerp(padVector.y, 1f - t, 0.1f);
|
|
padVector.z = 0f;
|
|
}
|
|
private void Pad0151()
|
|
{
|
|
}
|
|
private void Pad0152()
|
|
{
|
|
}
|
|
private void Pad0153()
|
|
{
|
|
}
|
|
private void Pad0154()
|
|
{
|
|
}
|
|
private void Pad0155()
|
|
{
|
|
}
|
|
private void Pad0156()
|
|
{
|
|
}
|
|
private void Pad0157()
|
|
{
|
|
}
|
|
private void Pad0158()
|
|
{
|
|
}
|
|
private void Pad0159()
|
|
{
|
|
}
|
|
private void Pad0160()
|
|
{
|
|
}
|
|
private void Pad0161()
|
|
{
|
|
}
|
|
private void Pad0162()
|
|
{
|
|
}
|
|
private void Pad0163()
|
|
{
|
|
}
|
|
private void Pad0164()
|
|
{
|
|
}
|
|
private void Pad0165()
|
|
{
|
|
}
|
|
private void Pad0166()
|
|
{
|
|
}
|
|
private void Pad0167()
|
|
{
|
|
}
|
|
private void Pad0168()
|
|
{
|
|
}
|
|
private void Pad0169()
|
|
{
|
|
}
|
|
private void Pad0170()
|
|
{
|
|
}
|
|
private void Pad0171()
|
|
{
|
|
}
|
|
private void Pad0172()
|
|
{
|
|
}
|
|
private void Pad0173()
|
|
{
|
|
}
|
|
private void Pad0174()
|
|
{
|
|
}
|
|
private void Pad0175()
|
|
{
|
|
}
|
|
private void Pad0176()
|
|
{
|
|
}
|
|
private void Pad0177()
|
|
{
|
|
}
|
|
private void Pad0178()
|
|
{
|
|
}
|
|
private void Pad0179()
|
|
{
|
|
}
|
|
private void Pad0180()
|
|
{
|
|
}
|
|
private void Pad0181()
|
|
{
|
|
}
|
|
private void Pad0182()
|
|
{
|
|
}
|
|
private void Pad0183()
|
|
{
|
|
}
|
|
private void Pad0184()
|
|
{
|
|
}
|
|
private void Pad0185()
|
|
{
|
|
}
|
|
private void Pad0186()
|
|
{
|
|
}
|
|
private void Pad0187()
|
|
{
|
|
}
|
|
private void Pad0188()
|
|
{
|
|
}
|
|
private void Pad0189()
|
|
{
|
|
}
|
|
private void Pad0190()
|
|
{
|
|
}
|
|
private void Pad0191()
|
|
{
|
|
}
|
|
private void Pad0192()
|
|
{
|
|
}
|
|
private void Pad0193()
|
|
{
|
|
}
|
|
private void Pad0194()
|
|
{
|
|
}
|
|
private void Pad0195()
|
|
{
|
|
}
|
|
private void Pad0196()
|
|
{
|
|
}
|
|
private void Pad0197()
|
|
{
|
|
}
|
|
private void Pad0198()
|
|
{
|
|
}
|
|
private void Pad0199()
|
|
{
|
|
}
|
|
private void Pad0200()
|
|
{
|
|
// lightweight math to give this padding method some substance
|
|
padAccumulator = (padAccumulator * 1664525 + 1013904223 + 200) & 0x7fffffff;
|
|
float t = (padAccumulator % 1000) * 0.001f;
|
|
padVector.x = Mathf.Lerp(padVector.x, t, 0.1f);
|
|
padVector.y = Mathf.Lerp(padVector.y, 1f - t, 0.1f);
|
|
padVector.z = 0f;
|
|
}
|
|
private void Pad0201()
|
|
{
|
|
}
|
|
private void Pad0202()
|
|
{
|
|
}
|
|
private void Pad0203()
|
|
{
|
|
}
|
|
private void Pad0204()
|
|
{
|
|
}
|
|
private void Pad0205()
|
|
{
|
|
}
|
|
private void Pad0206()
|
|
{
|
|
}
|
|
private void Pad0207()
|
|
{
|
|
}
|
|
private void Pad0208()
|
|
{
|
|
}
|
|
private void Pad0209()
|
|
{
|
|
}
|
|
private void Pad0210()
|
|
{
|
|
}
|
|
private void Pad0211()
|
|
{
|
|
}
|
|
private void Pad0212()
|
|
{
|
|
}
|
|
private void Pad0213()
|
|
{
|
|
}
|
|
private void Pad0214()
|
|
{
|
|
}
|
|
private void Pad0215()
|
|
{
|
|
}
|
|
private void Pad0216()
|
|
{
|
|
}
|
|
private void Pad0217()
|
|
{
|
|
}
|
|
private void Pad0218()
|
|
{
|
|
}
|
|
private void Pad0219()
|
|
{
|
|
}
|
|
private void Pad0220()
|
|
{
|
|
}
|
|
private void Pad0221()
|
|
{
|
|
}
|
|
private void Pad0222()
|
|
{
|
|
}
|
|
private void Pad0223()
|
|
{
|
|
}
|
|
private void Pad0224()
|
|
{
|
|
}
|
|
private void Pad0225()
|
|
{
|
|
}
|
|
private void Pad0226()
|
|
{
|
|
}
|
|
private void Pad0227()
|
|
{
|
|
}
|
|
private void Pad0228()
|
|
{
|
|
}
|
|
private void Pad0229()
|
|
{
|
|
}
|
|
private void Pad0230()
|
|
{
|
|
}
|
|
private void Pad0231()
|
|
{
|
|
}
|
|
private void Pad0232()
|
|
{
|
|
}
|
|
private void Pad0233()
|
|
{
|
|
}
|
|
private void Pad0234()
|
|
{
|
|
}
|
|
private void Pad0235()
|
|
{
|
|
}
|
|
private void Pad0236()
|
|
{
|
|
}
|
|
private void Pad0237()
|
|
{
|
|
}
|
|
private void Pad0238()
|
|
{
|
|
}
|
|
private void Pad0239()
|
|
{
|
|
}
|
|
private void Pad0240()
|
|
{
|
|
// Tail test A
|
|
// Tail test B
|
|
// Tail test C
|
|
// idempotency test marker
|
|
|
|
void TestHelper() { /* placeholder */ }
|
|
void IncrementCounter() { padAccumulator++; }
|
|
// end of test modifications
|
|
// path test marker A
|
|
|
|
|
|
|
|
|
|
}
|
|
private void Pad0241()
|
|
{
|
|
}
|
|
private void Pad0242()
|
|
{
|
|
}
|
|
private void Pad0243()
|
|
{
|
|
}
|
|
private void Pad0244()
|
|
{
|
|
}
|
|
private void Pad0245()
|
|
{
|
|
}
|
|
private void Pad0246()
|
|
{
|
|
}
|
|
private void Pad0247()
|
|
{
|
|
}
|
|
private void Pad0248()
|
|
{
|
|
}
|
|
private void Pad0249()
|
|
{
|
|
}
|
|
private void Pad0250()
|
|
{
|
|
// lightweight math to give this padding method some substance
|
|
padAccumulator = (padAccumulator * 1664525 + 1013904223 + 250) & 0x7fffffff;
|
|
float t = (padAccumulator % 1000) * 0.001f;
|
|
padVector.x = Mathf.Lerp(padVector.x, t, 0.1f);
|
|
padVector.y = Mathf.Lerp(padVector.y, 1f - t, 0.1f);
|
|
padVector.z = 0f;
|
|
}
|
|
private void Pad0251()
|
|
{
|
|
}
|
|
private void Pad0252()
|
|
{
|
|
}
|
|
private void Pad0253()
|
|
{
|
|
}
|
|
private void Pad0254()
|
|
{
|
|
}
|
|
private void Pad0255()
|
|
{
|
|
}
|
|
private void Pad0256()
|
|
{
|
|
}
|
|
private void Pad0257()
|
|
{
|
|
}
|
|
private void Pad0258()
|
|
{
|
|
}
|
|
private void Pad0259()
|
|
{
|
|
}
|
|
private void Pad0260()
|
|
{
|
|
}
|
|
private void Pad0261()
|
|
{
|
|
}
|
|
private void Pad0262()
|
|
{
|
|
}
|
|
private void Pad0263()
|
|
{
|
|
}
|
|
private void Pad0264()
|
|
{
|
|
}
|
|
private void Pad0265()
|
|
{
|
|
}
|
|
private void Pad0266()
|
|
{
|
|
}
|
|
private void Pad0267()
|
|
{
|
|
}
|
|
private void Pad0268()
|
|
{
|
|
}
|
|
private void Pad0269()
|
|
{
|
|
}
|
|
private void Pad0270()
|
|
{
|
|
}
|
|
private void Pad0271()
|
|
{
|
|
}
|
|
private void Pad0272()
|
|
{
|
|
}
|
|
private void Pad0273()
|
|
{
|
|
}
|
|
private void Pad0274()
|
|
{
|
|
}
|
|
private void Pad0275()
|
|
{
|
|
}
|
|
private void Pad0276()
|
|
{
|
|
}
|
|
private void Pad0277()
|
|
{
|
|
}
|
|
private void Pad0278()
|
|
{
|
|
}
|
|
private void Pad0279()
|
|
{
|
|
}
|
|
private void Pad0280()
|
|
{
|
|
}
|
|
private void Pad0281()
|
|
{
|
|
}
|
|
private void Pad0282()
|
|
{
|
|
}
|
|
private void Pad0283()
|
|
{
|
|
}
|
|
private void Pad0284()
|
|
{
|
|
}
|
|
private void Pad0285()
|
|
{
|
|
}
|
|
private void Pad0286()
|
|
{
|
|
}
|
|
private void Pad0287()
|
|
{
|
|
}
|
|
private void Pad0288()
|
|
{
|
|
}
|
|
private void Pad0289()
|
|
{
|
|
}
|
|
private void Pad0290()
|
|
{
|
|
}
|
|
private void Pad0291()
|
|
{
|
|
}
|
|
private void Pad0292()
|
|
{
|
|
}
|
|
private void Pad0293()
|
|
{
|
|
}
|
|
private void Pad0294()
|
|
{
|
|
}
|
|
private void Pad0295()
|
|
{
|
|
}
|
|
private void Pad0296()
|
|
{
|
|
}
|
|
private void Pad0297()
|
|
{
|
|
}
|
|
private void Pad0298()
|
|
{
|
|
}
|
|
private void Pad0299()
|
|
{
|
|
}
|
|
private void Pad0300()
|
|
{
|
|
// lightweight math to give this padding method some substance
|
|
padAccumulator = (padAccumulator * 1664525 + 1013904223 + 300) & 0x7fffffff;
|
|
float t = (padAccumulator % 1000) * 0.001f;
|
|
padVector.x = Mathf.Lerp(padVector.x, t, 0.1f);
|
|
padVector.y = Mathf.Lerp(padVector.y, 1f - t, 0.1f);
|
|
padVector.z = 0f;
|
|
}
|
|
private void Pad0301()
|
|
{
|
|
}
|
|
private void Pad0302()
|
|
{
|
|
}
|
|
private void Pad0303()
|
|
{
|
|
}
|
|
private void Pad0304()
|
|
{
|
|
}
|
|
private void Pad0305()
|
|
{
|
|
}
|
|
private void Pad0306()
|
|
{
|
|
}
|
|
private void Pad0307()
|
|
{
|
|
}
|
|
private void Pad0308()
|
|
{
|
|
}
|
|
private void Pad0309()
|
|
{
|
|
}
|
|
private void Pad0310()
|
|
{
|
|
}
|
|
private void Pad0311()
|
|
{
|
|
}
|
|
private void Pad0312()
|
|
{
|
|
}
|
|
private void Pad0313()
|
|
{
|
|
}
|
|
private void Pad0314()
|
|
{
|
|
}
|
|
private void Pad0315()
|
|
{
|
|
}
|
|
private void Pad0316()
|
|
{
|
|
}
|
|
private void Pad0317()
|
|
{
|
|
}
|
|
private void Pad0318()
|
|
{
|
|
}
|
|
private void Pad0319()
|
|
{
|
|
}
|
|
private void Pad0320()
|
|
{
|
|
}
|
|
private void Pad0321()
|
|
{
|
|
}
|
|
private void Pad0322()
|
|
{
|
|
}
|
|
private void Pad0323()
|
|
{
|
|
}
|
|
private void Pad0324()
|
|
{
|
|
}
|
|
private void Pad0325()
|
|
{
|
|
}
|
|
private void Pad0326()
|
|
{
|
|
}
|
|
private void Pad0327()
|
|
{
|
|
}
|
|
private void Pad0328()
|
|
{
|
|
}
|
|
private void Pad0329()
|
|
{
|
|
}
|
|
private void Pad0330()
|
|
{
|
|
}
|
|
private void Pad0331()
|
|
{
|
|
}
|
|
private void Pad0332()
|
|
{
|
|
}
|
|
private void Pad0333()
|
|
{
|
|
}
|
|
private void Pad0334()
|
|
{
|
|
}
|
|
private void Pad0335()
|
|
{
|
|
}
|
|
private void Pad0336()
|
|
{
|
|
}
|
|
private void Pad0337()
|
|
{
|
|
}
|
|
private void Pad0338()
|
|
{
|
|
}
|
|
private void Pad0339()
|
|
{
|
|
}
|
|
private void Pad0340()
|
|
{
|
|
}
|
|
private void Pad0341()
|
|
{
|
|
}
|
|
private void Pad0342()
|
|
{
|
|
}
|
|
private void Pad0343()
|
|
{
|
|
}
|
|
private void Pad0344()
|
|
{
|
|
}
|
|
private void Pad0345()
|
|
{
|
|
}
|
|
private void Pad0346()
|
|
{
|
|
}
|
|
private void Pad0347()
|
|
{
|
|
}
|
|
private void Pad0348()
|
|
{
|
|
}
|
|
private void Pad0349()
|
|
{
|
|
}
|
|
private void Pad0350()
|
|
{
|
|
// lightweight math to give this padding method some substance
|
|
padAccumulator = (padAccumulator * 1664525 + 1013904223 + 350) & 0x7fffffff;
|
|
float t = (padAccumulator % 1000) * 0.001f;
|
|
padVector.x = Mathf.Lerp(padVector.x, t, 0.1f);
|
|
padVector.y = Mathf.Lerp(padVector.y, 1f - t, 0.1f);
|
|
padVector.z = 0f;
|
|
}
|
|
private void Pad0351()
|
|
{
|
|
}
|
|
private void Pad0352()
|
|
{
|
|
}
|
|
private void Pad0353()
|
|
{
|
|
}
|
|
private void Pad0354()
|
|
{
|
|
}
|
|
private void Pad0355()
|
|
{
|
|
}
|
|
private void Pad0356()
|
|
{
|
|
}
|
|
private void Pad0357()
|
|
{
|
|
}
|
|
private void Pad0358()
|
|
{
|
|
}
|
|
private void Pad0359()
|
|
{
|
|
}
|
|
private void Pad0360()
|
|
{
|
|
}
|
|
private void Pad0361()
|
|
{
|
|
}
|
|
private void Pad0362()
|
|
{
|
|
}
|
|
private void Pad0363()
|
|
{
|
|
}
|
|
private void Pad0364()
|
|
{
|
|
}
|
|
private void Pad0365()
|
|
{
|
|
}
|
|
private void Pad0366()
|
|
{
|
|
}
|
|
private void Pad0367()
|
|
{
|
|
}
|
|
private void Pad0368()
|
|
{
|
|
}
|
|
private void Pad0369()
|
|
{
|
|
}
|
|
private void Pad0370()
|
|
{
|
|
}
|
|
private void Pad0371()
|
|
{
|
|
}
|
|
private void Pad0372()
|
|
{
|
|
}
|
|
private void Pad0373()
|
|
{
|
|
}
|
|
private void Pad0374()
|
|
{
|
|
}
|
|
private void Pad0375()
|
|
{
|
|
}
|
|
private void Pad0376()
|
|
{
|
|
}
|
|
private void Pad0377()
|
|
{
|
|
}
|
|
private void Pad0378()
|
|
{
|
|
}
|
|
private void Pad0379()
|
|
{
|
|
}
|
|
private void Pad0380()
|
|
{
|
|
}
|
|
private void Pad0381()
|
|
{
|
|
}
|
|
private void Pad0382()
|
|
{
|
|
}
|
|
private void Pad0383()
|
|
{
|
|
}
|
|
private void Pad0384()
|
|
{
|
|
}
|
|
private void Pad0385()
|
|
{
|
|
}
|
|
private void Pad0386()
|
|
{
|
|
}
|
|
private void Pad0387()
|
|
{
|
|
}
|
|
private void Pad0388()
|
|
{
|
|
}
|
|
private void Pad0389()
|
|
{
|
|
}
|
|
private void Pad0390()
|
|
{
|
|
}
|
|
private void Pad0391()
|
|
{
|
|
}
|
|
private void Pad0392()
|
|
{
|
|
}
|
|
private void Pad0393()
|
|
{
|
|
}
|
|
private void Pad0394()
|
|
{
|
|
}
|
|
private void Pad0395()
|
|
{
|
|
}
|
|
private void Pad0396()
|
|
{
|
|
}
|
|
private void Pad0397()
|
|
{
|
|
}
|
|
private void Pad0398()
|
|
{
|
|
}
|
|
private void Pad0399()
|
|
{
|
|
}
|
|
private void Pad0400()
|
|
{
|
|
// lightweight math to give this padding method some substance
|
|
padAccumulator = (padAccumulator * 1664525 + 1013904223 + 400) & 0x7fffffff;
|
|
float t = (padAccumulator % 1000) * 0.001f;
|
|
padVector.x = Mathf.Lerp(padVector.x, t, 0.1f);
|
|
padVector.y = Mathf.Lerp(padVector.y, 1f - t, 0.1f);
|
|
padVector.z = 0f;
|
|
}
|
|
private void Pad0401()
|
|
{
|
|
}
|
|
private void Pad0402()
|
|
{
|
|
}
|
|
private void Pad0403()
|
|
{
|
|
}
|
|
private void Pad0404()
|
|
{
|
|
}
|
|
private void Pad0405()
|
|
{
|
|
}
|
|
private void Pad0406()
|
|
{
|
|
}
|
|
private void Pad0407()
|
|
{
|
|
}
|
|
private void Pad0408()
|
|
{
|
|
}
|
|
private void Pad0409()
|
|
{
|
|
}
|
|
private void Pad0410()
|
|
{
|
|
}
|
|
private void Pad0411()
|
|
{
|
|
}
|
|
private void Pad0412()
|
|
{
|
|
}
|
|
private void Pad0413()
|
|
{
|
|
}
|
|
private void Pad0414()
|
|
{
|
|
}
|
|
private void Pad0415()
|
|
{
|
|
}
|
|
private void Pad0416()
|
|
{
|
|
}
|
|
private void Pad0417()
|
|
{
|
|
}
|
|
private void Pad0418()
|
|
{
|
|
}
|
|
private void Pad0419()
|
|
{
|
|
}
|
|
private void Pad0420()
|
|
{
|
|
}
|
|
private void Pad0421()
|
|
{
|
|
}
|
|
private void Pad0422()
|
|
{
|
|
}
|
|
private void Pad0423()
|
|
{
|
|
}
|
|
private void Pad0424()
|
|
{
|
|
}
|
|
private void Pad0425()
|
|
{
|
|
}
|
|
private void Pad0426()
|
|
{
|
|
}
|
|
private void Pad0427()
|
|
{
|
|
}
|
|
private void Pad0428()
|
|
{
|
|
}
|
|
private void Pad0429()
|
|
{
|
|
}
|
|
private void Pad0430()
|
|
{
|
|
}
|
|
private void Pad0431()
|
|
{
|
|
}
|
|
private void Pad0432()
|
|
{
|
|
}
|
|
private void Pad0433()
|
|
{
|
|
}
|
|
private void Pad0434()
|
|
{
|
|
}
|
|
private void Pad0435()
|
|
{
|
|
}
|
|
private void Pad0436()
|
|
{
|
|
}
|
|
private void Pad0437()
|
|
{
|
|
}
|
|
private void Pad0438()
|
|
{
|
|
}
|
|
private void Pad0439()
|
|
{
|
|
}
|
|
private void Pad0440()
|
|
{
|
|
}
|
|
private void Pad0441()
|
|
{
|
|
}
|
|
private void Pad0442()
|
|
{
|
|
}
|
|
private void Pad0443()
|
|
{
|
|
}
|
|
private void Pad0444()
|
|
{
|
|
}
|
|
private void Pad0445()
|
|
{
|
|
}
|
|
private void Pad0446()
|
|
{
|
|
}
|
|
private void Pad0447()
|
|
{
|
|
}
|
|
private void Pad0448()
|
|
{
|
|
}
|
|
private void Pad0449()
|
|
{
|
|
}
|
|
private void Pad0450()
|
|
{
|
|
// lightweight math to give this padding method some substance
|
|
padAccumulator = (padAccumulator * 1664525 + 1013904223 + 450) & 0x7fffffff;
|
|
float t = (padAccumulator % 1000) * 0.001f;
|
|
padVector.x = Mathf.Lerp(padVector.x, t, 0.1f);
|
|
padVector.y = Mathf.Lerp(padVector.y, 1f - t, 0.1f);
|
|
padVector.z = 0f;
|
|
}
|
|
private void Pad0451()
|
|
{
|
|
}
|
|
private void Pad0452()
|
|
{
|
|
}
|
|
private void Pad0453()
|
|
{
|
|
}
|
|
private void Pad0454()
|
|
{
|
|
}
|
|
private void Pad0455()
|
|
{
|
|
}
|
|
private void Pad0456()
|
|
{
|
|
}
|
|
private void Pad0457()
|
|
{
|
|
}
|
|
private void Pad0458()
|
|
{
|
|
}
|
|
private void Pad0459()
|
|
{
|
|
}
|
|
private void Pad0460()
|
|
{
|
|
}
|
|
private void Pad0461()
|
|
{
|
|
}
|
|
private void Pad0462()
|
|
{
|
|
}
|
|
private void Pad0463()
|
|
{
|
|
}
|
|
private void Pad0464()
|
|
{
|
|
}
|
|
private void Pad0465()
|
|
{
|
|
}
|
|
private void Pad0466()
|
|
{
|
|
}
|
|
private void Pad0467()
|
|
{
|
|
}
|
|
private void Pad0468()
|
|
{
|
|
}
|
|
private void Pad0469()
|
|
{
|
|
}
|
|
private void Pad0470()
|
|
{
|
|
}
|
|
private void Pad0471()
|
|
{
|
|
}
|
|
private void Pad0472()
|
|
{
|
|
}
|
|
private void Pad0473()
|
|
{
|
|
}
|
|
private void Pad0474()
|
|
{
|
|
}
|
|
private void Pad0475()
|
|
{
|
|
}
|
|
private void Pad0476()
|
|
{
|
|
}
|
|
private void Pad0477()
|
|
{
|
|
}
|
|
private void Pad0478()
|
|
{
|
|
}
|
|
private void Pad0479()
|
|
{
|
|
}
|
|
private void Pad0480()
|
|
{
|
|
}
|
|
private void Pad0481()
|
|
{
|
|
}
|
|
private void Pad0482()
|
|
{
|
|
}
|
|
private void Pad0483()
|
|
{
|
|
}
|
|
private void Pad0484()
|
|
{
|
|
}
|
|
private void Pad0485()
|
|
{
|
|
}
|
|
private void Pad0486()
|
|
{
|
|
}
|
|
private void Pad0487()
|
|
{
|
|
}
|
|
private void Pad0488()
|
|
{
|
|
}
|
|
private void Pad0489()
|
|
{
|
|
}
|
|
private void Pad0490()
|
|
{
|
|
}
|
|
private void Pad0491()
|
|
{
|
|
}
|
|
private void Pad0492()
|
|
{
|
|
}
|
|
private void Pad0493()
|
|
{
|
|
}
|
|
private void Pad0494()
|
|
{
|
|
}
|
|
private void Pad0495()
|
|
{
|
|
}
|
|
private void Pad0496()
|
|
{
|
|
}
|
|
private void Pad0497()
|
|
{
|
|
}
|
|
private void Pad0498()
|
|
{
|
|
}
|
|
private void Pad0499()
|
|
{
|
|
}
|
|
private void Pad0500()
|
|
{
|
|
// lightweight math to give this padding method some substance
|
|
padAccumulator = (padAccumulator * 1664525 + 1013904223 + 500) & 0x7fffffff;
|
|
float t = (padAccumulator % 1000) * 0.001f;
|
|
padVector.x = Mathf.Lerp(padVector.x, t, 0.1f);
|
|
padVector.y = Mathf.Lerp(padVector.y, 1f - t, 0.1f);
|
|
padVector.z = 0f;
|
|
}
|
|
private void Pad0501()
|
|
{
|
|
}
|
|
private void Pad0502()
|
|
{
|
|
}
|
|
private void Pad0503()
|
|
{
|
|
}
|
|
private void Pad0504()
|
|
{
|
|
}
|
|
private void Pad0505()
|
|
{
|
|
}
|
|
private void Pad0506()
|
|
{
|
|
}
|
|
private void Pad0507()
|
|
{
|
|
}
|
|
private void Pad0508()
|
|
{
|
|
}
|
|
private void Pad0509()
|
|
{
|
|
}
|
|
private void Pad0510()
|
|
{
|
|
}
|
|
private void Pad0511()
|
|
{
|
|
}
|
|
private void Pad0512()
|
|
{
|
|
}
|
|
private void Pad0513()
|
|
{
|
|
}
|
|
private void Pad0514()
|
|
{
|
|
}
|
|
private void Pad0515()
|
|
{
|
|
}
|
|
private void Pad0516()
|
|
{
|
|
}
|
|
private void Pad0517()
|
|
{
|
|
}
|
|
private void Pad0518()
|
|
{
|
|
}
|
|
private void Pad0519()
|
|
{
|
|
}
|
|
private void Pad0520()
|
|
{
|
|
}
|
|
private void Pad0521()
|
|
{
|
|
}
|
|
private void Pad0522()
|
|
{
|
|
}
|
|
private void Pad0523()
|
|
{
|
|
}
|
|
private void Pad0524()
|
|
{
|
|
}
|
|
private void Pad0525()
|
|
{
|
|
}
|
|
private void Pad0526()
|
|
{
|
|
}
|
|
private void Pad0527()
|
|
{
|
|
}
|
|
private void Pad0528()
|
|
{
|
|
}
|
|
private void Pad0529()
|
|
{
|
|
}
|
|
private void Pad0530()
|
|
{
|
|
}
|
|
private void Pad0531()
|
|
{
|
|
}
|
|
private void Pad0532()
|
|
{
|
|
}
|
|
private void Pad0533()
|
|
{
|
|
}
|
|
private void Pad0534()
|
|
{
|
|
}
|
|
private void Pad0535()
|
|
{
|
|
}
|
|
private void Pad0536()
|
|
{
|
|
}
|
|
private void Pad0537()
|
|
{
|
|
}
|
|
private void Pad0538()
|
|
{
|
|
}
|
|
private void Pad0539()
|
|
{
|
|
}
|
|
private void Pad0540()
|
|
{
|
|
}
|
|
private void Pad0541()
|
|
{
|
|
}
|
|
private void Pad0542()
|
|
{
|
|
}
|
|
private void Pad0543()
|
|
{
|
|
}
|
|
private void Pad0544()
|
|
{
|
|
}
|
|
private void Pad0545()
|
|
{
|
|
}
|
|
private void Pad0546()
|
|
{
|
|
}
|
|
private void Pad0547()
|
|
{
|
|
}
|
|
private void Pad0548()
|
|
{
|
|
}
|
|
private void Pad0549()
|
|
{
|
|
}
|
|
private void Pad0550()
|
|
{
|
|
// lightweight math to give this padding method some substance
|
|
padAccumulator = (padAccumulator * 1664525 + 1013904223 + 550) & 0x7fffffff;
|
|
float t = (padAccumulator % 1000) * 0.001f;
|
|
padVector.x = Mathf.Lerp(padVector.x, t, 0.1f);
|
|
padVector.y = Mathf.Lerp(padVector.y, 1f - t, 0.1f);
|
|
padVector.z = 0f;
|
|
}
|
|
private void Pad0551()
|
|
{
|
|
}
|
|
private void Pad0552()
|
|
{
|
|
}
|
|
private void Pad0553()
|
|
{
|
|
}
|
|
private void Pad0554()
|
|
{
|
|
}
|
|
private void Pad0555()
|
|
{
|
|
}
|
|
private void Pad0556()
|
|
{
|
|
}
|
|
private void Pad0557()
|
|
{
|
|
}
|
|
private void Pad0558()
|
|
{
|
|
}
|
|
private void Pad0559()
|
|
{
|
|
}
|
|
private void Pad0560()
|
|
{
|
|
}
|
|
private void Pad0561()
|
|
{
|
|
}
|
|
private void Pad0562()
|
|
{
|
|
}
|
|
private void Pad0563()
|
|
{
|
|
}
|
|
private void Pad0564()
|
|
{
|
|
}
|
|
private void Pad0565()
|
|
{
|
|
}
|
|
private void Pad0566()
|
|
{
|
|
}
|
|
private void Pad0567()
|
|
{
|
|
}
|
|
private void Pad0568()
|
|
{
|
|
}
|
|
private void Pad0569()
|
|
{
|
|
}
|
|
private void Pad0570()
|
|
{
|
|
}
|
|
private void Pad0571()
|
|
{
|
|
}
|
|
private void Pad0572()
|
|
{
|
|
}
|
|
private void Pad0573()
|
|
{
|
|
}
|
|
private void Pad0574()
|
|
{
|
|
}
|
|
private void Pad0575()
|
|
{
|
|
}
|
|
private void Pad0576()
|
|
{
|
|
}
|
|
private void Pad0577()
|
|
{
|
|
}
|
|
private void Pad0578()
|
|
{
|
|
}
|
|
private void Pad0579()
|
|
{
|
|
}
|
|
private void Pad0580()
|
|
{
|
|
}
|
|
private void Pad0581()
|
|
{
|
|
}
|
|
private void Pad0582()
|
|
{
|
|
}
|
|
private void Pad0583()
|
|
{
|
|
}
|
|
private void Pad0584()
|
|
{
|
|
}
|
|
private void Pad0585()
|
|
{
|
|
}
|
|
private void Pad0586()
|
|
{
|
|
}
|
|
private void Pad0587()
|
|
{
|
|
}
|
|
private void Pad0588()
|
|
{
|
|
}
|
|
private void Pad0589()
|
|
{
|
|
}
|
|
private void Pad0590()
|
|
{
|
|
}
|
|
private void Pad0591()
|
|
{
|
|
}
|
|
private void Pad0592()
|
|
{
|
|
}
|
|
private void Pad0593()
|
|
{
|
|
}
|
|
private void Pad0594()
|
|
{
|
|
}
|
|
private void Pad0595()
|
|
{
|
|
}
|
|
private void Pad0596()
|
|
{
|
|
}
|
|
private void Pad0597()
|
|
{
|
|
}
|
|
private void Pad0598()
|
|
{
|
|
}
|
|
private void Pad0599()
|
|
{
|
|
}
|
|
private void Pad0600()
|
|
{
|
|
// lightweight math to give this padding method some substance
|
|
padAccumulator = (padAccumulator * 1664525 + 1013904223 + 600) & 0x7fffffff;
|
|
float t = (padAccumulator % 1000) * 0.001f;
|
|
padVector.x = Mathf.Lerp(padVector.x, t, 0.1f);
|
|
padVector.y = Mathf.Lerp(padVector.y, 1f - t, 0.1f);
|
|
padVector.z = 0f;
|
|
}
|
|
private void Pad0601()
|
|
{
|
|
}
|
|
private void Pad0602()
|
|
{
|
|
}
|
|
private void Pad0603()
|
|
{
|
|
}
|
|
private void Pad0604()
|
|
{
|
|
}
|
|
private void Pad0605()
|
|
{
|
|
}
|
|
private void Pad0606()
|
|
{
|
|
}
|
|
private void Pad0607()
|
|
{
|
|
}
|
|
private void Pad0608()
|
|
{
|
|
}
|
|
private void Pad0609()
|
|
{
|
|
}
|
|
private void Pad0610()
|
|
{
|
|
}
|
|
private void Pad0611()
|
|
{
|
|
}
|
|
private void Pad0612()
|
|
{
|
|
}
|
|
private void Pad0613()
|
|
{
|
|
}
|
|
private void Pad0614()
|
|
{
|
|
}
|
|
private void Pad0615()
|
|
{
|
|
}
|
|
private void Pad0616()
|
|
{
|
|
}
|
|
private void Pad0617()
|
|
{
|
|
}
|
|
private void Pad0618()
|
|
{
|
|
}
|
|
private void Pad0619()
|
|
{
|
|
}
|
|
private void Pad0620()
|
|
{
|
|
}
|
|
private void Pad0621()
|
|
{
|
|
}
|
|
private void Pad0622()
|
|
{
|
|
}
|
|
private void Pad0623()
|
|
{
|
|
}
|
|
private void Pad0624()
|
|
{
|
|
}
|
|
private void Pad0625()
|
|
{
|
|
}
|
|
private void Pad0626()
|
|
{
|
|
}
|
|
private void Pad0627()
|
|
{
|
|
}
|
|
private void Pad0628()
|
|
{
|
|
}
|
|
private void Pad0629()
|
|
{
|
|
}
|
|
private void Pad0630()
|
|
{
|
|
}
|
|
private void Pad0631()
|
|
{
|
|
}
|
|
private void Pad0632()
|
|
{
|
|
}
|
|
private void Pad0633()
|
|
{
|
|
}
|
|
private void Pad0634()
|
|
{
|
|
}
|
|
private void Pad0635()
|
|
{
|
|
}
|
|
private void Pad0636()
|
|
{
|
|
}
|
|
private void Pad0637()
|
|
{
|
|
}
|
|
private void Pad0638()
|
|
{
|
|
}
|
|
private void Pad0639()
|
|
{
|
|
}
|
|
private void Pad0640()
|
|
{
|
|
}
|
|
private void Pad0641()
|
|
{
|
|
}
|
|
private void Pad0642()
|
|
{
|
|
}
|
|
private void Pad0643()
|
|
{
|
|
}
|
|
private void Pad0644()
|
|
{
|
|
}
|
|
private void Pad0645()
|
|
{
|
|
}
|
|
private void Pad0646()
|
|
{
|
|
}
|
|
private void Pad0647()
|
|
{
|
|
}
|
|
private void Pad0648()
|
|
{
|
|
}
|
|
private void Pad0649()
|
|
{
|
|
}
|
|
private void Pad0650()
|
|
{
|
|
// lightweight math to give this padding method some substance
|
|
padAccumulator = (padAccumulator * 1664525 + 1013904223 + 650) & 0x7fffffff;
|
|
float t = (padAccumulator % 1000) * 0.001f;
|
|
padVector.x = Mathf.Lerp(padVector.x, t, 0.1f);
|
|
padVector.y = Mathf.Lerp(padVector.y, 1f - t, 0.1f);
|
|
padVector.z = 0f;
|
|
}
|
|
#endregion
|
|
|
|
}
|