public static ArrowHelper Create(Renderer renderer, Vector3 dir, Vector3 origin, float length = 1, Color? color = null, float? headLength = null, float? headWidth = null)
{
var c = color.HasValue ? color.Value : new Color(0xffff00);
if (lineGeometry == null)
{
lineGeometry = new Geometry();
lineGeometry.vertices.Add(Vector3.Zero);
lineGeometry.vertices.Add(Vector3.UnitY);
lineGeometry.vertexColors = new List<Color>()
{
c,
c,
};
}
if (coneGeometry == null)
{
coneGeometry = new CylinderGeometry(0, 0.5f, 1, 5, 1);
var m = Matrix4.MakeTranslation(0, -0.5f, 0);
coneGeometry.Apply(m);
}
var arrowHelper = new ArrowHelper();
// dir is assumed to be normalized
var head = headLength.HasValue ? headLength.Value : 0.2f * length;
var width = headWidth.HasValue ? headWidth.Value : 0.2f * head;
arrowHelper.Position = origin;
arrowHelper.line = new Line(lineGeometry, new LineBasicMaterial(renderer)
{
Diffuse = c,
VertexColors = Net.Renderers.VertexColorMode.Vertex
});
arrowHelper.line.matrixAutoUpdate = false;
arrowHelper.Add(arrowHelper.line);
arrowHelper.cone = new Mesh(coneGeometry, new MeshBasicMaterial(renderer)
{
Diffuse = c
});
arrowHelper.cone.matrixAutoUpdate = false;
arrowHelper.Add(arrowHelper.cone);
arrowHelper.SetDirection(dir.Normalized());
arrowHelper.SetLength(length, head, width);
return arrowHelper;
}
// Project vector onto sphere's surface
private VertexInfo Prepare(Vector3 vector, List<VertexInfo> vertexSet)
{
var p = vector.Normalized();
var i = vertexSet.Count;
var u = Azimuth(vector) / 2 / Mathf.Pi + 0.5f;
var v = Inclination(vector) / Mathf.Pi + 0.5f;
var vertex = new VertexInfo()
{
Position = p,
Index = i,
// Texture coords are equivalent to map coords, calculate angle and convert to fraction of a circle.
UV = new Vector2(u, 1 - v)
};
vertexSet.Add(vertex);
return vertex;
}
private static void ShouldLookAt(Vector3 direction)
{
direction = direction.Normalized();
var quaternionLook = Quaternion.LookAt(direction)*Vector3.Forward;
Compare(quaternionLook, direction);
}
Color4 SunColor ( Vector3 dir )
{
Color4 dusk = new Color4(Temperature.Get(2000), 1);
Color4 zenith = new Color4(Temperature.Get(Params.SunTemperature), 1);
Vector3 ndir = dir.Normalized();
return Color4.Lerp( dusk, zenith, (float)Math.Pow(ndir.Y, 0.5f) );
}
public static void Test_Vector3_Generic_Normalization_Against_Unity3D(float a, float b, float c)
{
//arrange
Vector3<float> genericVec3 = new Vector3<float>(a, b, c);
UnityEngine.Vector3 unityVec3 = new UnityEngine.Vector3(a, b, c);
//act
Vector3<float> genericNormalized = genericVec3.Normalized();
UnityEngine.Vector3 unityNormalized = unityVec3.normalized;
//assert
//Warning: We provide more accurate normalized components than Unity. Magnitudes are almost exactly the same
//For example see: http://www.wolframalpha.com/input/?i=normalize%285.3%2C+6.5%2C+7.6%29 in this case Unity provides nearly even components
//we provide exactly what Wolfram does.
Assert.AreEqual(unityNormalized.magnitude, genericNormalized.Magnitude(), 1.1E-6, "Normalization failed. Generic:{0} Unity:{1}", genericNormalized, unityNormalized);
}
/// <summary>
///
/// </summary>
/// <param name="targetID"></param>
/// <param name="attackerID"></param>
/// <param name="damage"></param>
/// <param name="kickImpulse"></param>
/// <param name="kickPoint"></param>
/// <param name="damageType"></param>
public override bool Damage ( uint targetID, uint attackerID, short damage, Vector3 kickImpulse, Vector3 kickPoint, DamageType damageType )
{
if (damage<=0) {
return false;
}
var c = controller;
var e = Entity;
c.SupportFinder.ClearSupportData();
var i = MathConverter.Convert( kickImpulse );
var p = MathConverter.Convert( kickPoint );
c.Body.ApplyImpulse( p, i );
/**************************************************
*
* 1. Accumulate damage and emit FX according to
* maximum inflicted damage.
* Probably we have to add new controller stage
* for FX processing (e.g. Update and UpdateFX).
*
* 2. Do not scream at each damage.
* Screams should not overlap!
*
**************************************************/
//
// calc health :
//
var health = e.GetItemCount( Inventory.Health );
health -= damage;
var dir = kickImpulse.Normalized();
if (health>75) {
World.SpawnFX("PlayerPain25", targetID, kickPoint, dir );
} else
if (health>50) {
World.SpawnFX("PlayerPain50", targetID, kickPoint, dir );
} else
if (health>25) {
World.SpawnFX("PlayerPain75", targetID, kickPoint, dir );
} else
if (health>0) {
World.SpawnFX("PlayerPain100", targetID, kickPoint, dir );
} else
if (health>-25) {
World.SpawnFX("PlayerDeath", targetID, e.Position, dir );
} else {
World.SpawnFX("PlayerDeathMeat", targetID, e.Position, kickImpulse, dir );
}
if (health<=0) {
World.Kill( targetID );
return true;
}
e.SetItemCount( Inventory.Health, health );
return false;
}
private static bool Combo()
{
var flags = Orbwalker.ActiveModesFlags;
if (flags.HasFlag(Orbwalker.ActiveModes.Combo) && menuIni.Get<CheckBox>("Combo").CurrentValue)
{
var qm = ComboMenu.Get<CheckBox>("CUse_Q").CurrentValue;
var wm = ComboMenu.Get<CheckBox>("CUse_W").CurrentValue;
var em = ComboMenu.Get<CheckBox>("CUse_E").CurrentValue;
{
if (eTarget == null && E.Handle.ToggleState == 2)
{
E.Cast();
}
if (eTarget != null)
{
if (em && E.IsReady() && !player.IsZombie)
{
if (eTarget.IsValidTarget(E.Range) && E.Handle.ToggleState != 2)
{
E.Cast();
}
}
}
double countmana = W.Handle.SData.Mana;
if (wm && W.IsReady() && wTarget.IsValid && wTarget != null)
{
double ds = 0;
if (R.IsReady())
{
ds += player.GetSpellDamage(qTarget, SpellSlot.R);
countmana += R.Handle.SData.Mana;
}
while (qTarget != null && ds < qTarget.MaxHealth)
{
var qd = player.GetSpellDamage(qTarget, SpellSlot.Q);
ds += qd;
if (Q.Handle != null)
{
countmana += Q.Handle.SData.Mana;
}
}
var predW = W.GetPrediction(wTarget);
if (player.ManaPercent >= LaneMenu.Get<Slider>("LHQPercent").CurrentValue || qTarget.CountAlliesInRange(W.Range) > 3 || player.IsZombie)
{
W.Cast(predW.CastPosition);
}
}
if (qTarget == null || (!qm || !Q.IsReady() || !qTarget.IsValid))
{
return false;
}
var predQ = Q2.GetPrediction(qTarget);
var RDPos = qTarget.ServerPosition.X - Player.Instance.ServerPosition.X;
var RDPos2 = qTarget.ServerPosition.Y - Player.Instance.ServerPosition.Y;
var RPos = new Vector3(predQ.CastPosition.X + RDPos, predQ.CastPosition.Y + RDPos2, predQ.CastPosition.Z);
var RPosn = (RPos.Normalized());
if (!cz && predQ.HitChance >= HitChance.High)
{
if (ObjectManager.Player.Position.Distance(qTarget.ServerPosition) <= 900)
{
Q.Cast(predQ.CastPosition);
}
}
else
{
Q.Cast(predQ.CastPosition);
}
}
}
return true;
}