public void SetAttackVisibility(ParamData.AtkParam atk, bool visible, NewChrAsm asm, int dummyPolyOverride,
ParamData.AtkParam.DummyPolySource defaultDummyPolySource)
{
if (dummyPolyOverride >= 0)
{
var fakeHitRadius = atk.Hits[0].Radius;
var fakeHitType = atk.Hits[0].HitType;
var fakeHit = new ParamData.AtkParam.Hit()
{
DmyPoly1 = (short)dummyPolyOverride,
DmyPoly2 = -1,
Radius = fakeHitRadius,
HitType = fakeHitType,
};
ShowAttackOnDummyPoly(atk, dummyPolyOverride);
SetHitVisibility(fakeHit, visible);
}
else
{
bool isFirstValidDmyPoly = true;
for (int i = 0; i < atk.Hits.Length; i++)
{
int dmyPoly1 = atk.Hits[i].DmyPoly1;
if (dmyPoly1 == -1)
{
continue;
}
var dmyPolySrcToUse = defaultDummyPolySource;
if (atk.HitSourceType == 1)
{
dmyPolySrcToUse = ParamData.AtkParam.DummyPolySource.Body;
}
if (visible && isFirstValidDmyPoly && dmyPoly1 != -1)
{
if (asm != null)
{
var dummyPolySrcOfAtk = atk.Hits[i].GetDmyPoly1SpawnPlace(asm, dmyPolySrcToUse);
dummyPolySrcOfAtk.ShowAttackOnDummyPoly(atk, dmyPoly1 % 1000);
}
else
{
ShowAttackOnDummyPoly(atk, dmyPoly1);
}
isFirstValidDmyPoly = false;
}
var actualHit = atk.Hits[i];
actualHit.DummyPolySourceSpawnedOn = dmyPolySrcToUse;
SetHitVisibility(actualHit, visible);
}
}
}
private void AddNewHitPrim(ParamData.AtkParam.Hit hit, ParamData.AtkParam.DummyPolySource dmyFilter, bool visible = false, bool dontUpdate = false)
{
if (!HitPrims.ContainsKey(hit))
{
HitPrims.Add(hit, new List <IDbgPrim>());
}
if (!HitFilters.ContainsKey(hit))
{
HitFilters.Add(hit, dmyFilter);
}
else
{
HitFilters[hit] = dmyFilter;
}
if (hit.IsCapsule)
{
HitPrims[hit].Add(new DbgPrimWireCapsule(hit.GetColor())
{
EnableDraw = visible,
Category = DbgPrimCategory.DummyPolyHelper,
//OverrideColor = hit.GetColor(),
});
}
else
{
if (DummyPolyByRefID.ContainsKey(hit.DmyPoly1))
{
foreach (var dmy in DummyPolyByRefID[hit.DmyPoly1])
{
HitPrims[hit].Add(new DbgPrimWireSphere(new Transform(Matrix.CreateScale(hit.Radius) *
dmy.ReferenceMatrix), Color.White)
{
EnableDraw = visible,
Category = DbgPrimCategory.DummyPolyHelper,
OverrideColor = hit.GetColor(),
});
}
}
}
lock (_lock_everything_monkaS)
{
if (visible && !VisibleHitsToHideForHideAll.Contains(hit))
{
VisibleHitsToHideForHideAll.Enqueue(hit);
}
if (!dontUpdate)
{
UpdateHitPrim(hit);
}
}
}
private void CreateHitboxPrimitive(ParamData.AtkParam atkParam, ParamData.AtkParam.Hit hit, Color c, string primText, bool showText)
{
lock (_lock_hitboxes)
{
if (!HitboxPrimitiveInfos.ContainsKey(atkParam))
{
HitboxPrimitiveInfos.Add(atkParam, new HitboxPrimInfo());
}
//if (MODEL.IS_PLAYER)
//{
// hit.ShiftDmyPolyIDIntoPlayerWpnDmyPolyID(HitboxPrimitiveInfos[atkParam].IsLeftHandAtk || IsViewingLeftHandHit);
//}
//if (hit.DmyPoly1 == -1 && hit.DmyPoly2 == -1)
// return;
if (hit.IsCapsule)
{
var capsule = new DbgPrimWireCapsule(12, c)
{
Category = DbgPrimCategory.DummyPolyHelper,
EnableDraw = false,
OverrideColor = c,
Name = showText ? primText : "",
EnableNameDraw = false,
NameColor = c,
};
MODEL.DbgPrimDrawer.AddPrimitive(capsule);
HitboxPrimitiveInfos[atkParam].Primitives.Add(capsule);
}
else
{
var sphere = new DbgPrimWireSphere(Transform.Default, 1, 12, 12, Color.White)
{
Category = DbgPrimCategory.DummyPolyHelper,
EnableDraw = false,
OverrideColor = c,
Name = showText ? primText : "",
EnableNameDraw = false,
NameColor = c,
};
MODEL.DbgPrimDrawer.AddPrimitive(sphere);
HitboxPrimitiveInfos[atkParam].Primitives.Add(sphere);
}
}
}
public void SetHitVisibility(ParamData.AtkParam.Hit hit, bool visible)
{
lock (_lock_everything_monkaS)
{
if (HitPrims.ContainsKey(hit))
{
foreach (var prim in HitPrims[hit])
{
prim.EnableDraw = visible;
}
}
else
{
AddNewHitPrim(hit, visible);
}
if (visible && !VisibleHitsToHideForHideAll.Contains(hit))
{
VisibleHitsToHideForHideAll.Enqueue(hit);
}
}
}
//private Dictionary<ParamData.AtkParam.Hit, ParamData.AtkParam.DummyPolySource> HitFilters
// = new Dictionary<ParamData.AtkParam.Hit, ParamData.AtkParam.DummyPolySource>();
//private Dictionary<DummyPolyBladeSFX, ParamData.AtkParam.DummyPolySource> BladeSfxHitFilters
// = new Dictionary<DummyPolyBladeSFX, ParamData.AtkParam.DummyPolySource>();
private void UpdateHitPrim(ParamData.AtkParam.Hit hit)
{
lock (_lock_everything_monkaS)
{
var dmyA = hit.GetDmyPoly1Locations(MODEL, hit.DummyPolySourceSpawnedOn);
var dmyB = hit.GetDmyPoly2Locations(MODEL, hit.DummyPolySourceSpawnedOn);
if (hit.IsCapsule)
{
((DbgPrimWireCapsule)HitPrims[hit][0]).UpdateCapsuleEndPoints(Vector3.Transform(Vector3.Zero, dmyA[0]), Vector3.Transform(Vector3.Zero, dmyB[0]), hit.Radius);
}
else
{
if (dmyA.Count > HitPrims[hit].Count)
{
AddNewHitPrim(hit, dontUpdate: true);
}
for (int i = 0; i < Math.Min(HitPrims[hit].Count, dmyA.Count); i++)
{
Matrix m = dmyA[i];
Quaternion q = Quaternion.CreateFromRotationMatrix(m);
Matrix rm = Matrix.CreateFromQuaternion(Quaternion.Normalize(q));
Matrix tm = Matrix.CreateTranslation(Vector3.Transform(Vector3.Zero, m));
HitPrims[hit][i].Transform = new Transform(Matrix.CreateScale(hit.Radius) * rm * tm);
}
}
for (int i = 0; i < HitPrims[hit].Count; i++)
{
HitPrims[hit][i].OverrideColor = hit.GetColor();
}
}
}
private void UpdateHitPrim(ParamData.AtkParam.Hit hit)
{
lock (_lock_everything_monkaS)
{
int dmyPoly1 = hit.DmyPoly1;
int dmyPoly2 = hit.DmyPoly2;
var filter = ParamData.AtkParam.DummyPolySource.Body;
if (HitFilters.ContainsKey(hit))
{
dmyPoly1 = hit.GetFilteredDmyPoly1(HitFilters[hit]);
dmyPoly2 = hit.GetFilteredDmyPoly2(HitFilters[hit]);
filter = HitFilters[hit];
}
if (hit.IsCapsule)
{
if (DummyPolyByRefID.ContainsKey(dmyPoly1) && DummyPolyByRefID.ContainsKey(dmyPoly2))
{
Vector3 pointA = Vector3.Transform(Vector3.Zero, DummyPolyByRefID[dmyPoly1][0].CurrentMatrix);
Vector3 pointB = Vector3.Transform(Vector3.Zero, DummyPolyByRefID[dmyPoly2][0].CurrentMatrix);
((DbgPrimWireCapsule)HitPrims[hit][0]).UpdateCapsuleEndPoints(pointA, pointB, hit.Radius);
}
else
{
((DbgPrimWireCapsule)HitPrims[hit][0]).UpdateCapsuleEndPoints(Vector3.Zero, Vector3.Zero, hit.Radius);
}
}
else
{
if (dmyPoly1 == -1 || hit.Radius == 0)
{
for (int i = 0; i < HitPrims[hit].Count; i++)
{
HitPrims[hit][i].Transform = new Transform(Matrix.CreateScale(hit.Radius));
}
}
else if (DummyPolyByRefID.ContainsKey(dmyPoly1))
{
if (DummyPolyByRefID[dmyPoly1].Count != HitPrims[hit].Count)
{
AddNewHitPrim(hit, filter, false, dontUpdate: true);
}
for (int i = 0; i < Math.Min(HitPrims[hit].Count, DummyPolyByRefID[dmyPoly1].Count); i++)
{
Matrix m = DummyPolyByRefID[dmyPoly1][i].CurrentMatrix;
Quaternion q = Quaternion.CreateFromRotationMatrix(m);
Matrix rm = Matrix.CreateFromQuaternion(q);
Matrix tm = Matrix.CreateTranslation(Vector3.Transform(Vector3.Zero, m));
HitPrims[hit][i].Transform = new Transform(Matrix.CreateScale(hit.Radius) * rm * tm);
}
}
else
{
for (int i = 0; i < HitPrims[hit].Count; i++)
{
HitPrims[hit][i].Transform = new Transform(Matrix.CreateScale(hit.Radius));
}
}
}
}
}
