public void Vector3_EqualsTestsCorrectly()
{
var vector1 = new Vector3(123.4f, 567.8f, 901.2f);
var vector2 = new Vector3(123.4f, 567.8f, 901.2f);
var vector3 = new Vector3(901.2f, 567.8f, 123.4f);
TheResultingValue(vector1.Equals(vector2)).ShouldBe(true);
TheResultingValue(vector1.Equals(vector3)).ShouldBe(false);
}
public void NaNEquality()
{
Vector3 nanVec = new Vector3(float.NaN, float.NaN, float.NaN);
Assert.IsFalse(nanVec == nanVec);
Assert.IsTrue(nanVec != nanVec);
Assert.IsTrue(nanVec.Equals(nanVec));
}
public static IEnumerable<Targets.Item> FilterTargets(IEnumerable<Targets.Item> targets,
Vector3 from,
float range)
{
var finalTargets = targets.ToList();
var rangeDelay = _mainMenu.Item(_mainMenu.Name + ".range").GetValue<Slider>().Value;
var fowDelay = _mainMenu.Item(_mainMenu.Name + ".fow").GetValue<Slider>().Value;
if (rangeDelay > 0 && range > 0)
{
if (_lastRange > 0 && Game.Time - _lastRangeChange <= rangeDelay / 1000f)
{
finalTargets =
finalTargets.Where(
t =>
t.Hero.Distance(
from.Equals(default(Vector3)) ? ObjectManager.Player.ServerPosition : from) <=
_lastRange).ToList();
}
else if (Math.Abs(_lastRange - range) > 1)
{
_lastRange = range;
_lastRangeChange = Game.Time;
}
}
if (fowDelay > 0)
{
finalTargets =
finalTargets.Where(item => Game.Time - item.LastVisibleChange > fowDelay / 1000f).ToList();
}
return finalTargets;
}
public static bool IsFacing(this Obj_AI_Base source, Vector3 position, float angle = 90)
{
if (source == null || position.Equals(Vector3.Zero))
{
return false;
}
return source.Direction.To2D().Perpendicular().AngleBetween((position - source.Position).To2D()) < angle;
}
public void Test_Equals()
{
var a = new Vector3 (1, 2, 3.00001f);
var b = new Vector3 (1, 2, 3.00002f);
Assert.IsTrue (a.Equals (b)); // 誤差を許容する比較
Assert.IsFalse (a == b); // 厳密な比較
Assert.AreNotEqual (a.GetHashCode (), b.GetHashCode ()); // ハッシュは厳密な比較を基準
}
public void ScalarDivision()
{
Vector3 ScalarMultiplicationArgument = new Vector3(5.0f, 4.0f, 3.0f);
Assert.IsTrue(ScalarMultiplicationArgument / 2 == new Vector3(2.5f, 2.0f, 1.5f));
Assert.IsTrue(2 / ScalarMultiplicationArgument == new Vector3(2.5f, 2.0f, 1.5f));
Vector3 Point3 = new Vector3(12, 18, 24);
Point3 /= 6;
Assert.IsTrue(Point3.Equals(new Vector3(2, 3, 4), .01f));
}
public void ScalarMultiplication()
{
Vector3 ScalarMultiplicationArgument = new Vector3(5.0f, 4.0f, 3.0f);
Assert.IsTrue(ScalarMultiplicationArgument * -.5 == -new Vector3(2.5f, 2.0f, 1.5f));
Assert.IsTrue(-.5 * ScalarMultiplicationArgument == -new Vector3(2.5f, 2.0f, 1.5f));
Assert.IsTrue(5 * ScalarMultiplicationArgument == new Vector3(25.0f, 20.0f, 15.0f));
Vector3 Point3 = new Vector3(2, 3, 4);
Point3 *= 6;
Assert.IsTrue(Point3.Equals(new Vector3(12, 18, 24), .01f));
}
internal static bool IsValidTarget(Obj_AI_Hero target,
float range,
DamageType damageType,
bool ignoreShields = true,
Vector3 from = default(Vector3))
{
try
{
return target.IsValidTarget() &&
target.Distance(
(from.Equals(default(Vector3)) ? ObjectManager.Player.ServerPosition : from), true) <
Math.Pow((range <= 0 ? Orbwalking.GetRealAutoAttackRange(target) : range), 2) &&
!Invulnerable.Check(target, damageType, ignoreShields);
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return false;
}
internal static bool IsValidTarget(AIHeroClient target,
float range,
DamageType damageType,
bool ignoreShield = true,
Vector3 from = default(Vector3))
{
try
{
return target.IsValidTarget() &&
target.Distance(
(from.Equals(default(Vector3)) ? ObjectManager.Player.ServerPosition : from), true) <
Math.Pow((range <= 0 ? ObjectManager.Player.GetAutoAttackRange(target) : range), 2) &&
!Invulnerable.Check(target, damageType, ignoreShield );
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return false;
}
public override bool BlockPlaced(World world, Vector3 position, Vector3 blockClicked, byte facing, Entities.Entity placedBy)
{
Metadata = MathHelper.DirectionByRotationFlat(placedBy);
switch ((Directions)Metadata)
{
case Directions.North:
Metadata = (byte)StairDirections.North;
break;
case Directions.South:
Metadata = (byte)StairDirections.South;
break;
case Directions.West:
Metadata = (byte)StairDirections.West;
break;
case Directions.East:
Metadata = (byte)StairDirections.East;
break;
}
if (blockClicked.Equals(position + Vector3.Up))
this.Metadata |= 4;
return true;
}
public override bool OnBlockPlaced(World world, Vector3 position, Vector3 clickedBlock, Vector3 clickedSide, Vector3 cursorPosition, Entities.Entity usedBy)
{
Metadata = (byte)MathHelper.DirectionByRotationFlat(usedBy);
switch ((Direction)Metadata)
{
case Direction.North:
Metadata = (byte)StairDirections.North;
break;
case Direction.South:
Metadata = (byte)StairDirections.South;
break;
case Direction.West:
Metadata = (byte)StairDirections.West;
break;
case Direction.East:
Metadata = (byte)StairDirections.East;
break;
}
if (clickedBlock.Equals(position + Vector3.Up))
this.Metadata |= 4;
return true;
}
private Tuple<List<Obj_AI_Hero>, Vector3> GetMaxRHits(HitChance hitChance, Vector3 fromCheck = default(Vector3))
{
if (fromCheck.Equals(default(Vector3)))
{
fromCheck = ObjectManager.Player.Position;
}
var input = new PredictionInput
{
Collision = true,
CollisionObjects = new[] { CollisionableObjects.YasuoWall },
From = fromCheck,
RangeCheckFrom = fromCheck,
Type = R.Type,
Radius = R.Width,
Delay = R.Delay,
Speed = R.Speed,
Range = R.Range,
Aoe = true
};
var castPosition = Vector3.Zero;
var totalHits = new List<Obj_AI_Hero>();
try
{
var positions = new List<CPrediction.Position>();
foreach (var t in GameObjects.EnemyHeroes)
{
if (t.IsValidTarget(R.Range * 1.5f, true, fromCheck))
{
input.Unit = t;
var prediction = Prediction.GetPrediction(input);
if (prediction.Hitchance >= hitChance)
{
positions.Add(new CPrediction.Position(t, prediction.UnitPosition));
}
}
}
var circle = new Geometry.Polygon.Circle(fromCheck, R.Range).Points;
foreach (var point in circle)
{
var hits = new List<Obj_AI_Hero>();
foreach (var position in positions)
{
R.UpdateSourcePosition(fromCheck, fromCheck);
if (R.WillHit(position.UnitPosition, point.To3D()))
{
hits.Add(position.Hero);
}
R.UpdateSourcePosition();
}
if (hits.Count > totalHits.Count)
{
castPosition = point.To3D();
totalHits = hits;
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return new Tuple<List<Obj_AI_Hero>, Vector3>(totalHits, castPosition);
}
private Tuple<int, List<Obj_AI_Hero>> GetHits(Spell spell,
float overrideWidth = -1f,
Vector3 fromCheck = default(Vector3))
{
try
{
if (fromCheck.Equals(default(Vector3)))
{
fromCheck = Ball.Position;
}
var input = new PredictionInput
{
Collision = true,
CollisionObjects = new[] { CollisionableObjects.YasuoWall },
From = fromCheck,
RangeCheckFrom = fromCheck,
Type = spell.Type,
Radius = spell.Width,
Delay = spell.Delay,
Speed = spell.Speed,
Range = spell.Range,
Aoe = true
};
var width = overrideWidth > 0 ? overrideWidth : spell.Width;
var hits = new List<Obj_AI_Hero>();
var positions = new List<CPrediction.Position>();
foreach (var t in GameObjects.EnemyHeroes)
{
if (t.IsValidTarget(width * 4, true, fromCheck))
{
input.Unit = t;
var prediction = Prediction.GetPrediction(input);
if (prediction.Hitchance >= HitChance.High)
{
if (Utils.IsImmobile(t) || Utils.IsSlowed(t) || t.Distance(fromCheck) < spell.Width * 0.75 ||
t.Distance(fromCheck) < spell.Width &&
(fromCheck.Distance(Ball.Position) > 100 || t.IsFacing(fromCheck, 120f)))
{
positions.Add(new CPrediction.Position(t, prediction.UnitPosition));
}
}
}
}
if (positions.Any())
{
var circle = new Geometry.Polygon.Circle(fromCheck, width);
hits.AddRange(
from position in positions
where
!position.Hero.IsDashing() ||
(position.Hero.Distance(fromCheck) >= 100f &&
position.Hero.Position.Distance(fromCheck) >
position.Hero.GetDashInfo().EndPos.Distance(fromCheck) - 50f)
where circle.IsInside(position.UnitPosition)
select position.Hero);
return new Tuple<int, List<Obj_AI_Hero>>(hits.Count, hits);
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return new Tuple<int, List<Obj_AI_Hero>>(0, new List<Obj_AI_Hero>());
}
// Test Operator: Equality //-----------------------------------------//
/// <summary>
/// Helper method for testing equality.
/// </summary>
void TestEquality (Vector3 a, Vector3 b, Boolean expected )
{
// This test asserts the following:
// (a == b) == expected
// (b == a) == expected
// (a != b) == !expected
// (b != a) == !expected
Boolean result_1a = (a == b);
Boolean result_1b = (a.Equals(b));
Boolean result_1c = (a.Equals((Object)b));
Boolean result_2a = (b == a);
Boolean result_2b = (b.Equals(a));
Boolean result_2c = (b.Equals((Object)a));
Boolean result_3a = (a != b);
Boolean result_4a = (b != a);
Assert.That(result_1a, Is.EqualTo(expected));
Assert.That(result_1b, Is.EqualTo(expected));
Assert.That(result_1c, Is.EqualTo(expected));
Assert.That(result_2a, Is.EqualTo(expected));
Assert.That(result_2b, Is.EqualTo(expected));
Assert.That(result_2c, Is.EqualTo(expected));
Assert.That(result_3a, Is.EqualTo(!expected));
Assert.That(result_4a, Is.EqualTo(!expected));
}
private List<MLineVertex> ReadMLineSegments(int numVertexes, int numStyleElements, Vector3 normal, out double elevation)
{
elevation = 0.0;
List<MLineVertex> segments = new List<MLineVertex>();
Matrix3 trans = MathHelper.ArbitraryAxis(normal).Traspose();
for (int i = 0; i < numVertexes; i++)
{
Vector3 vertex = new Vector3();
vertex.X = this.chunk.ReadDouble(); // code 11
this.chunk.Next();
vertex.Y = this.chunk.ReadDouble(); // code 21
this.chunk.Next();
vertex.Z = this.chunk.ReadDouble(); // code 31
this.chunk.Next();
Vector3 dir = new Vector3();
dir.X = this.chunk.ReadDouble(); // code 12
this.chunk.Next();
dir.Y = this.chunk.ReadDouble(); // code 22
this.chunk.Next();
dir.Z = this.chunk.ReadDouble(); // code 32
this.chunk.Next();
Vector3 mitter = new Vector3();
mitter.X = this.chunk.ReadDouble(); // code 13
this.chunk.Next();
mitter.Y = this.chunk.ReadDouble(); // code 23
this.chunk.Next();
mitter.Z = this.chunk.ReadDouble(); // code 33
this.chunk.Next();
List<double>[] distances = new List<double>[numStyleElements];
for (int j = 0; j < numStyleElements; j++)
{
distances[j] = new List<double>();
short numDistances = this.chunk.ReadShort(); // code 74
this.chunk.Next();
for (short k = 0; k < numDistances; k++)
{
distances[j].Add(this.chunk.ReadDouble()); // code 41
this.chunk.Next();
}
// no more info is needed, fill parameters are not supported
short numFillParams = this.chunk.ReadShort(); // code 75
this.chunk.Next();
for (short k = 0; k < numFillParams; k++)
{
//double param = this.chunk.ReadDouble(); // code 42
this.chunk.Next();
}
}
// we need to convert WCS coordinates to OCS coordinates
if (!normal.Equals(Vector3.UnitZ))
{
vertex = trans*vertex;
dir = trans*dir;
mitter = trans*mitter;
}
MLineVertex segment = new MLineVertex(new Vector2(vertex.X, vertex.Y),
new Vector2(dir.X, dir.Y),
new Vector2(mitter.X, mitter.Y),
distances);
elevation = vertex.Z;
segments.Add(segment);
}
return segments;
}
/// <inheritdoc />
public unsafe override int BuildVertexBuffer(ref ParticleBufferState bufferState, Vector3 invViewX, Vector3 invViewY,
ref Vector3 spaceTranslation, ref Quaternion spaceRotation, float spaceScale, ref ParticleList sorter)
{
// Update the curve samplers if required
base.BuildVertexBuffer(ref bufferState, invViewX, invViewY, ref spaceTranslation, ref spaceRotation, spaceScale, ref sorter);
// Get all required particle fields
var positionField = sorter.GetField(ParticleFields.Position);
if (!positionField.IsValid())
return 0;
var lifeField = sorter.GetField(ParticleFields.Life);
var sizeField = sorter.GetField(ParticleFields.Size);
var rotField = sorter.GetField(ParticleFields.Quaternion);
var hasRotation = rotField.IsValid() || (SamplerRotation != null);
// Check if the draw space is identity - in this case we don't need to transform the position, scale and rotation vectors
var trsIdentity = (spaceScale == 1f);
trsIdentity = trsIdentity && (spaceTranslation.Equals(new Vector3(0, 0, 0)));
trsIdentity = trsIdentity && (spaceRotation.Equals(Quaternion.Identity));
var renderedParticles = 0;
var posAttribute = bufferState.GetAccessor(VertexAttributes.Position);
var texAttribute = bufferState.GetAccessor(bufferState.DefaultTexCoords);
foreach (var particle in sorter)
{
var centralPos = GetParticlePosition(particle, positionField, lifeField);
var particleSize = GetParticleSize(particle, sizeField, lifeField);
var unitX = new Vector3(1, 0, 0);
var unitY = new Vector3(0, 0, 1);
if (hasRotation)
{
var particleRotation = GetParticleRotation(particle, rotField, lifeField);
particleRotation.Rotate(ref unitX);
particleRotation.Rotate(ref unitY);
}
// The TRS matrix is not an identity, so we need to transform the quad
if (!trsIdentity)
{
spaceRotation.Rotate(ref centralPos);
centralPos = centralPos * spaceScale + spaceTranslation;
particleSize *= spaceScale;
spaceRotation.Rotate(ref unitX);
spaceRotation.Rotate(ref unitY);
}
// Use half size to make a Size = 1 result in a Billboard of 1m x 1m
unitX *= (particleSize * 0.5f);
unitY *= (particleSize * 0.5f);
var particlePos = centralPos - unitX + unitY;
var uvCoord = new Vector2(0, 0);
// 0f 0f
bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos));
bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord));
bufferState.NextVertex();
// 1f 0f
particlePos += unitX * 2;
uvCoord.X = 1;
bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos));
bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord));
bufferState.NextVertex();
// 1f 1f
particlePos -= unitY * 2;
uvCoord.Y = 1;
bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos));
bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord));
bufferState.NextVertex();
// 0f 1f
particlePos -= unitX * 2;
uvCoord.X = 0;
bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos));
bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord));
bufferState.NextVertex();
renderedParticles++;
}
var vtxPerShape = 4 * QuadsPerParticle;
return renderedParticles * vtxPerShape;
}
public static void SavePrimListToXml2(List<EntityBase> entityList, TextWriter stream, Vector3 min, Vector3 max)
{
int primCount = 0;
stream.WriteLine("<scene>\n");
foreach (EntityBase ent in entityList)
{
if (ent is SceneObjectGroup)
{
SceneObjectGroup g = (SceneObjectGroup)ent;
if (!min.Equals(Vector3.Zero) || !max.Equals(Vector3.Zero))
{
Vector3 pos = g.RootPart.GetWorldPosition();
if (min.X > pos.X || min.Y > pos.Y || min.Z > pos.Z)
continue;
if (max.X < pos.X || max.Y < pos.Y || max.Z < pos.Z)
continue;
}
stream.WriteLine(SceneObjectSerializer.ToXml2Format(g));
primCount++;
}
}
stream.WriteLine("</scene>\n");
stream.Flush();
}
/// <inheritdoc />
public override unsafe int BuildVertexBuffer(ref ParticleBufferState bufferState, Vector3 invViewX, Vector3 invViewY,
ref Vector3 spaceTranslation, ref Quaternion spaceRotation, float spaceScale, ref ParticleList sorter)
{
// Get all the required particle fields
var positionField = sorter.GetField(ParticleFields.Position);
if (!positionField.IsValid())
return 0;
var sizeField = sorter.GetField(ParticleFields.Size);
var orderField = sorter.GetField(ParticleFields.Order);
// Check if the draw space is identity - in this case we don't need to transform the position, scale and rotation vectors
// ReSharper disable once CompareOfFloatsByEqualityOperator
var trsIdentity = (spaceScale == 1f);
trsIdentity = trsIdentity && (spaceTranslation.Equals(new Vector3(0, 0, 0)));
trsIdentity = trsIdentity && (spaceRotation.Equals(Quaternion.Identity));
var ribbonizer = new Ribbonizer(this, currentTotalParticles, currentQuadsPerParticle);
var renderedParticles = 0;
bufferState.StartOver();
uint oldOrderValue = 0;
foreach (var particle in sorter)
{
if (orderField.IsValid())
{
var orderValue = (*((uint*)particle[orderField]));
if ((orderValue >> SpawnOrderConst.GroupBitOffset) != (oldOrderValue >> SpawnOrderConst.GroupBitOffset))
{
ribbonizer.Ribbonize(ref bufferState, invViewX, invViewY, QuadsPerParticle);
ribbonizer.RibbonSplit();
}
oldOrderValue = orderValue;
}
var centralPos = particle.Get(positionField);
var particleSize = sizeField.IsValid() ? particle.Get(sizeField) : 1f;
if (!trsIdentity)
{
spaceRotation.Rotate(ref centralPos);
centralPos = centralPos * spaceScale + spaceTranslation;
particleSize *= spaceScale;
}
ribbonizer.AddParticle(ref centralPos, particleSize);
renderedParticles++;
}
ribbonizer.Ribbonize(ref bufferState, invViewX, invViewY, QuadsPerParticle);
ribbonizer.Free();
var vtxPerShape = 4 * QuadsPerParticle;
return renderedParticles * vtxPerShape;
}
public void Equals_CanDetermineIfTwoVectorsHaveEqualValues_AndFalseIsReturnedIfTheyAreNot()
{
var vector = new Vector3(1.0, 2.0, 3.0);
var differentZ = new Vector3(1.0, 2.0, 3.1);
var differentY = new Vector3(1.0, 2.1, 3.0);
var differentX = new Vector3(1.1, 2.0, 3.0);
Assert.IsFalse(vector.Equals(differentZ));
Assert.IsFalse(vector.Equals(differentY));
Assert.IsFalse(vector.Equals(differentX));
Assert.IsFalse(vector.Equals("String"));
}
/// <summary>
/// Gets the minimum distance between two convex polyhedra.
/// </summary>
/// <param name="supportFunction">The function delegate responsible for returning support points.</param>
/// <param name="epsilon">The amount of allotted error in the result.</param>
/// <param name="maxIterations"><c>true</c> if there was an intersection between the two convex polyhedra; otherwise, <c>falce</c>.</param>
/// <returns>The minimum distance between the two convex polyhedra.</returns>
public float GetMinimumDistance(Func<Vector3, Vector3> supportFunction, int maxIterations, float epsilon)
{
/*
* This method uses the following psuedo code from the paper:
* http://www.win.tue.nl/~gino/solid/jgt98convex.pdf
*
*
* v := "arbitrary point in A − B";
* W := ∅;
* μ := 0;
* close_enough := false;
*
* while not close_enough and v ≠ 0 do begin
* w := Sᴀ-ʙ(−v);
* δ := v⋅w/‖v‖;
* μ := max{μ,δ};
* close_enough := ‖v‖ − μ ≤ ε;
*
* if not close_enough then begin
* v := υ(conv(W ∪ {w}));
* W := "smallest X ⊆ W ∪ {w} such that v ∈ conv(X)";
* end
* end;
*
* return ‖v‖
*/
var currentiteration = 0;
var u = 0f;
var closeenough = false;
Direction = supportFunction(Direction);
count = 0;
while (!closeenough && !Direction.Equals(Vector3.Zero, Utilities.ZeroTolerance) && currentiteration < maxIterations)
{
currentiteration++;
float directionlength = Direction.Length;
var w = supportFunction(-Direction);
var d = Vector3.Dot(Direction, w) / directionlength;
u = Math.Max(u, d);
closeenough = directionlength - u <= epsilon;
simplex[count++] = w;
if (!closeenough)
{
switch (count)
{
case 2:
DoLineNoDirection(simplex[1], simplex[0]);
break;
case 3:
DoTriangleNoDirection(simplex[2], simplex[1], simplex[0]);
break;
case 4:
if (DoTetrahedronNoDirection(simplex[3], simplex[2], simplex[1], simplex[0]))
{
//Objects intersect, distance makes no sense
return Direction.Length;
}
break;
}
Vector3 origin = Vector3.Zero;
switch (count)
{
case 1:
Direction = simplex[0];
break;
case 2:
Collision.ClosestPointOnSegmentToPoint(ref simplex[0], ref simplex[1], ref origin, out direction);
break;
case 3:
Collision.ClosestPointOnTriangleToPoint(ref simplex[0], ref simplex[1], ref simplex[2], ref origin, out direction);
break;
}
}
}
return Direction.Length;
}
private void CreateTurret(Vector3 location, Vector3 angles)
{
this.Call<Entity>("spawn", new Parameter[1] { (Parameter)"script_model" }).SetField("angles", new Parameter(angles));
if (angles.Equals((object)null))
angles = new Vector3(0.0f, 0.0f, 0.0f);
Entity entity = this.Call<Entity>("spawnTurret", (Parameter)"misc_turret", new Parameter(location), (Parameter)"pavelow_minigun_mp");
entity.Call("setmodel", new Parameter[1] { (Parameter)"sentry_minigun" });
entity.SetField("angles", (Parameter)angles);
this.MakeUsable(entity, "turret", 50);
}
trace_t Trace(Vector3 start, Vector3 end, Vector3 mins, Vector3 maxs, int model, Vector3 origin, int brushmask)
{
//cmodel_t cmod = ClipHandleToModel(model);
// for multi-check avoidance
checkcount++;
// for statistics, may be zeroed
c_traces++;
this.tw = new traceWork_t();
traceWork_t tw = this.tw;
tw.trace = new trace_t();
tw.trace.fraction = 1f; // assume it goes the entire distance until shown otherwise
tw.modelOrigin = origin;
if (nodes == null || nodes.Length == 0)
{
return tw.trace; // map not loaded, shouldn't happen
}
// set basic parms
tw.contents = brushmask;
// adjust so that mins and maxs are always symetric, which
// avoids some complications with plane expanding of rotated
// bmodels
Vector3 offset = (mins+maxs) * 0.5f;
tw.size[0] = mins - offset;
tw.size[1] = maxs - offset;
tw.start = start + offset;
tw.end = end + offset;
tw.maxOffset = tw.size[1][0] + tw.size[1][1] + tw.size[1][2];
// tw.offsets[signbits] = vector to apropriate corner from origin
tw.offsets[0][0] = tw.size[0][0];
tw.offsets[0][1] = tw.size[0][1];
tw.offsets[0][2] = tw.size[0][2];
tw.offsets[1][0] = tw.size[1][0];
tw.offsets[1][1] = tw.size[0][1];
tw.offsets[1][2] = tw.size[0][2];
tw.offsets[2][0] = tw.size[0][0];
tw.offsets[2][1] = tw.size[1][1];
tw.offsets[2][2] = tw.size[0][2];
tw.offsets[3][0] = tw.size[1][0];
tw.offsets[3][1] = tw.size[1][1];
tw.offsets[3][2] = tw.size[0][2];
tw.offsets[4][0] = tw.size[0][0];
tw.offsets[4][1] = tw.size[0][1];
tw.offsets[4][2] = tw.size[1][2];
tw.offsets[5][0] = tw.size[1][0];
tw.offsets[5][1] = tw.size[0][1];
tw.offsets[5][2] = tw.size[1][2];
tw.offsets[6][0] = tw.size[0][0];
tw.offsets[6][1] = tw.size[1][1];
tw.offsets[6][2] = tw.size[1][2];
tw.offsets[7][0] = tw.size[1][0];
tw.offsets[7][1] = tw.size[1][1];
tw.offsets[7][2] = tw.size[1][2];
//
// calculate bounds
//
for (int i = 0; i < 3; i++)
{
if (tw.start[i] < tw.end[i])
{
tw.bounds[0][i] = tw.start[i] + tw.size[0][i];
tw.bounds[1][i] = tw.end[i] + tw.size[1][i];
}
else
{
tw.bounds[0][i] = tw.end[i] + tw.size[0][i];
tw.bounds[1][i] = tw.start[i] + tw.size[1][i];
}
}
//
// check for position test special case
//
if (start.Equals(end))
{
if (model > 0)
{
int test = 2;
//TestInLeaf(tw, cmod.leaf);
}
else
{
PositionTest(tw);
}
}
else
{
//
// check for point special case
//
if (tw.size[0].Equals(Vector3.Zero))
{
tw.isPoint = true;
tw.extents = Vector3.Zero;
}
else
{
tw.isPoint = false;
tw.extents = tw.size[1];
}
//
// general sweeping through world
//
if (model > 0)
{
int test = 2;
//TraceThroughLeaf(tw, cmod.leaf);
}
else
{
RecursiveHullCheck(tw, 0, 0, 1, tw.start, tw.end);
//TraceThroughTree(tw, 0, 0, 1, tw.start, tw.end);
}
}
// generate endpos from the original, unmodified start/end
if (tw.trace.fraction == 1f)
{
tw.trace.endpos = end;
}
else
{
tw.trace.endpos = start + (tw.trace.fraction * (end - start));
}
// If allsolid is set (was entirely inside something solid), the plane is not valid.
// If fraction == 1.0, we never hit anything, and thus the plane is not valid.
// Otherwise, the normal on the plane should have unit length
Debug.Assert(tw.trace.allsolid || tw.trace.fraction == 1f || tw.trace.plane.normal.LengthSquared() > 0.9999f);
return tw.trace;
}
private static void Check(bool dash,
Obj_AI_Hero sender,
Vector3 startPosition,
Vector3 endPosition,
float endTime,
bool targeted)
{
try
{
if (!sender.IsValid || !sender.IsEnemy || sender.IsDead)
{
return;
}
if (Game.Time - endTime >= 5)
{
return;
}
if (endPosition.Distance(ObjectManager.Player.ServerPosition) >= 2000)
{
return;
}
foreach (var entry in Menues)
{
var uniqueId = entry.Key;
var menu = entry.Value;
if (HeroListManager.Check(uniqueId, sender))
{
var distance = menu.Item(menu.Name + ".gap-" + uniqueId + ".distance").GetValue<Slider>().Value;
var dangerous = menu.Item(menu.Name + ".gap-" + uniqueId + ".dangerous").GetValue<bool>();
if (startPosition.Distance(ObjectManager.Player.Position) >= distance &&
(!dangerous || IsDangerous(sender, startPosition, endPosition, targeted)))
{
var delay = menu.Item(menu.Name + ".gap-" + uniqueId + ".delay").GetValue<Slider>().Value;
var randomize =
menu.Item(menu.Name + ".gap-" + uniqueId + ".randomize").GetValue<Slider>().Value;
if (delay > 1)
{
delay = Random.Next((int) (delay * 0.9f), (int) (delay * 1.1f));
}
if (randomize > 0)
{
if (!startPosition.Equals(Vector3.Zero))
{
startPosition.X += Random.Next(0, randomize * 2 + 1) - randomize;
startPosition.Y += Random.Next(0, randomize * 2 + 1) - randomize;
}
if (!endPosition.Equals(Vector3.Zero))
{
endPosition.X += Random.Next(0, randomize * 2 + 1) - randomize;
endPosition.Y += Random.Next(0, randomize * 2 + 1) - randomize;
}
}
Utility.DelayAction.Add(
Math.Max(1, dash ? delay - 100 : delay),
() =>
OnGapcloser.RaiseEvent(
null,
new GapcloserManagerArgs(uniqueId, sender, startPosition, endPosition, endTime)));
}
}
}
OnGapcloser.RaiseEvent(
null, new GapcloserManagerArgs(string.Empty, sender, startPosition, endPosition, endTime));
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
public void CreateTurret(Vector3 origin, Vector3 angles)
{
Entity turret = Call<Entity>("spawn", "script_model");
turret.SetField("angles", new Parameter(angles));
if (angles.Equals(null))
angles = new Vector3(0f, 0f, 0f);
turret = Call<Entity>("spawnTurret", "misc_turret", new Parameter(origin), "pavelow_minigun_mp");
turret.Call("setmodel", "weapon_minigun");
turret.SetField("angles", angles);
}
/// <inheritdoc />
public unsafe override int BuildVertexBuffer(ParticleVertexBuilder vtxBuilder, Vector3 invViewX, Vector3 invViewY,
ref Vector3 spaceTranslation, ref Quaternion spaceRotation, float spaceScale, ParticleSorter sorter)
{
// Get all the required particle fields
var positionField = sorter.GetField(ParticleFields.Position);
if (!positionField.IsValid())
return 0;
var sizeField = sorter.GetField(ParticleFields.Size);
var directionField = sorter.GetField(ParticleFields.Direction);
// Check if the draw space is identity - in this case we don't need to transform the position, scale and rotation vectors
var trsIdentity = (spaceScale == 1f);
trsIdentity = trsIdentity && (spaceTranslation.Equals(new Vector3(0, 0, 0)));
trsIdentity = trsIdentity && (spaceRotation.Equals(Quaternion.Identity));
var renderedParticles = 0;
vtxBuilder.RestartBuffer();
uint oldOrderValue = 0;
var orderField = sorter.GetField(ParticleFields.Order);
foreach (var particle in sorter)
{
if (orderField.IsValid())
{
var orderValue = (*((uint*)particle[orderField]));
if ((orderValue >> 16) != (oldOrderValue >> 16))
{
ribbonizer.Ribbonize(vtxBuilder, QuadsPerParticle);
ribbonizer.RibbonSplit();
}
oldOrderValue = orderValue;
}
var centralPos = particle.Get(positionField);
var particleSize = sizeField.IsValid() ? particle.Get(sizeField) : 1f;
var particleDirection = directionField.IsValid() ? particle.Get(directionField) * particleSize : new Vector3(0f, particleSize, 0f);
if (!trsIdentity)
{
spaceRotation.Rotate(ref centralPos);
centralPos = centralPos * spaceScale + spaceTranslation;
// Direction
spaceRotation.Rotate(ref particleDirection);
particleDirection *= spaceScale;
}
ribbonizer.AddParticle(ref centralPos, ref particleDirection);
renderedParticles++;
}
ribbonizer.Ribbonize(vtxBuilder, QuadsPerParticle);
var vtxPerShape = 4 * QuadsPerParticle;
return renderedParticles * vtxPerShape;
}
public MRMPrim(MRMPrimFactory factory, string name, Vector3 position, Color colour = default(Color), Vector3 scale = default(Vector3), PrimType shape = PrimType.Unknown, Quaternion rotation = default(Quaternion))
{
_exists = true;
_editable = true;
_factory = factory;
_name = name;
_obj = factory.RegisterPrim(this, name, position);
_id = _obj.GlobalID;
_child = !ID.Equals(_obj.Root.GlobalID);
Glow = 0d;
Name = _name;
Colour = !colour.Equals(default(Color)) ? colour : Color.White;
Shape = !shape.Equals(PrimType.Unknown) ? shape : PrimType.Box;
Rotation = !rotation.Equals(default(Quaternion)) ? rotation : Quaternion.Identity;
Scale = !scale.Equals(default(Vector3)) ? scale : new Vector3(.5f, .5f, .5f);
_updateListener = Update;
factory.Update += _updateListener;
}
public void Equals_CanDetermineIfTwoVectorsHaveEqualValues_AndTrueIsReturnedIfTheyAre()
{
var vector = new Vector3(1.0, 2.0, 3.0);
var other = new Vector3(1.0, 2.0, 3.0);
Assert.IsTrue(vector.Equals(other));
}
/// <inheritdoc />
public override unsafe int BuildVertexBuffer(ref ParticleBufferState bufferState, Vector3 invViewX, Vector3 invViewY,
ref Vector3 spaceTranslation, ref Quaternion spaceRotation, float spaceScale, ref ParticleList sorter)
{
// Update the curve samplers if required
base.BuildVertexBuffer(ref bufferState, invViewX, invViewY, ref spaceTranslation, ref spaceRotation, spaceScale, ref sorter);
// Get all required particle fields
var positionField = sorter.GetField(ParticleFields.Position);
if (!positionField.IsValid())
return 0;
var sizeField = sorter.GetField(ParticleFields.Size);
var lifeField = sorter.GetField(ParticleFields.Life);
var angleField = sorter.GetField(ParticleFields.Angle);
var hasAngle = angleField.IsValid() || (SamplerRotation != null);
// Check if the draw space is identity - in this case we don't need to transform the position, scale and rotation vectors
var trsIdentity = (spaceScale == 1f);
trsIdentity = trsIdentity && (spaceTranslation.Equals(new Vector3(0, 0, 0)));
trsIdentity = trsIdentity && (spaceRotation.Equals(Quaternion.Identity));
var renderedParticles = 0;
var posAttribute = bufferState.GetAccessor(VertexAttributes.Position);
var texAttribute = bufferState.GetAccessor(bufferState.DefaultTexCoords);
foreach (var particle in sorter)
{
var centralPos = GetParticlePosition(particle, positionField, lifeField);
var particleSize = GetParticleSize(particle, sizeField, lifeField);
if (!trsIdentity)
{
spaceRotation.Rotate(ref centralPos);
centralPos = centralPos * spaceScale + spaceTranslation;
particleSize *= spaceScale;
}
// Use half size to make a Size = 1 result in a Billboard of 1m x 1m
var unitX = invViewX * (particleSize * 0.5f);
var unitY = invViewY * (particleSize * 0.5f);
// Particle rotation. Positive value means clockwise rotation.
if (hasAngle)
{
var rotationAngle = GetParticleRotation(particle, angleField, lifeField);
var cosA = (float)Math.Cos(rotationAngle);
var sinA = (float)Math.Sin(rotationAngle);
var tempX = unitX * cosA - unitY * sinA;
unitY = unitY * cosA + unitX * sinA;
unitX = tempX;
}
// vertex.Size = particleSize;
const float Sqrt3Half = 0.86602540378f;
unitY *= Sqrt3Half;
var halfX = unitX * 0.5f;
var particlePos = centralPos - halfX + unitY;
var uvCoord = new Vector2(0.25f, 0.5f - Sqrt3Half * 0.5f);
// Upper half
// 0f 0f
bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos));
bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord));
bufferState.NextVertex();
// 1f 0f
particlePos += unitX;
uvCoord.X = 0.75f;
bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos));
bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord));
bufferState.NextVertex();
// 1f 1f
particlePos += halfX;
particlePos -= unitY;
uvCoord.X = 1;
uvCoord.Y = 0.5f;
bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos));
bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord));
bufferState.NextVertex();
// 0f 1f
particlePos -= unitX * 2;
uvCoord.X = 0;
bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos));
bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord));
bufferState.NextVertex();
// Upper half
// 0f 0f
bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos));
bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord));
bufferState.NextVertex();
// 1f 0f
particlePos += unitX * 2;
uvCoord.X = 1;
bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos));
bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord));
bufferState.NextVertex();
// 1f 1f
particlePos -= halfX;
particlePos -= unitY;
uvCoord.X = 0.75f;
uvCoord.Y = 1;
bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos));
bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord));
bufferState.NextVertex();
// 0f 1f
particlePos -= unitX;
uvCoord.X = 0.25f;
bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos));
bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord));
bufferState.NextVertex();
renderedParticles++;
}
var vtxPerShape = 4 * QuadsPerParticle;
return renderedParticles * vtxPerShape;
}
private static bool IsValidTarget(Obj_AI_Hero target,
float range,
DamageType damageType,
bool ignoreShields = true,
Vector3 from = default(Vector3))
{
return target.IsValidTarget() &&
target.Distance((from.Equals(default(Vector3)) ? ObjectManager.Player.ServerPosition : from), true) <
Math.Pow((range <= 0 ? Orbwalking.GetRealAutoAttackRange(target) : range), 2) &&
!Invulnerable.HasBuff(target, damageType, ignoreShields);
}
public static void renderVector(Vector3 origin, Vector3 n, Color color)
{
//TODO ver donde meter este metodo
if (n.Equals(Vector3.Empty)) return;
TgcArrow arrow = new TgcArrow();
//arrow.Enabled = true;
arrow.PStart = origin;
arrow.PEnd = n * 70 + arrow.PStart;
arrow.Thickness = 3;
arrow.HeadSize = new Vector2(6, 6);
arrow.BodyColor = color;
arrow.updateValues();
arrow.render();
}
