public ITag ToJson(TagMaster json, object rawBox)
{
CollisionBox box = (CollisionBox)rawBox;
TagCompound obj = new TagCompound();
TagList rect = new TagList();
obj.AddProperty("bounds", rect);
rect.Add(box.X);
rect.Add(box.Y);
rect.Add(box.Width);
rect.Add(box.Height);
TagList faces = new TagList();
obj.AddProperty("faces", faces);
foreach (CollisionFaceProperties face in box.GetFaceProperties())
{
TagCompound faceObj = new TagCompound();
faces.Add(faceObj);
faceObj.AddProperty("enabled", face.Enabled);
faceObj.AddProperty("friction", face.Friction);
faceObj.AddProperty("snap", face.Snap);
}
return(obj);
}
public void ReloadTags()
{
Tags.Clear();
Tags.Add(new ComboBoxItem(@"", @""));
var tItems = new TagMaster().Query();
tItems.ForEach(row => { Tags.Add(new ComboBoxItem(row[0].ToString(), row[0].ToString())); });
}
public T FromJson <T>(TagMaster json, ITag value)
{
TagList list = (TagList)value;
byte r = ((TagByte)list[0]).Value;
byte g = ((TagByte)list[1]).Value;
byte b = ((TagByte)list[2]).Value;
byte a = ((TagByte)list[3]).Value;
return((T)Convert.ChangeType(Color.FromArgb(a, r, g, b), typeof(T)));
}
internal static ITag Parse(BinaryReader reader)
{
TagList arr = new TagList();
while (reader.ReadBoolean())
{
ITag value = TagMaster.ParseValue(reader);
arr.Add(value);
}
return(arr);
}
public K FromJson <K>(TagMaster json, ITag value)
{
if (value is TagString str)
{
return((K)Convert.ChangeType(str.Value, typeof(K)));
}
else
{
return(default(K));
}
}
public TagMaster Delete(int TagMasterId)
{
TagMaster tm = context.TagMaster.Find(TagMasterId);
if (tm != null)
{
context.TagMaster.Remove(tm);
context.SaveChanges();
}
return(tm);
}
public ITag ToJson(TagMaster json, object rawList)
{
IEnumerable <T> list = (IEnumerable <T>)rawList;
TagList arr = new TagList();
foreach (T t in list)
{
arr.Add(t);
}
return(arr);
}
internal static ITag Parse(BinaryReader reader)
{
TagCompound obj = new TagCompound();
while (reader.ReadBoolean())
{
string key = TagMaster.ReadString(reader);
ITag value = TagMaster.ParseValue(reader);
obj.AddProperty(key, value);
}
return(obj);
}
public ITag ToJson(TagMaster json, object obj)
{
Color color = (Color)obj;
TagList list = new TagList();
list.Add(new TagByte(color.R));
list.Add(new TagByte(color.G));
list.Add(new TagByte(color.B));
list.Add(new TagByte(color.A));
return(list);
}
public K FromJson <K>(TagMaster json, ITag value)
{
TagString str = value as TagString;
foreach (T o in typeof(T).GetEnumValues())
{
if (typeof(T).GetEnumName(o) == str.Value)
{
return((K)Convert.ChangeType(o, typeof(K)));
}
}
return(default(K));
}
public int Write(TagMaster json, BinaryWriter writer)
{
writer.Write(TypeId);
int size = 1;
foreach (ITag value in Content)
{
writer.Write(true);
size++;
size += value.Write(json, writer);
}
writer.Write(false);
size++;
return(size);
}
public void AddEditDel_Scrl_TagMaster(DO_TagMaster ObjScrl, TagMaster Flag)
{
SqlConnection conn = new SqlConnection();
SQLManager co = new SQLManager();
conn = co.GetConnection();
cmd = new SqlCommand("Scrl_AddEditDelTagMaster", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@FlagNo", SqlDbType.Int).Value = Flag;
cmd.Parameters.Add("@Id", SqlDbType.Int).Value = ObjScrl.Id;
cmd.Parameters.Add("@intTag", SqlDbType.Int).Value = ObjScrl.intTag;
cmd.ExecuteNonQuery();
co.CloseConnection(conn);
}
public int Write(TagMaster json, BinaryWriter writer)
{
writer.Write(TypeId);
int size = 1;
foreach (KeyValuePair <string, ITag> property in Properties)
{
writer.Write(true);
size++;
size += TagMaster.WriteString(property.Key, writer);
size += property.Value.Write(json, writer);
}
writer.Write(false);
size++;
return(size);
}
public K FromJson <K>(TagMaster json, ITag value)
{
TagList arr = value as TagList;
List <T> list = new List <T>();
foreach (ITag element in arr)
{
list.Add(json.ConvertFromValue <T>(element));
}
if (typeof(K).IsArray)
{
return((K)Convert.ChangeType(list.ToArray(), typeof(K)));
}
else
{
return((K)Convert.ChangeType(list, typeof(K)));
}
}
public void Resolve(TagMaster json)
{
foreach (KeyValuePair <string, ITag> property in Properties.ToList())
{
if (property.Value is TagCustom)
{
Properties[property.Key] = json.ConvertToValue(((TagCustom)property.Value).Value);
}
if (Properties[property.Key] is TagCompound)
{
((TagCompound)Properties[property.Key]).Resolve(json);
}
if (Properties[property.Key] is TagList)
{
((TagList)Properties[property.Key]).Resolve(json);
}
}
}
public T FromJson <T>(TagMaster json, ITag value)
{
TagCompound wrapper = (TagCompound)value;
int width = wrapper.Get <int>(json, "width");
int height = wrapper.Get <int>(json, "height");
TagList outer = wrapper.Get <TagList>("map");
bool[,] map = new bool[width, height];
for (int i = 0; i < width; i++)
{
TagList inner = (TagList)outer[i];
for (int j = 0; j < height; j++)
{
map[i, j] = ((TagBoolean)inner[j]).Value;
}
}
return((T)Convert.ChangeType(map, typeof(T)));
}
public DataTable GetDataTable(DO_TagMaster ObjScrl, TagMaster Flag)
{
DataTable dt = new DataTable();
SqlConnection conn = new SqlConnection();
SQLManager co = new SQLManager();
conn = co.GetConnection();
SqlDataAdapter da = new SqlDataAdapter("Scrl_AddEditDelTagMaster", conn);
da.SelectCommand.CommandType = CommandType.StoredProcedure;
da.SelectCommand.Parameters.Add("@FlagNo", SqlDbType.Int).Value = Flag;
da.SelectCommand.Parameters.Add("@Id", SqlDbType.Int).Value = ObjScrl.Id;
da.SelectCommand.Parameters.Add("@intTag", SqlDbType.Int).Value = ObjScrl.intTag;
da.Fill(dt);
co.CloseConnection(conn);
return(dt);
}
public K FromJson <K>(TagMaster json, ITag value)
{
switch (value)
{
case TagByte num: return((K)Convert.ChangeType(num.Value, typeof(K)));
case TagShort num: return((K)Convert.ChangeType(num.Value, typeof(K)));
case TagInt num: return((K)Convert.ChangeType(num.Value, typeof(K)));
case TagFloat num: return((K)Convert.ChangeType(num.Value, typeof(K)));
case TagLong num: return((K)Convert.ChangeType(num.Value, typeof(K)));
case TagDouble num: return((K)Convert.ChangeType(num.Value, typeof(K)));
default: return(default(K));
}
}
void Start()
{
// Application.targetFrameRate = 300;
Transform[] Objects = GetComponentsInChildren <Transform>();
foreach (Transform obj in Objects)
{
if (obj.CompareTag("tag_master"))
{
TagMaster agent = obj.GetComponent <TagMaster>();
Agents.Add(agent);
}
if (obj.CompareTag("scene"))
{
SceneController scene = obj.GetComponent <SceneController>();
sceneControllers.Add(scene);
}
}
}
public T FromJson <T>(TagMaster json, ITag value)
{
TagCompound obj = value as TagCompound;
CollisionBox box = new CollisionBox();
TagList bounds = obj.Get <TagList>("bounds");
box.X = (bounds[0] as TagDouble).Value;
box.Y = (bounds[1] as TagDouble).Value;
box.Width = (bounds[2] as TagDouble).Value;
box.Height = (bounds[3] as TagDouble).Value;
TagList faces = obj.Get <TagList>("faces");
box.TopFaceProperties = FaceFromJson(faces[0] as TagCompound);
box.RightFaceProperties = FaceFromJson(faces[1] as TagCompound);
box.BottomFaceProperties = FaceFromJson(faces[2] as TagCompound);
box.LeftFaceProperties = FaceFromJson(faces[3] as TagCompound);
return((T)Convert.ChangeType(box, typeof(T)));
}
public void Resolve(TagMaster json)
{
for (int i = 0; i < Content.Count; i++)
{
ITag tag = Content[i];
if (tag is TagCustom)
{
Content[i] = tag = json.ConvertToValue(((TagCustom)tag).Value);
}
if (tag is TagCompound)
{
((TagCompound)tag).Resolve(json);
}
if (tag is TagList)
{
((TagList)tag).Resolve(json);
}
}
}
public async Task <TagMasterViewModel> SaveTagMasterDetails(TagMasterViewModel tagMasterViewModel)
{
TagMaster tagMasterDatails = new TagMaster()
{
//TagId= tagMasterViewModel.TagId,
TagName = tagMasterViewModel.TagName,
Created_By = "aaaa",
Modified_By = "aaa",
Created_Date = DateTime.Today,
Modified_Date = DateTime.Today
};
var tagObj = await _tagMasterHelper.CreateAsync(tagMasterDatails);
TagMasterViewModel tagMasterDetailsViewModel = new TagMasterViewModel
{
TagId = Convert.ToInt32(tagObj.TagId)
};
return(tagMasterDetailsViewModel);
}
public T Get <T>(TagMaster json, string key)
{
if (!Properties.ContainsKey(key))
{
return(default(T));
}
ITag property = Properties[key];
if (property is T)
{
return((T)property);
}
else if (json != null)
{
return(json.ConvertFromValue <T>(property));
}
else
{
return(default(T));
}
}
public void attachToMaster(GameObject agent)
{
Agent = agent.GetComponent <TagMaster>();
// Debug.Log("Attach");
Rigidbody rbody = transform.gameObject.GetComponent <Rigidbody>();
rbody.constraints = RigidbodyConstraints.None;
hinge1 = transform.gameObject.AddComponent <HingeJoint>();
hinge1.anchor = hingeTransform.localPosition;
hinge1.axis = new Vector3(1f, 0f, 0f);
hinge1.autoConfigureConnectedAnchor = false;
hinge1.enableCollision = true;
hinge1.connectedAnchor = new Vector3(0f, 0.64f, 0f);
connector = Instantiate(Connector_model, hingeTransform.position, hingeTransform.rotation);
hinge1.connectedBody = connector.GetComponent <Rigidbody>();
hinge2 = connector.GetComponent <HingeJoint>();
hinge2.connectedBody = agent.GetComponent <Rigidbody>();
hinge2.autoConfigureConnectedAnchor = false;
hinge2.connectedAnchor = new Vector3(0f, 0.36f, -3.4f);
}
public ITag ToJson(TagMaster json, object obj)
{
bool[,] map = (bool[, ])obj;
TagCompound wrapper = new TagCompound();
int width = map.GetLength(0);
int height = map.GetLength(1);
wrapper.AddProperty("width", width);
wrapper.AddProperty("height", height);
TagList outer = new TagList();
wrapper.AddProperty("map", outer);
for (int i = 0; i < width; i++)
{
TagList inner = new TagList();
outer.Add(inner);
for (int j = 0; j < height; j++)
{
inner.Add(map[i, j]);
}
}
return(wrapper);
}
public ITag ToJson(TagMaster json, object raw)
{
TagCompound obj = new TagCompound();
foreach (PropertyInfo property in raw.GetType().GetProperties())
{
PersistentPropertyAttribute attr = property.GetCustomAttribute(typeof(PersistentPropertyAttribute), false) as PersistentPropertyAttribute;
if (attr == null)
{
continue;
}
string name = attr.KeyName ?? property.Name.ToSnakeCase();
object value = property.GetValue(raw);
if (value != null)
{
obj.AddProperty(name, value);
}
}
foreach (FieldInfo field in raw.GetType().GetFields())
{
PersistentPropertyAttribute attr = field.GetCustomAttribute(typeof(PersistentPropertyAttribute), false) as PersistentPropertyAttribute;
if (attr == null)
{
continue;
}
string name = attr.KeyName ?? field.Name.ToSnakeCase();
object value = field.GetValue(raw);
if (value != null)
{
obj.AddProperty(name, value);
}
}
return(obj);
}
public ITag ToJson(TagMaster json, object obj)
{
return(new TagString(typeof(T).GetEnumName(obj)));
}
public Scene Load()
{
if (!File.Exists(Path))
{
Console.WriteLine("Tried to load scene at '" + Path + "', does not exist");
return(null);
}
TagMaster tagMaster = new TagMaster();
tagMaster.RegisterConverter(new ListConverter <long>());
tagMaster.RegisterConverter(new ListConverter <int>());
tagMaster.RegisterConverter(new NumberConverter <byte>());
tagMaster.RegisterConverter(new NumberConverter <short>());
tagMaster.RegisterConverter(new NumberConverter <int>());
tagMaster.RegisterConverter(new NumberConverter <float>());
tagMaster.RegisterConverter(new NumberConverter <long>());
tagMaster.RegisterConverter(new NumberConverter <double>());
tagMaster.RegisterConverter(new StringConverter());
tagMaster.RegisterConverter(new BooleanConverter());
foreach (ITagConverter converter in Converters)
{
tagMaster.RegisterConverter(converter);
}
BinaryReader reader = new BinaryReader(new FileStream(Path, FileMode.Open));
TagCompound root = tagMaster.Read(reader);
reader.Close();
reader.Dispose();
Scene scene = new Scene(Controller);
TagCompound sceneRoot = root.Get <TagCompound>("scene");
scene.Name = sceneRoot.Get <string>(tagMaster, "name") ?? "";
scene.CurrentViewport = sceneRoot.Get <CameraView>(tagMaster, "viewport");
foreach (ITag rawEntity in sceneRoot.Get <TagList>("entities"))
{
TagCompound obj = rawEntity as TagCompound;
Entity entity = new Entity
{
_id = obj.Get <long>(tagMaster, "id"),
_is_id_set = true,
Name = obj.Get <TagString>("name").Value,
Active = obj.Get <TagBoolean>("active").Value
};
foreach (KeyValuePair <string, ITag> rawComponent in obj.Get <TagCompound>("components"))
{
Type componentType = Component.TypeForIdentifier(rawComponent.Key);
Component component = tagMaster.ConvertFromValue(rawComponent.Value, componentType) as Component;
entity.Components.Add(component);
}
scene.Entities.Add(entity);
}
foreach (ITag rawName in sceneRoot.Get <TagList>("systems"))
{
TagString name = rawName as TagString;
ComponentSystem system = ComponentSystem.TypeForIdentifier(name.Value).GetConstructor(new Type[0]).Invoke(new object[0]) as ComponentSystem;
scene.Systems.Add(system);
}
return(scene);
}
public void Save()
{
TagMaster tagMaster = new TagMaster();
tagMaster.RegisterConverter(new NumberConverter <byte>());
tagMaster.RegisterConverter(new NumberConverter <short>());
tagMaster.RegisterConverter(new NumberConverter <int>());
tagMaster.RegisterConverter(new NumberConverter <float>());
tagMaster.RegisterConverter(new NumberConverter <long>());
tagMaster.RegisterConverter(new NumberConverter <double>());
tagMaster.RegisterConverter(new StringConverter());
tagMaster.RegisterConverter(new ListConverter <long>());
tagMaster.RegisterConverter(new ListConverter <int>());
foreach (ITagConverter converter in Converters)
{
tagMaster.RegisterConverter(converter);
}
TagCompound root = new TagCompound();
TagCompound sceneRoot = new TagCompound();
root.AddProperty("scene", sceneRoot);
sceneRoot.AddProperty("name", Scene.Name);
sceneRoot.AddProperty("viewport", Scene.CurrentViewport);
{
TagList entities = new TagList();
sceneRoot.AddProperty("entities", entities);
foreach (Entity entity in Scene.Entities)
{
TagCompound entityObj = new TagCompound();
entities.Add(entityObj);
entityObj.AddProperty("name", entity.Name);
entityObj.AddProperty("id", entity.Id);
entityObj.AddProperty("active", entity.Active);
TagCompound components = new TagCompound();
entityObj.AddProperty("components", components);
foreach (Component component in entity.Components)
{
components.AddProperty(component.ComponentName, component);
}
}
}
{
TagList systems = new TagList();
sceneRoot.AddProperty("systems", systems);
foreach (ComponentSystem system in Scene.Systems)
{
if (system.ShouldSave)
{
systems.Add(system.SystemName);
}
}
}
BinaryWriter writer = new BinaryWriter(new FileStream(Path, FileMode.Create));
tagMaster.Write(root, writer);
writer.Close();
writer.Dispose();
}
public ITag ToJson(TagMaster json, object obj) => throw new NotImplementedException();
