public Vector3 getDesiredPositionDelta( Bounds targetBounds, Vector3 basePosition, Vector3 targetAvgVelocity )
{
var desiredOffset = Vector3.zero;
var hasHorizontal = ( axis & CameraAxis.Horizontal ) == CameraAxis.Horizontal;
var hasVertical = ( axis & CameraAxis.Vertical ) == CameraAxis.Vertical;
var bounds = new Bounds( basePosition, new Vector3( width, height, 5f ) );
if( !bounds.Contains( targetBounds.max ) || !bounds.Contains( targetBounds.min ) )
{
// figure out the minimum distance we need to move to get the player back in our bounds
// x-axis
if( hasHorizontal && bounds.min.x > targetBounds.min.x )
{
desiredOffset.x = targetBounds.min.x - bounds.min.x;
}
else if( hasHorizontal && bounds.max.x < targetBounds.max.x )
{
desiredOffset.x = targetBounds.max.x - bounds.max.x;
}
// y-axis. disregard movement above the trap when in platform snap mode
if( hasVertical && bounds.min.y > targetBounds.min.y )
{
desiredOffset.y = targetBounds.min.y - bounds.min.y;
}
else if( /*!inPlatformSnapMode &&*/ hasVertical && bounds.max.y < targetBounds.max.y )
{
desiredOffset.y = targetBounds.max.y - bounds.max.y;
}
}
return desiredOffset;
}
protected override void FixedUpdate()
{
base.FixedUpdate();
_realDetectionBlock = DetectionBlock;
_realDetectionBlock.center = DetectionBlock.center + this.transform.position;
if (IsFreeToMove && !IsDead && !IsHurt) {
if (!IsAttacking && !IsHurt && ValidateDetection()) {
if (AlwaysFollow) {
_following = true;
}
if (!IsAttacking && !IsHurt
&& this.transform.position.x - RangeOfAttack <= ProtaController.transform.position.x
&& this.transform.position.x + RangeOfAttack >= ProtaController.transform.position.x
&& _realDetectionBlock.Contains(ProtaController.transform.position)) {
_delayToAttackCounter += Time.deltaTime;
if (_delayToAttackCounter >= DelayToAttack) {
if (!IsAttacking && !IsHurt && this.transform.position.x > ProtaController.transform.position.x) {
this.ChangePlayerDirection("left");
this.ChangePlayerState(PlayerState.Attacking);
} else if (!IsAttacking && !IsHurt) {
this.ChangePlayerDirection("right");
this.ChangePlayerState(PlayerState.Attacking);
}
_delayToAttackCounter = 0.0f;
} else {
this.ChangePlayerState(PlayerState.Idle);
}
} else if (!IsAttacking && !IsHurt && ( _realDetectionBlock.Contains(ProtaController.transform.position) || _following )) {
// At Left
if (!IsAttacking && !IsHurt && this.transform.position.x - RangeOfAttack > ProtaController.transform.position.x) {
this.HorizontalMovement("left");
} else if (!IsAttacking && !IsHurt && this.transform.position.x + RangeOfAttack < ProtaController.transform.position.x) {
this.HorizontalMovement("right");
} else {
this.ChangePlayerState(PlayerState.Idle);
}
} else if (!IsAttacking && !IsHurt) {
this.ChangePlayerState(PlayerState.Idle);
}
} else if (!IsAttacking && !IsHurt) {
this.ChangePlayerState(PlayerState.Idle);
}
}
}
public static void setScope(Bounds pBounds, Transform pParent,NetworkPlayer pPlayer)
{
foreach (Transform lTransform in pParent)
{
lTransform.networkView.SetScope(pPlayer,pBounds.Contains(lTransform.position));
}
}
public static Vector3 BoundsInBoundsCheck( Bounds bigB, Bounds lilB, BoundsTest test = BoundsTest.onScreen)
{
Vector3 pos = lilB.center;
Vector3 off = Vector3.zero;
switch (test) {
case BoundsTest.center:
if (bigB.Contains(pos)){
return(Vector3.zero);
}
if(pos.x > bigB.max.x){
off.x = pos.x - bigB.max.x;
} else if (pos.x < bigB.min.x){
off.x = pos.x - bigB.min.x;
}
if(pos.y > bigB.max.y){
off.y = pos.y - bigB.max.y;
} else if (pos.y < bigB.min.y){
off.y = pos.y - bigB.min.y;
}
if(pos.z > bigB.max.z){
off.z = pos.z - bigB.max.z;
} else if (pos.z < bigB.min.z){
off.z = pos.z - bigB.min.z;
}
return(off);
}
return(Vector3.zero);
}
private List<Vector3> DynamicSetupList(float minX, float maxX, float minZ, float maxZ, Bounds bR, Bounds bM)
{
List<Vector3> checkList = new List<Vector3>();
float Tilesize = Pathfinder.Instance.Tilesize;
for (float i = minZ; i < maxZ; i += Tilesize / 2)
{
for (float j = minX; j < maxX; j += Tilesize / 2)
{
for (float k = bR.min.y; k < bR.max.y; k += Tilesize)
{
if (k > lowestY)
{
Vector3 local = transform.InverseTransformPoint(new Vector3(j, k, i));
if (bM.Contains(local))
{
checkList.Add(new Vector3(j, k, i));
}
}
}
}
}
return checkList;
}
ZigTrackedUser LookForTrackedUserInRegion(ZigInput zig, Bounds region) {
foreach (ZigTrackedUser trackedUser in zig.TrackedUsers.Values) {
if (trackedUser.SkeletonTracked && region.Contains(trackedUser.Position) && trackedUser != leftTrackedUser && trackedUser != rightTrackedUser) {
return trackedUser;
}
}
return null;
}
// Add fields here that your job needs to do its work.
// For example,
// public float deltaTime;
public void Execute(ref MoveTarget target, [ReadOnly] ref AIConstrain constrain, [ReadOnly] ref Translation translation)
{
UnityEngine.Bounds boundstest = new UnityEngine.Bounds(new float3(0), new float3(20));
if (!boundstest.Contains(translation.Value))
{
target.Value += ((float3)boundstest.ClosestPoint(translation.Value) - translation.Value) * 10;
}
}
//Checks for containment first, then for intersection
public static bool existsBetweenOrInside(Bounds box, Triangle3 triangle)
{
foreach (Vector3 p in triangle.ABC)
{
if(box.Contains(p))
return true;
}
return existsBetween(box, triangle);
}
// BoundsWithinPoints //
// Cchecks if passed bounds contains either point (return false) //
// Then Fires rays between both points to check if the bounds are contained within both rays (return true) //
public static bool BoundsWithinPoints( Vector3 point_a, Vector3 point_b, Bounds bounds )
{
// If the start or end point are within the object, do nothing
if( bounds.Contains( point_a ) || bounds.Contains( point_b ) )
{
return false;
}
// If the object is fully on both rays
Ray ray_forward = new Ray( point_a, point_b - point_a );
Ray ray_backward = new Ray( point_b, point_a - point_b );
if( bounds.IntersectRay( ray_forward ) && bounds.IntersectRay( ray_backward ))
{
return true;
}
else
{
return false;
}
}
public static bool AreaContainsClick(Bounds area , Vector2 mousePosition)
{
if (Input.GetMouseButton(0))
{
if (area.Contains(mousePosition))
{
return true;
}
}
return false;
}
protected override void Update()
{
base.Update();
if (EditorDebugMode) {
if (!ShootAlways) {
DebugExtension.DebugBounds(_realDetectionBlock, Color.red);
}
DebugExtension.DebugBounds(_realShootRangeBlock, Color.green);
}
_realDetectionBlock = DetectionBlock;
_realDetectionBlock.center = DetectionBlock.center + this.transform.position;
_realShootRangeBlock = ShootRangeBlock;
_realShootRangeBlock.center = ShootRangeBlock.center + this.transform.position;
if (!IsDead && (ShootAlways || _realDetectionBlock.Contains(PlayerController.transform.position)) ) {
_attackDelayCounter += Time.deltaTime;
if (_attackDelayCounter >= AttackDelay) {
_attackDelayCounter = 0;
ChangePlayerState(PlayerState.Attacking);
if (ShootAtTarget) {
_BulletToSpawn = Instantiate(BulletToSpawn, this.transform.position + _upSpawnPosition, this.transform.rotation) as GameObject;
_BulletToSpawn.GetComponent<BulletController>().TargetPosition = PlayerController.transform.position;
_BulletToSpawn.GetComponent<BulletController>().SetVelocity();
} else {
if (!ChooseShootDirections || ShootLeft) {
_BulletToSpawn = Instantiate(BulletToSpawn, this.transform.position + _leftSpawnPosition, this.transform.rotation) as GameObject;
_BulletToSpawn.GetComponent<BulletController>().TargetPosition = new Vector2(_realShootRangeBlock.min.x, _BulletToSpawn.transform.position.y);
_BulletToSpawn.GetComponent<BulletController>().SetVelocity();
}
if (!ChooseShootDirections || ShootUp) {
_BulletToSpawn = Instantiate(BulletToSpawn, this.transform.position + _upSpawnPosition, this.transform.rotation) as GameObject;
_BulletToSpawn.GetComponent<BulletController>().TargetPosition = new Vector2(_BulletToSpawn.transform.position.x, _realShootRangeBlock.max.y);
_BulletToSpawn.GetComponent<BulletController>().SetVelocity();
}
if (!ChooseShootDirections || ShootRight) {
_BulletToSpawn = Instantiate(BulletToSpawn, this.transform.position + _rightSpawnPosition, this.transform.rotation) as GameObject;
_BulletToSpawn.GetComponent<BulletController>().TargetPosition = new Vector2(_realShootRangeBlock.max.x, _BulletToSpawn.transform.position.y);
_BulletToSpawn.GetComponent<BulletController>().SetVelocity();
}
}
}
}
}
static public int Contains(IntPtr l)
{
try{
UnityEngine.Bounds self = (UnityEngine.Bounds)checkSelf(l);
UnityEngine.Vector3 a1;
checkType(l, 2, out a1);
System.Boolean ret = self.Contains(a1);
pushValue(l, ret);
return(1);
}
catch (Exception e) {
LuaDLL.luaL_error(l, e.ToString());
return(0);
}
}
public override Vector3 GetPosition(MBParticle PT)
{
int runs = 0;
Bounds r = new Bounds(Vector3.zero,Scale);
Vector3 hrs=Scale;
hrs.Scale(Hollow);
Bounds hr = new Bounds(Vector3.zero, hrs);
Vector3 v = Vector3.zero;
while (runs++ < 100) {
v.x = Random.Range(r.min.x, r.max.x);
v.y = Random.Range(r.min.y, r.max.y);
v.z = Random.Range(r.min.z, r.max.z);
if (!hr.Contains(v))
return v;
}
return new Vector3(r.min.x, r.min.y, r.min.z);
}
public void ApplyForce(Transform transObj, float maxForce = 1, float radius = 0)
{
//radius = 0;
//Debug.Log("Cube hit!");
var b = new Bounds(FinalPosition, transform.localScale);
b.Expand(radius * 2);
// Why does radius need to be multiplied by 2?
//var falloffBounds =new Bounds( new Bounds(FinalPosition, transform.localScale + (Vector3.one * Falloff) + (Vector3.one * radius * 2));
var falloffBounds = new Bounds(FinalPosition, transform.localScale);
falloffBounds.Expand(radius * 2 + Falloff * 2);
if (falloffBounds.Contains(transObj.position))
{
//Debug.Log("Object in falloff");
// inside the obstacle!
if (b.Contains(transObj.position))
{
//Debug.Log("Object has enter bounds!");
transObj.position = GetClosestBorderFromInsidePoint(b, transObj.position, 0.01f);
}
// in the fallout area
else
{
var falloutClosePoint = falloffBounds.ClosestPoint(transObj.position);
Helpers.DrawDebugPoint(falloutClosePoint, 1, Color.cyan);
var objClosePoint = b.ClosestPoint(transObj.position);
Helpers.DrawDebugPoint(objClosePoint, 1, Color.magenta);
Debug.DrawLine(falloutClosePoint, objClosePoint, Color.yellow);
var mag = (falloutClosePoint - objClosePoint).magnitude;
var frac = Mathf.Max(1 - mag / Falloff, 0);
//Debug.Log("mag = " + mag + " (" + frac + ")");
var forceVector = (falloutClosePoint - objClosePoint).normalized * frac * maxForce;
transObj.position += forceVector * Time.deltaTime;
}
}
}
void FixedUpdate(){
Vector3 delta = _player.transform.position - transform.position;
if(delta.x > targetDistance.x || delta.x < -targetDistance.x){
if(movementEnabled){
delta.Normalize();
_unit.Move(delta.x);
}
}
if(!movementEnabled){
Bounds bounds = new Bounds(transform.position, wakeDistance);
if(bounds.Contains(_player.transform.position)){
movementEnabled = true;
}
}
}
void Update()
{
if (Vector3.Distance(transform.position, currentTarget) <= 0.1)
{
Vector3 newTarget = getNewPosition();
while (!bounds.Contains(newTarget))
{
newTarget = getNewPosition();
}
currentTarget = newTarget;
}
Vector3 newPosition = Vector3.MoveTowards(transform.position, currentTarget, speed * Time.deltaTime);
Quaternion newRotation = Quaternion.LookRotation(currentTarget.normalized) * transform.rotation;
transform.position = newPosition;
transform.rotation = Quaternion.FromToRotation(transform.up, currentTarget) * transform.rotation;
}
public static Vector2 ClosestPoint(Bounds bounds, Vector2 point) {
if (bounds.Contains(point)) {
return point;
} else {
float x = point.x;
float y = point.y;
if (x < bounds.min.x) {
x = bounds.min.x;
} else if (x > bounds.max.x) {
x = bounds.max.x;
}
if (y < bounds.min.y) {
y = bounds.min.y;
} else if (y > bounds.max.y) {
y = bounds.max.y;
}
return new Vector2(x, y);
}
}
public void updateScope(Bounds pBounds)
{
//Scope Transform中的子物体
foreach (Transform lNetworkPlayerRoot in networkPlayerRoots)
{
setScope(pBounds, lNetworkPlayerRoot, networkPlayer);
}
//Scope 自定义物体
var lNetworkViewNode = networkViewList.First;
while (lNetworkViewNode != null)
{
var lNetworkView = lNetworkViewNode.Value;
var lNextNode = lNetworkViewNode.Next;
if (lNetworkView)
{
lNetworkView.SetScope(networkPlayer,
pBounds.Contains(lNetworkView.transform.position));
}
else
networkViewList.Remove(lNetworkViewNode);
lNetworkViewNode = lNextNode;
}
}
public bool OnSceneGUI(Matrix4x4 transform, Color boxColor, Color midPointHandleColor, bool handlesOnly, ref Vector3 center, ref Vector3 size)
{
bool flag = GUIUtility.hotControl == this.m_HandleControlID;
if (!this.m_AlwaysDisplayHandles && !flag)
{
for (int i = 0; i < 6; i++)
{
GUIUtility.GetControlID(this.m_ControlIdHint, FocusType.Keyboard);
}
return false;
}
Color color = Handles.color;
Handles.color = boxColor;
Vector3 b = center - size * 0.5f;
Vector3 a = center + size * 0.5f;
Matrix4x4 matrix = Handles.matrix;
Handles.matrix = transform;
int hotControl = GUIUtility.hotControl;
if (!handlesOnly)
{
this.DrawWireframeBox(center, size);
}
Vector3 point = transform.inverse.MultiplyPoint(Camera.current.transform.position);
Bounds bounds = new Bounds(center, size);
bool isCameraInsideBox = bounds.Contains(point);
Handles.color = midPointHandleColor;
this.MidpointHandles(ref b, ref a, Handles.matrix, isCameraInsideBox);
if (hotControl != GUIUtility.hotControl && GUIUtility.hotControl != 0)
{
this.m_HandleControlID = GUIUtility.hotControl;
}
bool changed = GUI.changed;
if (changed)
{
center = (a + b) * 0.5f;
size = a - b;
}
Handles.color = color;
Handles.matrix = matrix;
return changed;
}
public bool Hit(Transform target, Bounds bounds) {
return (bounds.Contains(target.position));
}
// Checks to see whether Bounds lilB are within Bounds bigB
public static Vector3 BoundsInBoundsCheck( Bounds bigB, Bounds lilB,
BoundsTest test = BoundsTest.onScreen )
{
// The behavior of this function is different based on the BoundsTest
// that has been selected.
// Get the center of lilB
Vector3 pos = lilB.center;
// Initialize the offset at [0,0,0]
Vector3 off = Vector3.zero;
switch (test) {
// The center test determines what off (offset) would have to be applied
// to lilB to move its center back inside bigB
case BoundsTest.center:
if ( bigB.Contains( pos ) ) {
return( Vector3.zero );
}
if (pos.x > bigB.max.x) {
off.x = pos.x - bigB.max.x;
} else if (pos.x < bigB.min.x) {
off.x = pos.x - bigB.min.x;
}
if (pos.y > bigB.max.y) {
off.y = pos.y - bigB.max.y;
} else if (pos.y < bigB.min.y) {
off.y = pos.y - bigB.min.y;
}
if (pos.z > bigB.max.z) {
off.z = pos.z - bigB.max.z;
} else if (pos.z < bigB.min.z) {
off.z = pos.z - bigB.min.z;
}
return( off );
// The onScreen test determines what off would have to be applied to
// keep all of lilB inside bigB
case BoundsTest.onScreen:
if ( bigB.Contains( lilB.min ) && bigB.Contains( lilB.max ) ) {
return( Vector3.zero );
}
if (lilB.max.x > bigB.max.x) {
off.x = lilB.max.x - bigB.max.x;
} else if (lilB.min.x < bigB.min.x) {
off.x = lilB.min.x - bigB.min.x;
}
if (lilB.max.y > bigB.max.y) {
off.y = lilB.max.y - bigB.max.y;
} else if (lilB.min.y < bigB.min.y) {
off.y = lilB.min.y - bigB.min.y;
}
if (lilB.max.z > bigB.max.z) {
off.z = lilB.max.z - bigB.max.z;
} else if (lilB.min.z < bigB.min.z) {
off.z = lilB.min.z - bigB.min.z;
}
return( off );
// The offScreen test determines what off would need to be applied to
// move any tiny part of lilB inside of bigB
case BoundsTest.offScreen:
bool cMin = bigB.Contains( lilB.min );
bool cMax = bigB.Contains( lilB.max );
if ( cMin || cMax ) {
return( Vector3.zero );
}
if (lilB.min.x > bigB.max.x) {
off.x = lilB.min.x - bigB.max.x;
} else if (lilB.max.x < bigB.min.x) {
off.x = lilB.max.x - bigB.min.x;
}
if (lilB.min.y > bigB.max.y) {
off.y = lilB.min.y - bigB.max.y;
} else if (lilB.max.y < bigB.min.y) {
off.y = lilB.max.y - bigB.min.y;
}
if (lilB.min.z > bigB.max.z) {
off.z = lilB.min.z - bigB.max.z;
} else if (lilB.max.z < bigB.min.z) {
off.z = lilB.max.z - bigB.min.z;
}
return( off );
}
return( Vector3.zero );
}
/// <summary>
/// Calculates the influence velocities for the drone. We do this in one big loop for efficiency.
/// </summary>
protected virtual void CalculateVelocities()
{
// the general procedure is that we add up velocities based on the neighbors in our radius for a particular influence (cohesion, separation, etc.)
// and divide the sum by the total number of drones in our neighbor radius
// this produces an evened-out velocity that is aligned with its neighbors to apply to the target drone
Vector3 separationSum = Vector3.zero;
Vector3 alignmentSum = Vector3.zero;
Vector3 cohesionSum = Vector3.zero;
Vector3 boundsSum = Vector3.zero;
int separationCount = 0;
int alignmentCount = 0;
int cohesionCount = 0;
int boundsCount = 0;
for (int i = 0; i < this.drones.Count; i++)
{
if (drones[i] == null) continue;
float distance = Vector3.Distance(transform.position, drones[i].transform.position);
// separation
// calculate separation influence velocity for this drone, based on its preference to keep distance between itself and neighboring drones
if (distance > 0 && distance < desiredSeparation)
{
// calculate vector headed away from myself
Vector3 direction = transform.position - drones[i].transform.position;
direction.Normalize();
direction = direction / distance; // weight by distance
separationSum += direction;
separationCount++;
}
// alignment & cohesion
// calculate alignment influence vector for this drone, based on its preference to be aligned with neighboring drones
// calculate cohesion influence vector for this drone, based on its preference to be close to neighboring drones
if (distance > 0 && distance < neighborRadius)
{
alignmentSum += drones[i].rigidbody.velocity;
alignmentCount++;
cohesionSum += drones[i].transform.position;
cohesionCount++;
}
// bounds
// calculate the bounds influence vector for this drone, based on whether or not neighboring drones are in bounds
Bounds bounds = new Bounds(swarm.transform.position, new Vector3(swarm.swarmBounds.x, 10000f, swarm.swarmBounds.y));
if (distance > 0 && distance < neighborRadius && !bounds.Contains(drones[i].transform.position))
{
Vector3 diff = transform.position - swarm.transform.position;
if (diff.magnitude> 0)
{
boundsSum += swarm.transform.position;
boundsCount++;
}
}
}
// end
_separation = separationCount > 0 ? separationSum / separationCount : separationSum;
_alignment = alignmentCount > 0 ? Limit(alignmentSum / alignmentCount, maxSteer) : alignmentSum;
_cohesion = cohesionCount > 0 ? Steer(cohesionSum / cohesionCount, false) : cohesionSum;
_bounds = boundsCount > 0 ? Steer(boundsSum / boundsCount, false) : boundsSum;
}
/** All nodes inside the shape or if null, the bounding box.
* If a shape is supplied, it is assumed to be contained inside the bounding box.
* \see GraphUpdateShape.GetBounds
*/
private List<GraphNode> GetNodesInArea (Bounds b, GraphUpdateShape shape) {
if (nodes == null || width*depth != nodes.Length) {
return null;
}
// Get a buffer we can use
List<GraphNode> inArea = Pathfinding.Util.ListPool<GraphNode>.Claim();
// Take the bounds and transform it using the matrix
// Then convert that to a rectangle which contains
// all nodes that might be inside the bounds
Vector3 min, max;
GetBoundsMinMax(b, inverseMatrix, out min, out max);
int minX = Mathf.RoundToInt(min.x-0.5F);
int maxX = Mathf.RoundToInt(max.x-0.5F);
int minZ = Mathf.RoundToInt(min.z-0.5F);
int maxZ = Mathf.RoundToInt(max.z-0.5F);
var originalRect = new IntRect(minX, minZ, maxX, maxZ);
// Rect which covers the whole grid
var gridRect = new IntRect(0, 0, width-1, depth-1);
// Clamp the rect to the grid
var rect = IntRect.Intersection(originalRect, gridRect);
// Loop through all nodes in the rectangle
for (int x = rect.xmin; x <= rect.xmax; x++) {
for (int z = rect.ymin; z <= rect.ymax; z++) {
int index = z*width+x;
GraphNode node = nodes[index];
// If it is contained in the bounds (and optionally the shape)
// then add it to the buffer
if (b.Contains((Vector3)node.position) && (shape == null || shape.Contains((Vector3)node.position))) {
inArea.Add(node);
}
}
}
return inArea;
}
// Checks to see whether a smaller object is inside a bigger object.
public static Vector3 BoundsInBoundsCheck( Bounds bigB, Bounds lilB, BoundsTest test =
BoundsTest.onScreen )
{
Vector3 pos = lilB.center;
Vector3 off = Vector3.zero;
switch (test) {
case BoundsTest.center: // What offset to move lilB into bigB
if ( bigB.Contains( pos ) ) {
return( Vector3.zero );
}
if (pos.x > bigB.max.x) {
off.x = pos.x - bigB.max.x;
} else if (pos.x < bigB.min.x) {
off.x = pos.x - bigB.min.x;
}
if (pos.y > bigB.max.y) {
off.y = pos.y - bigB.max.y;
} else if (pos.y < bigB.min.y) {
off.y = pos.y - bigB.min.y;
}
if (pos.z > bigB.max.z) {
off.z = pos.z - bigB.max.z;
} else if (pos.z < bigB.min.z) {
off.z = pos.z - bigB.min.z;
}
return( off );
case BoundsTest.onScreen: //What offset keep all of lilB inside bigB
if ( bigB.Contains( lilB.min ) && bigB.Contains( lilB.max ) ) {
return( Vector3.zero );
}
if (lilB.max.x > bigB.max.x) {
off.x = lilB.max.x - bigB.max.x;
} else if (lilB.min.x < bigB.min.x) {
off.x = lilB.min.x - bigB.min.x;
}
if (lilB.max.y > bigB.max.y) {
off.y = lilB.max.y - bigB.max.y;
} else if (lilB.min.y < bigB.min.y) {
off.y = lilB.min.y - bigB.min.y;
}
if (lilB.max.z > bigB.max.z) {
off.z = lilB.max.z - bigB.max.z;
} else if (lilB.min.z < bigB.min.z) {
off.z = lilB.min.z - bigB.min.z;
}
return( off );
case BoundsTest.offScreen: //What offset move any tiny part of lilB inside of bigB
bool cMin = bigB.Contains( lilB.min );
bool cMax = bigB.Contains( lilB.max );
if ( cMin || cMax ) {
return( Vector3.zero );
}
if (lilB.min.x > bigB.max.x) {
off.x = lilB.min.x - bigB.max.x;
} else if (lilB.max.x < bigB.min.x) {
off.x = lilB.max.x - bigB.min.x;
}
if (lilB.min.y > bigB.max.y) {
off.y = lilB.min.y - bigB.max.y;
} else if (lilB.max.y < bigB.min.y) {
off.y = lilB.max.y - bigB.min.y;
}
if (lilB.min.z > bigB.max.z) {
off.z = lilB.min.z - bigB.max.z;
} else if (lilB.max.z < bigB.min.z) {
off.z = lilB.max.z - bigB.min.z;
}
return( off );
}
return( Vector3.zero );
}
// Checks to see if bounds lilb are within Bounds bigB
public static Vector3 BoundsInBoundsCheck(Bounds bigB, Bounds lilB, BoundsTest test = BoundsTest.onScreen)
{
// behavior needs to be different depending on the test selected
Vector3 pos = lilB.center; // use center for measurement
Vector3 off = Vector3.zero; // offset is 0,0,0 to start
switch (test) {
// what is offset to move center of lilB back inside bigB
case BoundsTest.center:
// trivial case - we are already inside
if (bigB.Contains(pos)) {
return (Vector3.zero); //no need to move
}
//otherwise adjust x,y,z components as needed
if(pos.x > bigB.max.x) {
off.x = pos.x - bigB.max.x;
} else if (pos.x < bigB.min.x) {
off.x = pos.x - bigB.min.x;
}
if(pos.y > bigB.max.y) {
off.y = pos.y - bigB.max.y;
} else if (pos.y < bigB.min.y) {
off.y = pos.y - bigB.min.y;
}
if(pos.z > bigB.max.z) {
off.z = pos.z - bigB.max.z;
} else if (pos.z < bigB.min.z) {
off.z = pos.z - bigB.min.z;
}
return (off);
//-------------------------
// what is the offset to keep ALL of lilB inside bigB
case BoundsTest.onScreen:
// trivial case - we are already inside
if (bigB.Contains(lilB.max) && bigB.Contains(lilB.min)) {
return (Vector3.zero); //no need to move
}
if(lilB.max.x > bigB.max.x) {
off.x = lilB.max.x - bigB.max.x;
} else if (lilB.min.x < bigB.min.x) {
off.x = lilB.min.x - bigB.min.x;
}
if(lilB.max.y > bigB.max.y) {
off.y = lilB.max.y - bigB.max.y;
} else if (lilB.min.y < bigB.min.y) {
off.y = lilB.min.y - bigB.min.y;
}
if(lilB.max.z > bigB.max.z) {
off.z = lilB.max.z - bigB.max.z;
} else if (lilB.min.z < bigB.min.z) {
off.z = lilB.min.z - bigB.min.z;
}
return (off);
//-------------------------
// what is the offset to keep ALL of lilB outside of bigB
case BoundsTest.offScreen:
bool cMin = bigB.Contains(lilB.min);
bool cMax = bigB.Contains(lilB.max);
if (cMin || cMax) {
return (Vector3.zero);
}
if(lilB.min.x > bigB.max.x) {
off.x = lilB.min.x - bigB.max.x;
} else if (lilB.max.x < bigB.min.x) {
off.x = lilB.max.x - bigB.min.x;
}
if(lilB.min.y > bigB.max.y) {
off.y = lilB.min.y - bigB.max.y;
} else if (lilB.max.y < bigB.min.y) {
off.y = lilB.max.y - bigB.min.y;
}
if(lilB.min.z > bigB.max.z) {
off.z = lilB.min.z - bigB.max.z;
} else if (lilB.max.z < bigB.min.z) {
off.z = lilB.max.z - bigB.min.z;
}
return (off);
} // end switch BoundsTest
return (Vector3.zero); // if we get here something went wrong
}
// methods
static bool Bounds_Contains__Vector3(JSVCall vc, int argc)
{
int len = argc;
if (len == 1)
{
UnityEngine.Vector3 arg0 = (UnityEngine.Vector3)JSApi.getVector3S((int)JSApi.GetType.Arg);
UnityEngine.Bounds argThis = (UnityEngine.Bounds)vc.csObj; JSApi.setBooleanS((int)JSApi.SetType.Rval, (System.Boolean)(argThis.Contains(arg0)));
JSMgr.changeJSObj(vc.jsObjID, argThis);
}
return(true);
}
// Tests to see whether lilB is inside bigB
public static Vector3 BoundsInBoundsCheck( Bounds bigB, Bounds lilB, BoundsTest test = BoundsTest.onScreen )
{
// Get the center of lilB
Vector3 pos = lilB.center;
// Initialize the offset at [0,0,0]
Vector3 off = Vector3.zero;
switch (test) {
// The center test determines what off (offset) would have to be applied to lilB to move its center back inside bigB
case BoundsTest.center:
// if the center is contained, return Vector3.zero
if ( bigB.Contains( pos ) ) {
return( Vector3.zero );
}
// if not contained, find the offset
if (pos.x > bigB.max.x) {
off.x = pos.x - bigB.max.x;
} else if (pos.x < bigB.min.x) {
off.x = pos.x - bigB.min.x;
}
if (pos.y > bigB.max.y) {
off.y = pos.y - bigB.max.y;
} else if (pos.y < bigB.min.y) {
off.y = pos.y - bigB.min.y;
}
if (pos.z > bigB.max.z) {
off.z = pos.z - bigB.max.z;
} else if (pos.z < bigB.min.z) {
off.z = pos.z - bigB.min.z;
}
return( off );
// The onScreen test determines what off would have to be applied to keep all of lilB inside bigB
case BoundsTest.onScreen:
// find whether bigB contains all of lilB
if ( bigB.Contains( lilB.min ) && bigB.Contains( lilB.max ) ) {
return( Vector3.zero );
}
// if not, find the offset
if (lilB.max.x > bigB.max.x) {
off.x = lilB.max.x - bigB.max.x;
} else if (lilB.min.x < bigB.min.x) {
off.x = lilB.min.x - bigB.min.x;
}
if (lilB.max.y > bigB.max.y) {
off.y = lilB.max.y - bigB.max.y;
} else if (lilB.min.y < bigB.min.y) {
off.y = lilB.min.y - bigB.min.y;
}
if (lilB.max.z > bigB.max.z) {
off.z = lilB.max.z - bigB.max.z;
} else if (lilB.min.z < bigB.min.z) {
off.z = lilB.min.z - bigB.min.z;
}
return( off );
// The offScreen test determines what off would need to be applied to move any tiny part of lilB inside of bigB
case BoundsTest.offScreen:
// find whether bigB contains any of lilB
bool cMin = bigB.Contains( lilB.min );
bool cMax = bigB.Contains( lilB.max );
if ( cMin || cMax ) {
return( Vector3.zero );
}
// if not, find the offset
if (lilB.min.x > bigB.max.x) {
off.x = lilB.min.x - bigB.max.x;
} else if (lilB.max.x < bigB.min.x) {
off.x = lilB.max.x - bigB.min.x;
}
if (lilB.min.y > bigB.max.y) {
off.y = lilB.min.y - bigB.max.y;
} else if (lilB.max.y < bigB.min.y) {
off.y = lilB.max.y - bigB.min.y;
}
if (lilB.min.z > bigB.max.z) {
off.z = lilB.min.z - bigB.max.z;
} else if (lilB.max.z < bigB.min.z) {
off.z = lilB.max.z - bigB.min.z;
}
return( off );
}
return( Vector3.zero );
}
public static float MinDistanceToAABB(Vector3 vec, Vector3 pMin, Vector3 pMax)
{
var b = new Bounds();
b.SetMinMax(pMin, pMax);
// inside?
if (b.Contains(vec)) return 0f;
else return Mathf.Sqrt(b.SqrDistance(vec));
}
public bool Raycast(UnityEngine.Ray ray)
{
var bounds = new UnityEngine.Bounds();
bounds.SetMinMax(new UnityEngine.Vector3(0, 0, 0), new UnityEngine.Vector3(_sizeX * 16, _sizeY * 16, _sizeZ * 16));
// if we're outside world bounds, first intersect the world's bounding box
if (!bounds.Contains(ray.origin))
{
float dist;
if (!bounds.IntersectRay(ray, out dist))
{
return(false);
}
ray.origin += ray.direction * dist;
}
// inside or at world edge, time to voxel trace
// From "A Fast Voxel Traversal Algorithm for Ray Tracing"
// by John Amanatides and Andrew Woo, 1987
// <http://www.cse.yorku.ca/~amana/research/grid.pdf>
// <http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.3443>
// initialize to initial voxel coordinate
// TODO verify that this works reliable even if we started outside the world bounds
int x = Mathf.FloorToInt(ray.origin.x);
int y = Mathf.FloorToInt(ray.origin.y);
int z = Mathf.FloorToInt(ray.origin.z);
// TODO determine initial distances to voxel edges
float tMaxX = intbound(ray.origin.x, ray.direction.x);
float tMaxY = intbound(ray.origin.y, ray.direction.y);
float tMaxZ = intbound(ray.origin.z, ray.direction.z);
// determine stepping direction
int stepX = (int)Mathf.Sign(ray.direction.x);
int stepY = (int)Mathf.Sign(ray.direction.y);
int stepZ = (int)Mathf.Sign(ray.direction.z);
// determine distance (in ray units) between voxel edges
float tDeltaX = stepX / ray.direction.x;
float tDeltaY = stepY / ray.direction.y;
float tDeltaZ = stepZ / ray.direction.z;
int wx = _sizeX * 16;
int wy = _sizeY * 16;
int wz = _sizeZ * 16;
while (
(stepX > 0 ? x < wx : x >= 0) &&
(stepY > 0 ? y < wy : y >= 0) &&
(stepZ > 0 ? z < wz : z >= 0))
{
// lalala
// TODO WE NOW HAVE A VOXEL AT X,Y,Z
// walk...
if (tMaxX < tMaxY)
{
if (tMaxX < tMaxZ)
{
x += stepX;
tMaxX += tDeltaX;
}
else
{
z += stepZ;
tMaxZ += tDeltaZ;
}
}
else
{
if (tMaxY < tMaxZ)
{
y += stepY;
tMaxY += tDeltaY;
}
else
{
z += stepZ;
tMaxZ += tDeltaZ;
}
}
}
return(false);
}
void CheckSessionStart(Vector3 point, ZigJointId joint)
{
if (InSession) { Debug.Log("CheckSessionStart when already in session, leaving"); return; }
Vector3 boundsCenter = (RotateToUser) ? RotateHandPoint(trackedUser.Position) : trackedUser.Position;
boundsCenter += SessionBoundsOffset;
currentSessionBounds = new Bounds(boundsCenter, SessionBounds);
Vector3 fp = (RotateToUser) ? RotateHandPoint(point) : point;
if (currentSessionBounds.Contains(fp)) {
focusPoint = fp;
jointInSession = joint;
InSession = true;
OnSessionStart(fp);
}
}
public void MoveToSpaceCell(int d)
{
AAgent a = AttachedAgent;
List<AAgent> list = a.World.AllAgents.Where(x => IsInRange(a, x, d)).ToList();
LimitedWorld lw = a.World.GetComponent<LimitedWorld>();
Bounds b = new Bounds();
if(lw)
b = lw.Bound;
List<Vector3> candidates = new List<Vector3>();
for(int x=-d;x<=d;x++){
for(int y=-d;y<=d;y++){
for(int z=-d;z<=d;z++){
Vector3 v = ToGrid(new Vector3(x, y, z)+transform.position);
if(lw){
if(b.Contains(v)){
candidates.Add(v);
}
}else{
candidates.Add(v);
}
}
}
}
foreach(AAgent agent in list){
Vector3 p = ToGrid(agent.transform.position);
candidates.Remove(p);
}
candidates.Remove(transform.position);
candidates = candidates.OrderBy(x => Vector3.Distance(transform.position, x)).ToList();
if(candidates.Count > 0)
Position = candidates[0];
}
/** All nodes inside the shape or if null, the bounding box.
* If a shape is supplied, it is assumed to be contained inside the bounding box.
* \see GraphUpdateShape.GetBounds
*/
private List<GraphNode> GetNodesInArea (Bounds b, GraphUpdateShape shape) {
if (nodes == null || width*depth != nodes.Length) {
return null;
}
List<GraphNode> inArea = Pathfinding.Util.ListPool<GraphNode>.Claim ();
Vector3 min, max;
GetBoundsMinMax (b,inverseMatrix,out min, out max);
int minX = Mathf.RoundToInt (min.x-0.5F);
int maxX = Mathf.RoundToInt (max.x-0.5F);
int minZ = Mathf.RoundToInt (min.z-0.5F);
int maxZ = Mathf.RoundToInt (max.z-0.5F);
IntRect originalRect = new IntRect(minX,minZ,maxX,maxZ);
IntRect gridRect = new IntRect(0,0,width-1,depth-1);
IntRect rect = IntRect.Intersection (originalRect, gridRect);
for (int x = rect.xmin; x <= rect.xmax;x++) {
for (int z = rect.ymin;z <= rect.ymax;z++) {
int index = z*width+x;
GraphNode node = nodes[index];
if (b.Contains ((Vector3)node.position) && (shape == null || shape.Contains ((Vector3)node.position))) {
inArea.Add (node);
}
}
}
return inArea;
}
void enableShielding()
{
// print("enableShielding()");
disableShielding();
var attached=getFairingParams();
if (!sideFairing) return;
// get all parts in range
var parts=new List<Part>();
var colliders=Physics.OverlapSphere(part.transform.TransformPoint(lookupCenter), lookupRad, 1);
for (int i=colliders.Length-1; i>=0; --i)
{
var p=colliders[i].gameObject.GetComponentUpwards<Part>();
if (p!=null) parts.AddUnique(p);
}
// print("got "+parts.Count+" nearby parts");
// filter parts
float sizeSqr=lookupRad*lookupRad*4;
float boundCylRadSq=boundCylRad*boundCylRad;
bool isInline = (sideFairing.inlineHeight>0);
bool topClosed=false;
Matrix4x4 w2l=Matrix4x4.identity, w2lb=Matrix4x4.identity;
Bounds topBounds=default(Bounds);
if (isInline)
{
w2l=part.transform.worldToLocalMatrix;
w2lb=w2l;
for (int i=0; i<3; ++i)
for (int j=0; j<3; ++j)
w2lb[i, j]=Mathf.Abs(w2lb[i, j]);
topBounds=new Bounds(new Vector3(0, boundCylY1, 0), Vector3.one*(sideFairing.topRad*2));
}
for (int pi=0; pi<parts.Count; ++pi)
{
var pt=parts[pi];
// check special cases
if (pt==part) { shieldedParts.Add(pt); continue; }
bool isSide=false;
for (int i=0; i<attached.Length; ++i) if (attached[i].attachedPart==pt) { isSide=true; break; }
if (isSide) continue;
// print("checking part "+pt.partName+" "+pt.partInfo.title);
// check if the top is closed in the inline case
var bounds=pt.GetRendererBounds();
var box=PartGeometryUtil.MergeBounds(bounds, pt.partTransform);
if (isInline && !topClosed && pt.vessel==vessel)
{
var wb=box; wb.Expand(sideFairing.sideThickness*4);
var b=new Bounds(w2l.MultiplyPoint3x4(wb.center), w2lb.MultiplyVector(wb.size));
if (b.Contains(topBounds.min) && b.Contains(topBounds.max)) topClosed=true;
}
// check if too big to fit
// if (box.size.sqrMagnitude>sizeSqr) continue;
// check if the centroid is within fairing bounds
var c=part.transform.InverseTransformPoint(PartGeometryUtil.FindBoundsCentroid(bounds, null));
float y=c.y;
if (y<boundCylY0 || y>boundCylY1) continue;
float xsq=new Vector2(c.x, c.z).sqrMagnitude;
if (xsq>boundCylRadSq) continue;
// accurate centroid check
float x=Mathf.Sqrt(xsq);
bool inside=false;
for (int i=1; i<shape.Length; ++i)
{
var p0=shape[i-1];
var p1=shape[i];
if (p0.y>p1.y) { var p=p0; p0=p1; p1=p; }
if (y<p0.y || y>p1.y) continue;
float dy=p1.y-p0.y, r;
if (dy<=1e-6f) r=(p0.x+p1.x)*0.5f;
else r=(p1.x-p0.x)*(y-p0.y)/dy+p0.x;
if (x>r) continue;
inside=true;
break;
}
if (!inside) continue;
shieldedParts.Add(pt);
// print("shielded "+pt.partName);
}
if (isInline && !topClosed) { disableShielding(); return; }
// add shielding
for (int i=0; i<shieldedParts.Count; ++i)
shieldedParts[i].AddShield(this);
numShieldedDisplay=shieldedParts.Count;
var fbase=part.GetComponent<ProceduralFairingBase>();
if (fbase!=null) fbase.onShieldingEnabled(shieldedParts);
}
/// <summary>
/// Updates the graph during runtime adding or removing the waypoints associated with this starbase.
/// The method determines add/remove based on whether the starbase has previously been recorded.
/// </summary>
/// <param name="baseCmd">The Starbase command.</param>
public void UpdateGraph(StarbaseCmdItem baseCmd) {
List<GraphUpdateObject> guos = null;
if (_starbaseGuos.TryGetValue(baseCmd, out guos)) {
// this base is being removed
guos.ForAll(guo => guo.RevertFromBackup()); // reverses the node changes made when base was added
_starbaseGuos.Remove(baseCmd);
}
else {
// base is being added
guos = new List<GraphUpdateObject>(2);
// First, make surrounding waypoints walkable (includes base/sector position which is already walkable)
var baseSector = SectorGrid.Instance.GetSector(baseCmd.SectorIndex);
D.Assert(Mathfx.Approx(baseSector.Position, baseCmd.Position, .01F)); // base should be in center of sector
float baseSectorCenterApproachWaypointDistanceWithBuffer = (baseSector.Radius * SectorItem.CenterApproachWaypointDistanceMultiplier) + 1F;
Vector3 sectorCenterApproachWaypointAreaSize = Vector3.one * baseSectorCenterApproachWaypointDistanceWithBuffer;
var sectorCenterApproachWaypointWalkableGuo = new GraphUpdateObject(new Bounds(baseCmd.Position, sectorCenterApproachWaypointAreaSize)) {
modifyWalkability = true,
setWalkability = true,
updatePhysics = true, // default
trackChangedNodes = true, // allows RevertFromBackup
requiresFloodFill = true // default // OPTIMIZE
};
active.UpdateGraphs(sectorCenterApproachWaypointWalkableGuo);
guos.Add(sectorCenterApproachWaypointWalkableGuo);
// Now, create GUO that makes the base/sector position node unwalkable
float baseRadius = baseCmd.Data.CloseOrbitOuterRadius;
Vector3 baseUnwalkableAreaSize = Vector3.one * baseRadius;
Bounds baseUnwalkableBounds = new Bounds(baseCmd.Position, baseUnwalkableAreaSize);
D.Log("{0} Unwalkable Bounds {1} contains {2} = {3}.", baseCmd.FullName, baseUnwalkableBounds, baseCmd.Position, baseUnwalkableBounds.Contains(baseCmd.Position));
GraphUpdateObject baseUnwalkableGuo = new GraphUpdateObject(baseUnwalkableBounds) {
modifyWalkability = true,
setWalkability = false, // default
updatePhysics = true, // default
trackChangedNodes = true, // allows RevertFromBackup
requiresFloodFill = true // default // OPTIMIZE
};
active.UpdateGraphs(baseUnwalkableGuo);
guos.Add(baseUnwalkableGuo);
_starbaseGuos.Add(baseCmd, guos);
}
}
public static Vector3 BoundsInBoundsCheck(Bounds bigB, Bounds lilB, BoundsTest test = BoundsTest.onScreen)
{
Vector3 pos = lilB.center;
Vector3 off = Vector3.zero;
switch (test) {
case BoundsTest.center:
if (bigB.Contains (pos)) {
return Vector3.zero;
}
if (pos.x > bigB.max.x) {
off.x = pos.x - bigB.max.x;
} else if (pos.x < bigB.min.x) {
off.x = pos.x - bigB.min.x;
}
if (pos.y > bigB.max.y) {
off.y = pos.y - bigB.max.y;
} else if (pos.y < bigB.min.y) {
off.y = pos.y - bigB.min.y;
}
if (pos.z > bigB.max.z) {
off.z = pos.z - bigB.max.z;
} else if (pos.z < bigB.min.z) {
off.z = pos.z - bigB.min.z;
}
return (off);
case BoundsTest.onScreen:
if (bigB.Contains (lilB.min) && bigB.Contains (lilB.max)) {
return Vector3.zero;
}
if (lilB.max.x > bigB.max.x) {
off.x = lilB.max.x - bigB.max.x;
} else if (lilB.min.x < bigB.min.x) {
off.x = lilB.min.x - bigB.min.x;
}
if (lilB.max.y > bigB.max.y) {
off.y = lilB.max.y - bigB.max.y;
} else if (lilB.min.y < bigB.min.y) {
off.y = lilB.min.y - bigB.min.y;
}
if (lilB.max.z > bigB.max.z) {
off.z = lilB.max.z - bigB.max.z;
} else if (lilB.min.z < bigB.min.z) {
off.z = lilB.min.z - bigB.min.z;
}
return off;
case BoundsTest.offScreen:
bool cMin = bigB.Contains (lilB.min);
bool cMax = bigB.Contains (lilB.max);
if (cMax || cMin) {
return Vector3.zero;
}
if (lilB.min.x > bigB.max.x) {
off.x = lilB.min.x - bigB.max.x;
} else if (lilB.max.x < bigB.min.x) {
off.x = lilB.max.x - bigB.min.x;
}
if (lilB.min.y > bigB.max.y) {
off.y = lilB.min.y - bigB.max.y;
} else if (lilB.max.y < bigB.min.y) {
off.y = lilB.max.y - bigB.min.y;
}
if (lilB.min.z > bigB.max.z) {
off.z = lilB.min.z - bigB.max.z;
} else if (lilB.max.z < bigB.min.z) {
off.z = lilB.max.z - bigB.min.z;
}
return off;
}
return Vector3.zero;
}
