public void OrthonormalBasisTest()
{
var p = new CSP();
p.MaxSteps = 10000000;
var v1 = new Vector3Variable("v1", p, box);
var v2 = new Vector3Variable("v2", p, box);
var v3 = new Vector3Variable("v3", p, box);
v1.Magnitude.MustEqual(1);
v2.Magnitude.MustEqual(1);
v3.Magnitude.MustEqual(1);
v1.MustBePerpendicular(v2);
v2.MustBePerpendicular(v3);
v3.MustBePerpendicular(v1);
for (int count = 0; count < 10; count++)
{
p.NewSolution();
double magnitude = Math.Sqrt(v1.X * v1.X + v1.Y * v1.Y + v1.Z * v1.Z);
Assert.IsTrue(MathUtil.NearlyEqual(magnitude, 1), "Magnitude not unity; was: " + magnitude);
double dotProduct = v1.X * v2.X + v1.Y * v2.Y + v1.Z * v2.Z;
Assert.IsTrue(MathUtil.NearlyEqual(dotProduct, 0), "Dot product not zero; was: " + dotProduct);
magnitude = Math.Sqrt(v2.X * v2.X + v2.Y * v2.Y + v2.Z * v2.Z);
Assert.IsTrue(MathUtil.NearlyEqual(magnitude, 1), "Magnitude not unity; was: " + magnitude);
dotProduct = v2.X * v3.X + v2.Y * v3.Y + v2.Z * v3.Z;
Assert.IsTrue(MathUtil.NearlyEqual(dotProduct, 0), "Dot product not zero; was: " + dotProduct);
magnitude = Math.Sqrt(v3.X * v3.X + v3.Y * v3.Y + v3.Z * v3.Z);
Assert.IsTrue(MathUtil.NearlyEqual(magnitude, 1), "Magnitude not unity; was: " + magnitude);
dotProduct = v3.X * v1.X + v3.Y * v1.Y + v3.Z * v1.Z;
Assert.IsTrue(MathUtil.NearlyEqual(dotProduct, 0), "Dot product not zero; was: " + dotProduct);
}
}
private object ApplyProjectHorizontal(List <object> args)
{
if (args.Count != 4)
{
throw new ArgumentException("projectHorizontal requires 4 arguments: target, cameraLocation, opticAxis, focalLength");
}
var target = args[0] as Vector3Variable;
var cameraPosition = args[1] as Vector3Variable;
var opticAxis = args[2] as Vector3Variable;
var focalLength = args[3] as FloatVariable;
if (target == null || cameraPosition == null || opticAxis == null || focalLength == null)
{
throw new ArgumentException("Invalid argument type in call to Project(Vector3, Vector3, Vector3, float)");
}
var offset = target - cameraPosition;
var depth = Vector3Variable.Dot(opticAxis, offset);
// Axis must be a unit vector
opticAxis.Magnitude.MustEqual(1);
// Target must be at least 1mm in front of the camera
depth.MustBeContainedIn(new Interval(0.001, double.PositiveInfinity));
var yProjection = focalLength * offset.Y / depth;
var xProjection = focalLength * (offset.X * opticAxis.Z - offset.Z * opticAxis.X) / depth;
return(new Vector3Variable(xProjection, yProjection, FloatVariable.Constant(CSP, 1)));
}
// Use this for initialization
void Start()
{
rigidBody = GetComponent <Rigidbody>();
this.rigidBody.AddRelativeForce(new Vector3(velocity, 0, 0));
isAnchored = false;
distance = (Vector3Variable)ScriptableObject.CreateInstance("Vector3Variable");
}
private void AddValueToList(FieldInfo f)
{
IBaseVariable variable = null;
if (f.FieldType.ToString() == "System.String")
{
variable = new StringVariable();
}
else if (f.FieldType.ToString() == "System.Int32")
{
variable = new IntegerVariable();
}
else if (f.FieldType.ToString() == "System.Single")
{
variable = new FloatVariable();
}
else if (f.FieldType.ToString() == "System.Boolean")
{
variable = new BooleanVariable();
}
else if (f.FieldType.ToString() == "System.String[]")
{
variable = new StringVariableArray();
}
else if (f.FieldType.ToString() == "System.Int32[]")
{
variable = new IntegerVariableArray();
}
else if (f.FieldType.ToString() == "System.Single[]")
{
variable = new FloatVariableArray();
}
else if (f.FieldType.ToString() == "System.Boolean[]")
{
variable = new BooleanVariableArray();
}
else if (f.FieldType.ToString() == "UnityEngine.Vector2")
{
variable = new Vector2Variable();
}
else if (f.FieldType.ToString() == "UnityEngine.Vector3")
{
variable = new Vector3Variable();
}
else if (f.FieldType.ToString() == "UnityEngine.Vector2[]")
{
variable = new Vector2VariableArray();
}
else if (f.FieldType.ToString() == "UnityEngine.Vector3[]")
{
variable = new Vector3VariableArray();
}
if (variable != null)
{
variable.value = f.GetValue(this);
ListValue.Add((string)f.Name, variable);
}
}
public void SetTarget(Vector3Variable target)
{
if (_targetVariable != null)
{
_targetVariable.OnValueChange -= UpdatePosition;
}
_targetVariable = target;
_targetVariable.OnValueChange += UpdatePosition;
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
Vector3Variable myScript = (Vector3Variable)target;
if (GUILayout.Button("Invoke"))
{
myScript.ValueChangedEvent.Invoke();
}
}
/// <summary>
/// Assign either the Left or Right variable depending on the Hand that is selected
/// </summary>
void CheckHand()
{
if (Hand == Hand.LEFT)
{
thumbPosition = LeftThumbPosition;
touchpadIsPressed = LeftTouchpadIsPressed;
}
else
{
thumbPosition = RightThumbPosition;
touchpadIsPressed = RightTouchpadIsPressed;
}
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
Vector3Variable vector3Variable = (Vector3Variable)target;
if (Application.isPlaying)
{
vector3Variable.RuntimeValue = EditorGUILayout.Vector3Field("Runtime Value", vector3Variable.RuntimeValue);
}
else
{
GUILayout.Label("Runtime Value: " + vector3Variable.RuntimeValue.ToString());
}
}
public void UnitVectorTest()
{
var p = new CSP();
var v = new Vector3Variable("v", p, box);
v.Magnitude.MustEqual(1);
for (int count = 0; count < 1000; count++)
{
p.NewSolution();
double magnitude = Math.Sqrt(v.X * v.X + v.Y * v.Y + v.Z * v.Z);
Assert.IsTrue(MathUtil.NearlyEqual(magnitude, 1), "Magnitude not unity; was: " + magnitude);
}
}
public void DotProductOneVectorFixedTest()
{
var p = new CSP();
var eX = new Vector3Variable("eX", p, 1, 0, 0);
var unknown = new Vector3Variable("unknown", p, box);
var dot = Vector3Variable.Dot(eX, unknown);
dot.MustEqual(0);
for (int count = 0; count < 1000; count++)
{
p.NewSolution();
Assert.IsTrue(MathUtil.NearlyEqual(unknown.X.UniqueValue, 0));
}
}
public void DotProductTest()
{
var p = new CSP();
var v1 = new Vector3Variable("v1", p, box);
var v2 = new Vector3Variable("v2", p, box);
var dot = Vector3Variable.Dot(v1, v2);
dot.MustEqual(0);
for (int count = 0; count < 1000; count++)
{
p.NewSolution();
double dotProduct = v1.X.UniqueValue * v2.X.UniqueValue + v1.Y.UniqueValue * v2.Y.UniqueValue + v1.Z.UniqueValue * v2.Z.UniqueValue;
Assert.IsTrue(MathUtil.NearlyEqual(dotProduct, 0), "Dot product not zero; was: " + dotProduct);
}
}
/// <summary>
/// Set an Vector3Variable with the given tag.
/// </summary>
/// <param name="tag"></param>
/// <param name="value"></param>
/// <returns></returns>
public void SetVector3(string tag, Vector3 value)
{
foreach (var variable in Vector3Variables)
{
if (variable.Tag == tag)
{
variable.Value = value;
return;
}
}
//Not found
var newVariable = new Vector3Variable();
newVariable.Tag = tag;
newVariable.Value = value;
Vector3Variables.Add(newVariable);
}
private void Update()
{
if (normalized == null)
{
normalized = new FloatVariable();
}
if (value == null)
{
value = new Vector3Variable();
}
value.runtimeValue.x = curveX.Evaluate(normalized);
value.runtimeValue.y = curveY.Evaluate(normalized);
value.runtimeValue.z = curveZ.Evaluate(normalized);
transform.localScale = value.runtimeValue;
}
IEnumerator sendCardToPlatformingUI()
{
Vector3 originalPosition = transform.position;
float originalScale = transform.localScale.x;
Vector3Variable targetPosition = null;
switch (card.Ability)
{
case Ability.Dash:
targetPosition = DashMeterLocation;
break;
case Ability.Glide:
targetPosition = GlideMeterLocation;
break;
case Ability.ExtraJump:
targetPosition = ExtraJumpMeterLocation;
break;
case Ability.SuperJump:
targetPosition = SuperJumpMeterLocation;
break;
}
ToPlatformingUITransition.FlashFromTo(0, 1);
while (ToPlatformingUITransition.Transitioning)
{
float t = ToPlatformingUITransition.Value;
transform.position = Vector3.Lerp(originalPosition, targetPosition.Value, t);
transform.localScale = Vector3.one * Mathf.Lerp(originalScale, ToPlatformingUITargetScale, t);
yield return(null);
}
PlayerAbilityCharges[card.Ability]++;
destroyCard();
}
public void EditorSetVariableData(Vector3Variable global, Vector3VariableInstanced instanced, Vector3 constant,
AssignmentType type, IDTokenHolder tokenHolder)
{
_assignmentType = type;
EditorSetTokenHolder(tokenHolder);
switch (type)
{
case AssignmentType.Constant:
_constantValue = constant;
break;
case AssignmentType.GlobalVariable:
_globalVariable = global;
break;
case AssignmentType.PersonalVariable:
_instancedVariable = instanced;
break;
}
}
public void SetValue(Vector3Variable value)
{
Value = value.Value;
}
public void ModValue(Vector3Variable amount)
{
value += amount.value;
}
public void SetValue(Vector3Variable v)
{
value = v.value;
}
public void InitManual(Vector2 camOffset, bool useSmoothDamp, Vector2 value, Vector3Variable playerPos)
{
Init(camOffset, useSmoothDamp, value);
this.playerPos = playerPos;
GameInput.BindEvent(GameEventType.NextRoom, room => ToNextRoom(GameManager.GetBoundsFromRoom(room).ToBounds()));
}
public void SetupHealthBar(AtomBaseVariable enemyData)
{
var enemyDataCollection = (AtomCollection)enemyData;
var healthBar = Instantiate(_healthBarPrefab).GetComponent <HealthBar>();
healthBar.transform.SetParent(transform);
IntVariable health = default;
Vector3Variable position = default;
Action <Vector3> positionChangedHandler = default;
Action <AtomBaseVariable> varAddedHandler = (AtomBaseVariable baseVar) =>
{
switch (baseVar.Id)
{
case "Health":
var healthVar = (IntVariable)baseVar;
health = healthVar;
healthBar.InitialHealth.Value = healthVar.InitialValue;
healthVar.Changed.Register(healthBar.HealthChanged);
break;
case "Position":
var positionVar = (Vector3Variable)baseVar;
position = positionVar;
positionChangedHandler = (pos) =>
{
Vector2 viewportPos = Camera.main.WorldToViewportPoint(pos);
Vector2 healthBarPos = new Vector2(
(viewportPos.x * _canvasRectTransform.sizeDelta.x) - (_canvasRectTransform.sizeDelta.x * 0.5f),
(viewportPos.y * _canvasRectTransform.sizeDelta.y) - (_canvasRectTransform.sizeDelta.y * 0.5f) + 38f
);
healthBar.GetComponent <RectTransform>().anchoredPosition = healthBarPos;
};
positionVar.Changed.Register(positionChangedHandler);
break;
}
};
Action <AtomBaseVariable> varRemovedHandler = (AtomBaseVariable baseVar) =>
{
switch (baseVar.Id)
{
case "Health":
var healthVar = (IntVariable)baseVar;
healthVar.Changed.Unregister(healthBar.HealthChanged);
break;
case "Position":
var positionVar = (Vector3Variable)baseVar;
positionVar.Changed.Unregister(positionChangedHandler);
break;
}
};
enemyDataCollection.Added.Register(varAddedHandler);
enemyDataCollection.Removed.Register(varRemovedHandler);
Action <AtomBaseVariable> enemyDataRemovedHandler = default;
enemyDataRemovedHandler = (enemyDataToBeRemoved) =>
{
if (enemyDataToBeRemoved == enemyData)
{
enemyDataCollection.Added.Unregister(varAddedHandler);
enemyDataCollection.Removed.Unregister(varRemovedHandler);
_enemies.Removed.Unregister(enemyDataRemovedHandler);
if (healthBar != null && healthBar.gameObject != null)
{
if (health != null)
{
health.Changed.Unregister(healthBar.HealthChanged);
}
else if (position != null)
{
position.Changed.Unregister(positionChangedHandler);
}
Destroy(healthBar.gameObject);
}
}
};
_enemies.Removed.Register(enemyDataRemovedHandler);
}
public void SetValue(Vector3Variable para)
{
value = para.value;
}
public void SendPlayerVRPosToOthers(Vector3Variable playerVRPosition) => photonView.RPC("SendVector3", RpcTarget.Others, playerVRPosition.Value);
public void PopulateContainer()
{
TriggerVariables.Clear();
BoolVariables.Clear();
IntVariables.Clear();
FloatVariables.Clear();
Vector2Variables.Clear();
Vector3Variables.Clear();
QuaternionVariables.Clear();
TimerVariables.Clear();
foreach (var propertyPath in AssetDatabaseUtils.GetAssetRelativePaths(FolderPath, IncludeSubdirectories))
{
TriggerVariable assetAsTrigger =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(TriggerVariable)) as TriggerVariable;
if (assetAsTrigger != null)
{
TriggerVariables.Add(assetAsTrigger);
continue;
}
BoolVariable assetAsBool =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(BoolVariable)) as BoolVariable;
if (assetAsBool != null)
{
BoolVariables.Add(assetAsBool);
continue;
}
IntVariable assetAsInt =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(IntVariable)) as IntVariable;
if (assetAsInt != null)
{
IntVariables.Add(assetAsInt);
continue;
}
FloatVariable assetAsFloat =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(FloatVariable)) as FloatVariable;
if (assetAsFloat != null)
{
FloatVariables.Add(assetAsFloat);
continue;
}
Vector2Variable assetAsVector2 =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(Vector2Variable)) as Vector2Variable;
if (assetAsVector2 != null)
{
Vector2Variables.Add(assetAsVector2);
continue;
}
Vector3Variable assetAsVector3 =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(Vector3Variable)) as Vector3Variable;
if (assetAsVector3 != null)
{
Vector3Variables.Add(assetAsVector3);
continue;
}
QuaternionVariable assetAsQuaternion =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(QuaternionVariable)) as QuaternionVariable;
if (assetAsQuaternion != null)
{
QuaternionVariables.Add(assetAsQuaternion);
continue;
}
TimerVariable assetAsTimer =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(TimerVariable)) as TimerVariable;
if (assetAsTimer != null)
{
TimerVariables.Add(assetAsTimer);
continue;
}
FunctionVariable assetAsFunction =
AssetDatabase.LoadAssetAtPath(propertyPath, typeof(TimerVariable)) as FunctionVariable;
if (assetAsFunction != null)
{
FunctionVariables.Add(assetAsFunction);
continue;
}
}
Debug.Log($"{TriggerVariables.Count} Triggers" +
$" | {BoolVariables.Count} Bools" +
$" | {IntVariables.Count} Ints" +
$" | {FloatVariables.Count} Floats" +
$" | {Vector2Variables.Count} Vector2s" +
$" | {Vector3Variables.Count} Vector3s" +
$" | {QuaternionVariables.Count} Quaternions" +
$" | {TimerVariables.Count} Timers" +
$" | {FunctionVariables.Count} Functions");
}
public void AddForce(Vector3Variable force)
{
Sleep = false;
//_velocity1
_currentForce += force;
}
public Vector3Data(Vector3 v)
{
vector3Val = v;
vector3Ref = null;
}
public void ApplyChange(Vector3Variable amount)
{
Value += amount.Value;
}
public void SetDefaultValue(Vector3Variable value)
{
defaultValue = value.currentValue;
}
public void SetValue(Vector3Variable value)
{
CurrentValue = value.CurrentValue;
}
public void SetVector(Vector3Variable _vector)
{
value = _vector.Value;
}
private void MakeVector3Variable(CSP csp)
{
this.mVector3Variable = new Vector3Variable(VariableName, csp, new BoundingBox(new Interval(Min, Max), new Interval(MinY, MaxY), new Interval(MinZ, MaxZ)));
}
