614 lines
12 KiB
C#
614 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Linq;
|
|
using System.IO;
|
|
|
|
namespace _2DGAMELIB
|
|
{
|
|
[Serializable]
|
|
public class Obj
|
|
{
|
|
public string Tag = "";
|
|
|
|
public OrderedDictionary<string, Difs> Difss = new OrderedDictionary<string, Difs>();
|
|
|
|
private Difs r;
|
|
|
|
private JointsD jsd;
|
|
|
|
public IEnumerable<string> Keys => Difss.Keys;
|
|
|
|
public IEnumerable<Difs> Values => Difss.Values;
|
|
|
|
public Difs this[string Name]
|
|
{
|
|
get
|
|
{
|
|
return Difss[Name];
|
|
}
|
|
set
|
|
{
|
|
Difss[Name] = value;
|
|
}
|
|
}
|
|
|
|
public Difs this[int Index]
|
|
{
|
|
get
|
|
{
|
|
return Difss[Index];
|
|
}
|
|
set
|
|
{
|
|
Difss[Index] = value;
|
|
}
|
|
}
|
|
|
|
public double PositionSize
|
|
{
|
|
set
|
|
{
|
|
foreach (Difs value2 in Difss.Values)
|
|
{
|
|
value2.PositionSize = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public Vector2D PositionVector
|
|
{
|
|
set
|
|
{
|
|
foreach (Difs value2 in Difss.Values)
|
|
{
|
|
value2.PositionVector = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public double AngleBase
|
|
{
|
|
set
|
|
{
|
|
foreach (Difs value2 in Difss.Values)
|
|
{
|
|
value2.AngleBase = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public double AngleCont
|
|
{
|
|
set
|
|
{
|
|
foreach (Difs value2 in Difss.Values)
|
|
{
|
|
value2.AngleCont = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public double SizeBase
|
|
{
|
|
set
|
|
{
|
|
foreach (Difs value2 in Difss.Values)
|
|
{
|
|
value2.SizeBase = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public double SizeCont
|
|
{
|
|
set
|
|
{
|
|
foreach (Difs value2 in Difss.Values)
|
|
{
|
|
value2.SizeCont = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public double SizeXBase
|
|
{
|
|
set
|
|
{
|
|
foreach (Difs value2 in Difss.Values)
|
|
{
|
|
value2.SizeXBase = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public double SizeXCont
|
|
{
|
|
set
|
|
{
|
|
foreach (Difs value2 in Difss.Values)
|
|
{
|
|
value2.SizeXCont = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public double SizeYBase
|
|
{
|
|
set
|
|
{
|
|
foreach (Difs value2 in Difss.Values)
|
|
{
|
|
value2.SizeYBase = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public double SizeYCont
|
|
{
|
|
set
|
|
{
|
|
foreach (Difs value2 in Difss.Values)
|
|
{
|
|
value2.SizeYCont = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool Dra
|
|
{
|
|
set
|
|
{
|
|
foreach (Difs value2 in Difss.Values)
|
|
{
|
|
value2.Dra = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool Hit
|
|
{
|
|
set
|
|
{
|
|
foreach (Difs value2 in Difss.Values)
|
|
{
|
|
value2.Hit = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public Difs JoinRoot => r;
|
|
public IEnumerable<Par> EnumAllPar()
|
|
{
|
|
foreach (Difs value in Difss.Values)
|
|
{
|
|
foreach (Par item in value.EnumAllPar())
|
|
{
|
|
yield return item;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SetDefault()
|
|
{
|
|
foreach (Difs value in Difss.Values)
|
|
{
|
|
value.SetDefault();
|
|
}
|
|
}
|
|
|
|
public Obj SetDefaultR()
|
|
{
|
|
foreach (Difs value in Difss.Values)
|
|
{
|
|
value.SetDefault();
|
|
}
|
|
return this;
|
|
}
|
|
|
|
public Obj()
|
|
{
|
|
}
|
|
|
|
public Obj(Obj Obj)
|
|
{
|
|
Copy(Obj);
|
|
}
|
|
|
|
private void Copy(Obj Obj)
|
|
{
|
|
Tag = Obj.Tag;
|
|
foreach (string key in Obj.Difss.Keys)
|
|
{
|
|
Difss.Add(key, new Difs(Obj.Difss[key]));
|
|
}
|
|
}
|
|
|
|
public void Add(string Name, Difs Difs)
|
|
{
|
|
Difss.Add(Name, Difs);
|
|
}
|
|
|
|
public void Add(Difs Difs)
|
|
{
|
|
Difss.Add(Difs.Tag, Difs);
|
|
}
|
|
|
|
public void Insert(int Index, string Name, Difs Difs)
|
|
{
|
|
Difss.Insert(Index, Name, Difs);
|
|
}
|
|
|
|
public void Remove(string Name)
|
|
{
|
|
Difss.Remove(Name);
|
|
}
|
|
|
|
public void Draw(Are Are)
|
|
{
|
|
foreach (Difs value in Difss.Values)
|
|
{
|
|
value.Draw(Are);
|
|
}
|
|
}
|
|
|
|
public void Draws(Are Are)
|
|
{
|
|
foreach (Difs value in Difss.Values)
|
|
{
|
|
value.Draws(Are);
|
|
}
|
|
}
|
|
|
|
public void Draw(AreM AreM)
|
|
{
|
|
foreach (Difs value in Difss.Values)
|
|
{
|
|
value.Draw(AreM);
|
|
}
|
|
}
|
|
|
|
public void Draws(AreM AreM)
|
|
{
|
|
foreach (Difs value in Difss.Values)
|
|
{
|
|
value.Draws(AreM);
|
|
}
|
|
}
|
|
|
|
private Difs GetJoinRootDifs()
|
|
{
|
|
Difs[] array = Difss.Values.ToArray();
|
|
if (array.Length <= 1)
|
|
{
|
|
return array.FirstOrDefault();
|
|
}
|
|
Par[] pa = EnumAllPar().ToArray();
|
|
Difs[] array2 = array;
|
|
Vector2D p;
|
|
foreach (Difs difs in array2)
|
|
{
|
|
if (difs.EnumJoinRoot.All(delegate(Par p0)
|
|
{
|
|
p = p0.Position;
|
|
return pa.All((Par p1) => p0 == p1 || p1.JP.All((Joi j) => !(p1.ToGlobal(j.Joint).DistanceSquared(p) <= Join.IdentityDistance)));
|
|
}))
|
|
{
|
|
return difs;
|
|
}
|
|
}
|
|
return array.First();
|
|
}
|
|
|
|
public void SetJoints()
|
|
{
|
|
Difs[] array = Difss.Values.ToArray();
|
|
Difs[] array2 = array;
|
|
for (int i = 0; i < array2.Length; i++)
|
|
{
|
|
array2[i].SetJoints();
|
|
}
|
|
r = GetJoinRootDifs();
|
|
if (r != null)
|
|
{
|
|
jsd = r.GetJointsD(array);
|
|
}
|
|
}
|
|
|
|
public void SetJoints(string Name)
|
|
{
|
|
Difs[] array = Difss.Values.ToArray();
|
|
Difs[] array2 = array;
|
|
for (int i = 0; i < array2.Length; i++)
|
|
{
|
|
array2[i].SetJoints();
|
|
}
|
|
r = Difss[Name];
|
|
if (r != null)
|
|
{
|
|
jsd = r.GetJointsD(array);
|
|
}
|
|
}
|
|
|
|
public void JoinP()
|
|
{
|
|
if (r != null)
|
|
{
|
|
r.JoinPA();
|
|
jsd.JoinP();
|
|
}
|
|
}
|
|
|
|
public void JoinPA()
|
|
{
|
|
if (r != null)
|
|
{
|
|
r.JoinPA();
|
|
jsd.JoinPA();
|
|
}
|
|
}
|
|
|
|
public void JoinPall()
|
|
{
|
|
if (r != null)
|
|
{
|
|
r.JoinPA();
|
|
jsd.JoinPall();
|
|
}
|
|
}
|
|
|
|
public void JoinPAall()
|
|
{
|
|
if (r != null)
|
|
{
|
|
r.JoinPA();
|
|
jsd.JoinPAall();
|
|
}
|
|
}
|
|
|
|
public HashSet<string> GetHitDifsTagsCur(ref Color HitColor)
|
|
{
|
|
HashSet<string> hashSet = new HashSet<string>();
|
|
foreach (Difs value in Values)
|
|
{
|
|
if (value.Current.IsHit(ref HitColor))
|
|
{
|
|
hashSet.Add(value.Tag);
|
|
}
|
|
}
|
|
return hashSet;
|
|
}
|
|
|
|
public List<Difs> GetHitDifssCur(ref Color HitColor)
|
|
{
|
|
List<Difs> list = new List<Difs>();
|
|
foreach (Difs value in Values)
|
|
{
|
|
if (value.Current.IsHit(ref HitColor))
|
|
{
|
|
list.Add(value);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public HashSet<string> GetHitParTagsCur(ref Color HitColor)
|
|
{
|
|
HashSet<string> hashSet = new HashSet<string>();
|
|
foreach (Difs value in Values)
|
|
{
|
|
foreach (string hitTag in value.Current.GetHitTags(ref HitColor))
|
|
{
|
|
hashSet.Add(hitTag);
|
|
}
|
|
}
|
|
return hashSet;
|
|
}
|
|
|
|
public List<Par> GetHitParsCur(ref Color HitColor)
|
|
{
|
|
List<Par> list = new List<Par>();
|
|
foreach (Difs value in Values)
|
|
{
|
|
list.AddRange(value.Current.GetHitPars(ref HitColor));
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public bool IsHitCur(ref Color HitColor)
|
|
{
|
|
foreach (Difs value in Values)
|
|
{
|
|
if (value.IsHit(ref HitColor))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public HashSet<string> GetHitDifsTags(ref Color HitColor)
|
|
{
|
|
HashSet<string> hashSet = new HashSet<string>();
|
|
foreach (Difs value in Values)
|
|
{
|
|
if (value.IsHit(ref HitColor))
|
|
{
|
|
hashSet.Add(value.Tag);
|
|
}
|
|
}
|
|
return hashSet;
|
|
}
|
|
|
|
public List<Difs> GetHitDifss(ref Color HitColor)
|
|
{
|
|
List<Difs> list = new List<Difs>();
|
|
foreach (Difs value in Values)
|
|
{
|
|
if (value.IsHit(ref HitColor))
|
|
{
|
|
list.Add(value);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public HashSet<string> GetHitParTags(ref Color HitColor)
|
|
{
|
|
HashSet<string> hashSet = new HashSet<string>();
|
|
foreach (Difs value in Values)
|
|
{
|
|
foreach (string hitTag in value.GetHitTags(ref HitColor))
|
|
{
|
|
hashSet.Add(hitTag);
|
|
}
|
|
}
|
|
return hashSet;
|
|
}
|
|
|
|
public List<Par> GetHitPars(ref Color HitColor)
|
|
{
|
|
List<Par> list = new List<Par>();
|
|
foreach (Difs value in Values)
|
|
{
|
|
list.AddRange(value.GetHitPars(ref HitColor));
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public bool IsHit(ref Color HitColor)
|
|
{
|
|
foreach (Difs value in Values)
|
|
{
|
|
if (value.IsHit(ref HitColor))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void Symmetrization(string[] Names)
|
|
{
|
|
Difs[] array = Difss.Values.ToArray();
|
|
Difs[] array2 = array;
|
|
for (int i = 0; i < array2.Length; i++)
|
|
{
|
|
array2[i].SetJoints();
|
|
}
|
|
JointsD jointsD = GetJoinRootDifs().GetJointsD(array);
|
|
foreach (string name in Names)
|
|
{
|
|
symmetrization(name, array, jointsD);
|
|
}
|
|
}
|
|
|
|
public void Symmetrization(string Name, string[] Names)
|
|
{
|
|
Difs[] array = Difss.Values.ToArray();
|
|
Difs[] array2 = array;
|
|
for (int i = 0; i < array2.Length; i++)
|
|
{
|
|
array2[i].SetJoints();
|
|
}
|
|
JointsD jointsD = Difss[Name].GetJointsD(array);
|
|
foreach (string name in Names)
|
|
{
|
|
symmetrization(name, array, jointsD);
|
|
}
|
|
}
|
|
|
|
private void symmetrization(string Name, Difs[] da, JointsD jsdb)
|
|
{
|
|
Difs difs = Difss[Name];
|
|
JointsD jointsD = difs.GetJointsD(da);
|
|
Difs difs2 = new Difs(difs);
|
|
difs2.SetJoints();
|
|
difs2.ReverseX();
|
|
TagReplace(difs2);
|
|
SetPos(difs2, GetSymPos(difs, jsdb) - difs2.CurJoinRoot.Position);
|
|
foreach (Pars item in difs2.EnumAllPars())
|
|
{
|
|
difs2.JoinP(item);
|
|
}
|
|
Difss.Add(difs2.Tag, difs2);
|
|
string key = null;
|
|
foreach (JointD join in jointsD.Joins)
|
|
{
|
|
difs2 = new Difs(join.Difs1);
|
|
difs2.SetJoints();
|
|
difs2.ReverseX();
|
|
TagReplace(difs2);
|
|
if (join.Difs0.Tag.Contains("左"))
|
|
{
|
|
key = join.Difs0.Tag.Replace("左", "右");
|
|
}
|
|
else if (join.Difs0.Tag.Contains("右"))
|
|
{
|
|
key = join.Difs0.Tag.Replace("右", "左");
|
|
}
|
|
Par par = Difss[key].Current.GetPar(join.Path0);
|
|
SetPos(difs2, par.ToGlobal(par.JP[join.Index].Joint) - difs2.CurJoinRoot.Position);
|
|
foreach (Pars item2 in difs2.EnumAllPars())
|
|
{
|
|
difs2.JoinP(item2);
|
|
}
|
|
Difss.Add(difs2.Tag, difs2);
|
|
}
|
|
}
|
|
|
|
private void TagReplace(Difs ds)
|
|
{
|
|
if (ds.Tag.Contains("左"))
|
|
{
|
|
ds.Tag = ds.Tag.Replace("左", "右");
|
|
}
|
|
else if (ds.Tag.Contains("右"))
|
|
{
|
|
ds.Tag = ds.Tag.Replace("右", "左");
|
|
}
|
|
}
|
|
|
|
private Vector2D GetSymPos(Difs r, JointsD jsdb)
|
|
{
|
|
JointD jointD = null;
|
|
foreach (JointD join in jsdb.Joins)
|
|
{
|
|
if (join.Difs1 == r)
|
|
{
|
|
jointD = join;
|
|
break;
|
|
}
|
|
}
|
|
Vector2D position = r.CurJoinRoot.Position;
|
|
Par par = jointD.Difs0.Current.GetPar(jointD.Path0);
|
|
Joi joi = par.JP[jointD.Index];
|
|
foreach (Joi item in par.JP)
|
|
{
|
|
Vector2D result = par.ToGlobal(item.Joint);
|
|
if (item != joi && System.Math.Abs(result.Y - position.Y) < 1E-06)
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
return Dat.Vec2DZero;
|
|
}
|
|
|
|
private void SetPos(Difs ds, Vector2D v)
|
|
{
|
|
foreach (Par item in ds.EnumAllPar())
|
|
{
|
|
item.PositionBase += v;
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
foreach (Difs value in Difss.Values)
|
|
{
|
|
value.Dispose();
|
|
}
|
|
}
|
|
}
|
|
}
|