protected override bool MakeResult(Character cc)
{
if (cc == null)
{
return(false);
}
EffectUnit unit = null;
if (World)
{
Transform p = cc.Avatar.GetBindTransform(Bind);
unit = GTWorld.Instance.Ect.LoadEffect(ID, 0, Retain);
unit.CacheTransform.parent = p;
unit.CacheTransform.localPosition = Offset;
unit.CacheTransform.localEulerAngles = Euler;
unit.CacheTransform.parent = null;
unit.CacheTransform.localScale = Scale;
}
else
{
Transform p = cc.Avatar.GetBindTransform(Bind);
unit = GTWorld.Instance.Ect.LoadEffect(ID, 0, KTransform.Create(Offset, Euler, Scale), p, Retain);
}
unit.Release(Duration);
return(true);
}
public EffectUnit(int id, ulong guid, KTransform data, Transform parent, bool retain)
{
this.ID = id;
this.GUID = guid > 0 ? guid : GTGUID.NewGUID();
this.Parent = parent;
this.Retain = retain;
this.Cfg = ReadCfgEffect.GetDataById(id);
if (Cfg == null)
{
Debug.LogError("不存在特效ID =" + ID);
return;
}
GameObject go = GTPoolManager.Instance.GetObject(Cfg.Path);
if (go == null)
{
go = new GameObject(ID.ToString());
}
this.CacheTransform = go.transform;
NGUITools.SetLayer(go, GTLayer.LAYER_EFFECT);
this.CacheTransform.parent = this.Parent != null ? Parent : null;
this.CacheTransform.localScale = data.Scale;
this.CacheTransform.localEulerAngles = data.Euler;
this.CacheTransform.localPosition = data.Pos;
this.TriggerObject = go.GET <ETriggerObject>();
}
public void TestPointRotation1()
{
KVector2 point = new KVector2(1, 0);
KTransform tx = new KTransform(KVector2.Zero, (float)(System.Math.PI / 2.0), new KVector2(1));
Assert.AreEqual(new KVector2(0, -1), tx.TransformPointWL(point));
}
public Character AddMainPlayer(KTransform bornData)
{
XCharacter data = RoleModule.Instance.GetMainPlayer();
Main = AddActor(data.Id, EBattleCamp.A, EActorType.PLAYER, bornData, data, true);
return(Main);
}
protected override bool Trigger()
{
base.Trigger();
if (World)
{
Transform p = Skill.Caster.Avatar.GetBindTransform(CasterBind);
Unit = GTWorld.Instance.Ect.LoadEffect(ID, 0, Retain);
Unit.CacheTransform.parent = p;
Unit.CacheTransform.localPosition = Offset;
Unit.CacheTransform.localEulerAngles = Euler;
Unit.CacheTransform.parent = null;
Unit.CacheTransform.localScale = Scale;
Unit.CacheTransform.localEulerAngles = Euler + Skill.Caster.Euler;
}
else
{
Transform p = Skill.Caster.Avatar.GetBindTransform(CasterBind);
Unit = GTWorld.Instance.Ect.LoadEffect(ID, 0, KTransform.Create(Offset, Euler, Scale), p, Retain);
}
for (int i = 0; i < Children.Count; i++)
{
Children[i].ApplyCenter = Unit.CacheTransform;
Children[i].ApplyHitPoint = Unit.Pos;
Children[i].ApplyHitDir = Vector3.zero;
}
Unit.Release(Duration);
return(true);
}
public Character AddNpc(int id, KTransform bornData)
{
Character cc = AddActorNoneSync(id, EBattleCamp.C, EActorType.NPC, bornData);
cc.EnableAI(true);
return(cc);
}
public void TestDir1()
{
KVector2 dir = new KVector2(1, 0);
KTransform tx = new KTransform(KVector2.Zero, 0, new KVector2(5, 4));
Assert.AreEqual(new KVector2(5, 0), tx.TransformDirLW(dir));
}
public void TestNormal()
{
KVector2 dir = new KVector2(1, 0);
KTransform tx = new KTransform(KVector2.Zero, (float)(System.Math.PI), new KVector2(5));
Assert.AreEqual(tx.TransformNormalLW(dir), new KVector2(-1, 0));
}
public void TestWorldToLocal()
{
KVector2 point = new KVector2(31, -4);
KTransform tx = new KTransform(KVector2.One, (System.Math.PI / 2.0), new KVector2(5));
Assert.AreEqual(new KVector2(-1, -6), tx.TransformPointWL(point));
}
public void TestLocalToWorld()
{
KVector2 point = new KVector2(-1, -6);
KTransform tx = new KTransform(KVector2.One, (System.Math.PI / 2), new KVector2(5));
Assert.AreEqual(new KVector2(-29, 6), tx.TransformPointLW(point));
}
public void TestDir()
{
KVector2 dir = new KVector2(1, 0);
KTransform tx = new KTransform(KVector2.Zero, (float)(System.Math.PI), new KVector2(5));
Assert.AreEqual(new KVector2(-5, 0), tx.TransformDirLW(dir));
}
public void TestOverlapSquareAndTrangle1()
{
KTransform t = new KTransform(KVector2.Zero, 0, KVector2.One);
KVertices vA = new KVertices()
{
new KVector2(0f, 0f + 2),
new KVector2(1f, -2f + 2),
new KVector2(-1f, -2f + 2),
};
KVertices vB = new KVertices()
{
new KVector2(0.5f, 0.5f),
new KVector2(0.5f, -0.5f),
new KVector2(-0.5f, -0.5f),
new KVector2(-0.5f, 0.5f),
};
vA.Reverse();
vB.Reverse();
Rigidbody sqr = BodyFactory.CreatePolygon(t, new MassData(1, 1), vB);
Rigidbody tri = BodyFactory.CreatePolygon(t, new MassData(1, 1), vA);
Fixture fA = new Fixture(sqr, sqr.Colliders[0]);
Fixture fB = new Fixture(tri, tri.Colliders[0]);
Contact c = new Contact(fA, fB);
Assert.AreEqual(CollisionDetection.Collision(ref c), true);
}
public void TestPointTranslation()
{
KVector2 point = new KVector2(2, 3);
KTransform tx = new KTransform(new KVector2(-5, -2), 0, new KVector2(1));
Assert.AreEqual(new KVector2(-3, 1), tx.TransformPointLW(point));
}
public void TestPointScale()
{
KVector2 point = new KVector2(1, 0);
KTransform tx = new KTransform(KVector2.Zero, 0, new KVector2(5));
Assert.AreEqual(new KVector2(5, 0), tx.TransformPointLW(point));
}
private void ShowModel()
{
if (mPlayer != null)
{
CharacterManager.Instance.DelActor(mPlayer);
}
KTransform param = KTransform.Default;
DRole roleDB = mRoleDBList[mRoleIndex];
int id = roleDB.Id;
mPlayer = CharacterManager.Instance.AddRole(id, param);
mPlayer.EnableCharacter(false);
mPlayer.EnableRootMotion(false);
mPlayer.Action.Play("idle");
if (roleDB.DisplayWeapon > 0)
{
mPlayer.Avatar.ChangeAvatar(8, roleDB.DisplayWeapon);
}
mPlayer.CacheTransform.localPosition = mRoleModelPos;
mPlayer.CacheTransform.localEulerAngles = mRoleModelEuler;
GameObject go = mPlayer.Obj;
go.transform.position = mRoleModelPos;
go.transform.eulerAngles = mRoleModelEuler;
go.SetActive(true);
}
public EffectUnit LoadEffect(int id, ulong guid, KTransform data, Transform parent, bool retain = true)
{
EffectUnit tab = new EffectUnit(id, guid, data, parent, retain);
Effects[tab.GUID] = tab;
return(tab);
}
public static KTransform Create(XTransform data)
{
KTransform d = new KTransform();
d.Pos = new Vector3(data.Pos.x, data.Pos.y, data.Pos.z);
d.Euler = new Vector3(data.Forward.x, data.Forward.y, data.Forward.z);
d.Scale = Vector3.one;
return(d);
}
//FIXME: Bad CircleVsCircle test
private static bool CircleVsCircle(ref Contact contact)
{
Circle a = (Circle)contact.FixtureA.Collider;
Circle b = (Circle)contact.FixtureB.Collider;
//In the local worl A is a unit circle and B is an ellipse
KVector2 cB = a.Transform.TransformPointWL(b.Transform.TransformPointLW(b.LPosition));
KVector2 axisA = a.Transform.TransformDirWL(b.Transform.TransformDirLW(KVector2.XPos));
KVector2 axisB = a.Transform.TransformDirWL(b.Transform.TransformDirLW(KVector2.YPos));
KTransform kTransform = new KTransform(cB, a.Transform.Rotation + b.Transform.Rotation, KVector2.One);
KVector2 P = kTransform.TransformPointWL(a.LPosition);
double t = Math.PI / 4f;
KVector2 scale = new KVector2(axisA.Length(), axisB.Length());
KVector2 potCp = new KVector2();
for (int i = 0; i < 50; i++)
{
potCp = new KVector2(scale.X * Math.Cos(t), scale.Y * Math.Sin(t));
double ex = (scale.X * scale.X) - (scale.Y * scale.Y) * Math.Pow(Math.Cos(t), 3) / scale.X;
double ey = (scale.Y * scale.Y) - (scale.X * scale.X) * Math.Pow(Math.Sin(t), 3) / scale.Y;
KVector2 e = new KVector2(ex, ey);
KVector2 r = potCp - e;
KVector2 q = P - e;
double delta_c = r.Length() * Math.Asin((r.X * q.Y - r.Y * q.X) / (r.Length() * q.Length()));
double delta_t = delta_c / Math.Sqrt(scale.LengthSquared() - potCp.LengthSquared());
t += delta_t;
t += Math.Min(Math.PI / 2, Math.Max(0, t));
}
KVector2 wPos = a.Transform.TransformPointLW(kTransform.TransformPointLW(potCp));
KVector2 cDir = P - potCp;
KVector2 wDir = b.Transform.TransformDirLW(KVector2.Normalize(cDir) * (1 - cDir.Length()));
if (wDir.Length() >= 1)
{
return(false);
}
ContactPoint cp = new ContactPoint
{
WPosition = wPos,
WPenetration = wDir.Length()
};
contact.Manifold.WNormal = KVector2.Normalize(wDir);
contact.Manifold.ContactPoints[0] = cp;
contact.Manifold.Count = 1;
return(true);
}
IEnumerator AddNpc()
{
for (int i = 0; i < m_Config.Npcs.Count; i++)
{
LvlNpc data = m_Config.Npcs[i];
CharacterManager.Instance.AddNpc(data.Id, KTransform.Create(data.Pos, data.Euler, data.Scale));
yield return(null);
}
}
public static KTransform Create(Vector3 pos, Vector3 angle, Vector3 scale)
{
KTransform data = new KTransform();
data.Pos = pos;
data.Euler = angle;
data.Scale = scale;
return(data);
}
private void InitModel()
{
KTransform param = KTransform.Create(Vector3.zero, Vector3.zero);
Camera camera = GTCameraManager.Instance.MainCamera;
camera.transform.position = new Vector3(0.2214f, 1.5794f, 41.2714f);
camera.transform.eulerAngles = new Vector3(-23.7111f, -179.525f, 0.01245f);
camera.fieldOfView = 46.6f;
camera.renderingPath = RenderingPath.DeferredLighting;
}
IEnumerator AddMonster()
{
for (int i = 0; i < m_Config.Monsters.Count; i++)
{
LvlMonster mm = m_Config.Monsters[i];
KTransform bd = KTransform.Create(mm.Pos, mm.Euler);
CharacterManager.Instance.AddMonster(mm.Id, bd);
yield return(null);
}
}
public void TestFindIncidentFace1()
{
KTransform t1 = new KTransform(KVector2.Zero, 0, KVector2.One);
KTransform t2 = new KTransform(KVector2.Zero, 0f, KVector2.One);
KVertices vA = new KVertices()
{
new KVector2(0f, .5f),
new KVector2(1f, 2f),
new KVector2(-1f, 2f),
};
KVertices vB = new KVertices()
{
new KVector2(-1, -1),
new KVector2(1, -1),
new KVector2(1, 1),
new KVector2(-1, 1),
};
Polygon a = new Polygon(vA);
a.Transform = t1;
Polygon b = new Polygon(vB);
b.Transform = t2;
CollisionDetection.SeparationSAT(a, b, out int indexA, out double separationA);
CollisionDetection.SeparationSAT(b, a, out int indexB, out double separationB);
Polygon refPoly;
Polygon incidentPoly;
Face refFace;
Face incidentFace;
if (separationB > separationA + Config.EpsilonsFloat)
{
refPoly = b;
refFace = b.ComputeFace(indexB);
incidentPoly = a;
CollisionDetection.FindIncidentFace(incidentPoly, -refFace.WNormal, indexA, out incidentFace);
}
else
{
refPoly = a;
refFace = a.ComputeFace(indexA);
incidentPoly = b;
CollisionDetection.FindIncidentFace(incidentPoly, -refFace.WNormal, indexB, out incidentFace);
}
//Assert.AreEqual(new KVector2(-2, 3), output[0]);
//Assert.AreEqual(new KVector2(0.5f, 0.5f), output[1]);
}
public Rigidbody(List <Collider> shapes, MassData massData, KTransform transform)
{
State = new State
{
Transform = transform
};
Colliders = shapes;
MassData = massData;
MassData.ComputeCenterOfMass(Colliders);
Materiel = new PhysicMateriel(0.5f, 1f);
}
public Character AddActor(int id, EBattleCamp camp, EActorType type, KTransform bornData, XCharacter data, bool isMain = false)
{
Character cc = new Character(id, GTGUID.NewGUID(), type, camp, isMain);
bornData.Pos = GTTools.NavSamplePosition(bornData.Pos);
cc.Load(bornData);
cc.SyncData(data, ESyncDataType.TYPE_ALL);
cc.CacheTransform.parent = transform;
Characters.Add(cc);
return(cc);
}
public State()
{
Transform = new KTransform();
Velocity = KVector2.Zero;
ForcesAccumulate = KVector2.Zero;
AngVelocity = 0f;
TorquesAccumulate = 0f;
ForceGenerators = new Dictionary <string, IForceGenerator>();
}
public void TestLWAndWL()
{
KTransform tx = new KTransform(KVector2.Zero, (float)(System.Math.PI / 2.0), new KVector2(1));
KTransform.ComputeLocalToWorld(tx, out KMatrix3x3Opti A);
KTransform.ComputeWorldToLocal(tx, out KMatrix3x3Opti IA);
KMatrix3x3Opti mat = (A * IA);
Assert.IsTrue((A * IA).IsIdentity);
}
public static Rigidbody CreateRectangleBody(KTransform tx, MassData massData, float hWidth, float hHeight)
{
KVertices rect = new KVertices
{
new KVector2(-hWidth, -hHeight),
new KVector2(-hWidth, hHeight),
new KVector2(hWidth, hHeight),
new KVector2(hWidth, -hHeight)
};
return(new Rigidbody(new Polygon(rect), massData, tx));
}
IEnumerator DoSummon()
{
for (int i = 0; i < Count; i++)
{
yield return(new WaitForSeconds(Interval));
Vector3 bornPoint = GTTools.RandomOnCircle(Skill.Caster.Pos, MinRadius, MaxRadius);
Vector3 bornEuler = Vector3.zero;
KTransform kt = KTransform.Create(bornPoint, bornEuler);
CharacterManager.Instance.AddActorNoneSync(Id, Skill.Caster.Camp, ActorType, kt);
}
}
IEnumerator AddMainPlayer()
{
int id = GTGlobal.CurPlayerID;
if (m_Config.A == null)
{
yield break;
}
KTransform bornData = KTransform.Create(m_Config.A.Pos, m_Config.A.Euler);
CharacterManager.Instance.AddMainPlayer(bornData);
yield return(null);
}
