private MachineElement FilterMachineElementsWithoutToolholder(MachineElement me)
{
MachineElement result = null;
var children = new List <MachineElement>();
if (me.Children != null && me.Children.Count > 0)
{
foreach (var item in me.Children)
{
var e = FilterMachineElementsWithoutToolholder(item);
if (e != null)
{
children.Add(e);
}
}
if (children.Count > 0)
{
result = me;
result.Children = children;
}
}
else if (me.ToolHolderType != MachineModels.Enums.ToolHolderType.None)
{
result = me;
}
return(result);
}
private MachineElementViewModel ToViewModel(MachineElement me)
{
MachineElementViewModel vm = null;
if (me != null)
{
if (me.ToolHolderType != MachineModels.Enums.ToolHolderType.None)
{
vm = new ToolHolderViewModel()
{
ToolHolderId = me.ToolHolderData.Id, ToolHolderType = me.ToolHolderType
};
}
else
{
vm = new MachineElementViewModel();
}
vm.Name = me.Name;
if (me.Children.Count > 0)
{
var children = new List <MachineElementViewModel>();
foreach (var item in me.Children)
{
children.Add(ToViewModel(item));
}
vm.Children = children;
}
}
return(vm);
}
void OnCollisionStay2D(Collision2D collision)
{
// Player
Greek zorba = collision.gameObject.GetComponent <Greek>();
if (zorba != null && state == GreekState.DASHING)
{
zorba.shock();
nextForce = Vector3.zero;
}
// Element
MachineElement element = collision.gameObject.GetComponent <MachineElement>();
if (element != null)
{
// thrown element ?
if (element.getState() == ElementState.THROWN)
{
if (element.getThrower() != this)
{
shock();
}
}
else if (possession == null && state != GreekState.SHOCKED)
{
element.setOwner(this);
possession = element;
}
}
}
private MachineElement ImportImplementation(string filePath, Action <string> setMachProjectFile = null)
{
MachineElement m = null;
if (!string.IsNullOrEmpty(filePath))
{
var info = new FileInfo(filePath);
//var extractPath = GetExtractionPath();
var extractPath = $"{info.DirectoryName}\\{Path.GetFileNameWithoutExtension(info.Name)}";
var dirInfo = new DirectoryInfo(extractPath);
var projectFile = $"{extractPath}\\{_machineFileName}";
if (dirInfo.Exists)
{
dirInfo.Delete(true);
}
ZipFile.ExtractToDirectory(filePath, extractPath);
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(MachineElement));
using (var reader = new StreamReader(projectFile))
{
m = (MachineElement)serializer.Deserialize(reader);
}
if (m != null)
{
UpdateModelsFiles(m, extractPath);
}
setMachProjectFile?.Invoke(projectFile);
}
return(m);
}
private bool AddModelsFilesToArchive(MachineElement me, ZipArchive archive)
{
bool result = true;
if (!string.IsNullOrEmpty(me.ModelFile))
{
FileInfo info = new FileInfo(me.ModelFile);
if (info.Exists)
{
var name = info.Name;
if (!_entrieeNames.Contains(name))
{
var entry = archive.CreateEntryFromFile(me.ModelFile, name);
_entrieeNames.Add(name);
}
}
}
foreach (var item in me.Children)
{
AddModelsFilesToArchive(item, archive);
}
return(result);
}
private void RemoveElementData(MachineElement m)
{
if (m.Color != null)
{
Colors.Remove(m.Color);
}
if (m.Transformation != null)
{
Matrices.Remove(m.Transformation);
}
if (m.LinkToParent != null)
{
Links.Remove(m.LinkToParent);
}
if (m is ColliderElement c)
{
RemoveElementData(c);
}
//else if (m is InserterElement ins) RemoveElementData(ins);
else if (m is InjectorElement inj)
{
RemoveElementData(inj);
}
else if (m is PanelHolderElement p)
{
RemoveElementData(p);
}
else if (m is ToolholderElement t)
{
RemoveElementData(t);
}
}
void dropElement()
{
if (possession != null)
{
possession.thrown(Vector3.zero, possession.transform.position);
possession = null;
}
}
private MachineElement GetMachine(string machProjectFile)
{
MachineElement machine = null;
DataSource.LoadMachine(machProjectFile, m => machine = m);
return(machine);
}
private static void SaveMachineProjectFile(MachineElement m, string machProjectFile)
{
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(MachineElement));
using (var writer = new System.IO.StreamWriter(machProjectFile))
{
serializer.Serialize(writer, m);
}
}
void throwElement()
{
if (nextForce == Vector3.zero)
{
dropElement();
}
possession.thrown(nextForce * 3, transform.position + (nextForce * 3).normalized);
possession = null;
}
private void RemoveElement(MachineElement m)
{
foreach (var item in m.Children)
{
RemoveElement(item);
}
RemoveElementData(m);
MachineElements.Remove(m);
}
private bool AddProjectFileToArchive(MachineElement me, ZipArchive archive)
{
bool result = true;
FilterModelsNames(me);
var entry = archive.CreateEntry(_machineFileName);
DataSource.SaveMachine(me, () => new StreamWriter(entry.Open()));
return(result);
}
internal static void SaveMachine(MachineElement machine, Func <StreamWriter> getSTreamWriter)
{
JsonSerializer serializer = new JsonSerializer();
serializer.NullValueHandling = NullValueHandling.Ignore;
serializer.Converters.Add(new LinkJsonConverter());
serializer.Converters.Add(new MachineElementJsonConverter());
using (StreamWriter sw = getSTreamWriter())
using (JsonWriter writer = new JsonTextWriter(sw))
{
serializer.Serialize(writer, machine);
}
}
private void FilterModelsNames(MachineElement me)
{
if (!string.IsNullOrEmpty(me.ModelFile))
{
var info = new FileInfo(me.ModelFile);
var name = info.Name;
me.ModelFile = name;
}
foreach (var item in me.Children)
{
FilterModelsNames(item);
}
}
private bool AddProjectFileToArchive(MachineElement me, ZipArchive archive)
{
bool result = true;
FilterModelsNames(me);
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(MachineElement));
var entry = archive.CreateEntry(_machineFileName);
using (var writer = new StreamWriter(entry.Open()))
{
serializer.Serialize(writer, me);
}
return(result);
}
private void UpdateModelsFiles(MachineElement m, string extractPath, bool save = false)
{
if (!string.IsNullOrEmpty(m.ModelFile))
{
m.ModelFile = $"{extractPath}\\{m.ModelFile}";
}
foreach (var item in m.Children)
{
UpdateModelsFiles(item, extractPath);
}
if (save)
{
var machProjectFile = $"{extractPath}\\{_machineFileName}";
SaveMachineProjectFile(m, machProjectFile);
}
}
private bool ExportImplementation(MachineElement machine, string filePath)
{
bool result = true;
FileInfo info = new FileInfo(filePath);
if (info.Exists)
{
info.Delete();
}
using (var archive = ZipFile.Open(filePath, ZipArchiveMode.Create))
{
if (!AddModelsFilesToArchive(machine, archive))
{
// log errore
}
else if (!AddProjectFileToArchive(machine, archive))
{
// log error
}
}
return(result);
}
private static string GetComputerCredentials(string SourceMachine)
{
MachineElement m = null;
foreach (MachineElement machine in machineConfig.Machines)
{
if (machine.ComputerName == SourceMachine)
{
m = machine;
}
}
if (m == null)
{
throw new InvalidOperationException(string.Format("{0} was not found in the configuration", SourceMachine));
}
if (string.IsNullOrEmpty(m.Username))
{
return(string.Format(",computername={0}", SourceMachine));
}
return(string.Format(",computername={0},username=\"{1}\",password=\"{2}\"", SourceMachine, m.Username, m.Password));
}
public static bool Export(MachineElement machine, string filePath)
{
var h = new ZipArchiveHelper();
return(h.ExportImplementation(machine, filePath));
}
internal static void SaveMachine(string fileName, MachineElement machine) => SaveMachine(machine, () => new StreamWriter(fileName));
