protected ListViewElementProject CreateListViewElement(SharedProject proj)
{
ListViewElementProject newElement = null;
if (null != ListViewElementPool)
{
newElement = ListViewElementPool.GetObject();
}
if (null == newElement)
{
newElement = GameObject.Instantiate <ListViewElementProject>(ListViewElementPrefab);
MousePointerEvents events = newElement.GetComponent <MousePointerEvents>();
SubscribeToMouseEventPointers(events, proj, TooltipComponent);
}
else
{
MousePointerEvents events = newElement.GetComponent <MousePointerEvents>();
events.RemoveAllListeners();
SubscribeToMouseEventPointers(events, proj, TooltipComponent);
}
newElement.Project = proj;
newElement.gameObject.SetActive(true);
return(newElement);
}
private string GetProjectListViewElementText(SharedProject proj)
{
return(string.Format("{0}\nCompletion bonus: {1} $\nCompletion time: {2} days",
proj.Name,
proj.CompletionBonus,
proj.CompletionTime));
}
/*Private methods*/
private void OnGameTimeDayChanged()
{
if (true == PhotonNetwork.isMasterClient && Projects.Count < MaxProjectsOnMarket)
{
int randomNumber = UnityEngine.Random.Range(1, 101);
if (randomNumber <= PROJECT_ADD_PROBABILITY_DAILY)
{
SharedProject newProject = GenerateSingleProject();
this.photonView.RPC("AddProjectRPC", PhotonTargets.All, newProject);
}
}
}
private void AddProjectRPC(SharedProject projectToAdd)
{
Projects.Add(projectToAdd);
ProjectAdded?.Invoke(projectToAdd);
if (false == PhotonNetwork.isMasterClient && false == IsDataReceived)
{
if (this.Projects.Count == MaxProjectsOnMarket)
{
IsDataReceived = true;
DataReceived?.Invoke();
}
}
}
private void OnButtonSelectorProjectsSelectedButtonChanged(Button btn)
{
if (null != btn)
{
ListViewElementProject el = btn.GetComponent <ListViewElementProject>();
SelectedProject = el.Project;
}
else
{
SelectedProject = null;
}
SetProjectInfoText(SelectedProject);
SetProjectMarketButton();
}
/// <summary>
/// Used to display text in tooltip component
/// </summary>
protected void SubscribeToMouseEventPointers(MousePointerEvents events, SharedProject proj, Tooltip tooltipComponent)
{
events.PointerEntered += () =>
{
tooltipComponent.gameObject.SetActive(true);
string tooltipText = string.Format("Used technologies:\n{0}",
GetProjectTechnologiesString(proj));
tooltipComponent.Text = tooltipText;
};
events.PointerExited += () =>
{
tooltipComponent.gameObject.SetActive(false);
};
}
private void RemoveProjectInternalRPC(int projectToRemoveID)
{
SharedProject removedProject = null;
for (int i = 0; i < Projects.Count; i++)
{
if (projectToRemoveID == Projects[i].ID)
{
removedProject = Projects[i];
Projects.RemoveAt(i);
break;
}
}
ProjectRemoved?.Invoke(removedProject);
}
private void OnProjectsMarketProjectRemoved(SharedProject proj)
{
ListViewElementProject element = GetProjectListViewElement(ListViewMarketProjects, proj);
if (null == ListViewElementPool)
{
ListViewElementPool = new ObjectPool <ListViewElementProject>();
}
element.gameObject.SetActive(false);
ListViewMarketProjects.RemoveControl(element.gameObject, false);
ButtonSelectorProjects.RemoveButton(element.Button);
ListViewElementPool.AddObject(element);
SetListViewMarketProjectsText();
proj.CompletionTimeUpdated -= OnMarketProjectCompletionTimeUpdated;
}
private void SetProjectInfoText(SharedProject proj)
{
if (null != proj)
{
TextProjectName.text = proj.Name;
TextCompleteBonus.text = string.Format("{0} $", proj.CompletionBonus);
TextUsedTechnologies.text = string.Format("{0}", GetProjectTechnologiesString(proj));
TextCompletionTime.text = string.Format("{0} days", proj.CompletionTime);
}
else
{
TextProjectName.text = string.Empty;
TextCompleteBonus.text = string.Empty;
TextUsedTechnologies.text = string.Empty;
TextCompletionTime.text = string.Empty;
}
}
/*Private methods*/
protected string GetProjectTechnologiesString(SharedProject proj)
{
StrBuilder.Clear();
for (int i = 0; i < proj.UsedTechnologies.Count; i++)
{
ProjectTechnology pt = proj.UsedTechnologies[i];
StrBuilder.Append(EnumToString.ProjectTechnologiesStrings[pt]);
if (i != proj.UsedTechnologies.Count - 1)
{
StrBuilder.Append(" / ");
}
}
return(StrBuilder.ToString());
}
public static void Run()
{
var path = Environment.ExpandEnvironmentVariables(@"%TEMP%\Diablo III.DMP");
var dump = new MiniDumpMemoryReader(path);
var pe = new PEHeaderReader(dump.ReadBytes(dump.ImageBase, 1024));
_ctx = new CodePatternContext(dump, pe);
_symbols = new SymbolTable();
_symbols.Version = dump.MainModuleVersion;
_symbols.DataSegment.Address = _ctx.Data.Start;
FindObjectManager();
FindActors();
FindACDs();
FindSNOs();
FindAttributeDescriptors();
FindApplicationCore();
FindLevelArea();
FindPreferences();
FindMapActId();
FindContainerManager();
FindMessageDescriptors();
FindPlayerData();
var dir = new DirectoryInfo("enigma-d3-memory-" + new Version(_symbols.Version.ToString()));
dir.Create();
WriteObjectPtrFile(dir);
WriteGlobalsFile(dir);
var project = new SharedProject("862a67ee-9ceb-42fe-9406-d7feafc55b00", "Enigma.D3.Memory");
project.AddCompileFile(Path.Combine(dir.FullName, "Globals.cs"));
//project.AddCompileFile(Path.Combine(dir.FullName, "MethodPtr.cs"));
project.AddCompileFile(Path.Combine(dir.FullName, "ObjectPtr.cs"));
project.Save(Path.Combine(dir.FullName, "Enigma.D3.Memory.Generated.*"));
if (Program.DeployGeneratedCode)
{
project.Deploy(
dir,
Program.SolutionDirectory.CreateSubdirectory(project.RootNamespace + ".Generated"));
}
}
private void OnProjectsMarketProjectAdded(SharedProject proj)
{
ListViewElementProject newElement = CreateListViewElement(proj);
MousePointerEvents mousePtrEvts = newElement.GetComponent <MousePointerEvents>();
mousePtrEvts.PointerDoubleClick += () =>
{
OnButtonTakeProjectClicked();
};
ButtonSelectorProjects.AddButton(newElement.Button);
ListViewMarketProjects.AddControl(newElement.gameObject);
newElement.Text.text = GetProjectListViewElementText(proj);
newElement.FrontImage.sprite = proj.Icon;
SetListViewMarketProjectsText();
proj.CompletionTimeUpdated += OnMarketProjectCompletionTimeUpdated;
}
private SharedProject GenerateSingleProject()
{
SharedProject newProject;
int projectNameIndex = UnityEngine.Random.Range(0, ProjectData.Names.Count);
string projectName =
ProjectData.Names[projectNameIndex];
newProject = new SharedProject(projectName);
newProject.UsedTechnologies = GenerateProjectTechnologies();
newProject.CompletionTime = UnityEngine.Random.Range(PROJECT_COMPLETION_TIME_MIN, PROJECT_COMPLETION_TIME_MAX);
newProject.CompletionBonus = CalculateProjectCompleteBonus(newProject);
newProject.ID = MainSimulationManager.GenerateID();
newProject.NameIndex = projectNameIndex;
//Every project name is associated with one icon
newProject.IconIndex = projectNameIndex;
newProject.Icon = ResourceHolderComponent.ProjectsIcons[projectNameIndex];
return(newProject);
}
internal static void Run()
{
var dir = new DirectoryInfo("enigma-d3-core-" + Engine.Current.ProcessVersion);
var enums = dir.CreateSubdirectory("Enums");
var project = new SharedProject("da9978d2-8f71-4399-8a57-a789f082e501", "Enigma.D3.Core");
File.WriteAllText(Path.Combine(enums.FullName, "AttributeId.cs"),
"namespace Enigma.D3.Enums\r\n{\r\n\tpublic enum AttributeId\r\n\t{\r\n" +
string.Join(",\r\n", Engine.Current.AttributeDescriptors.Select(a => $"\t\t{GetCleanName(a.x1C_Name)} = {a.x00_Id}").ToArray())
+ "\r\n\t}\r\n}\r\n");
project.AddCompileFile(Path.Combine(enums.FullName, "AttributeId.cs"));
if (Program.DeployGeneratedCode)
{
project.Deploy(
dir,
Program.SolutionDirectory.CreateSubdirectory(project.RootNamespace + ".Generated"));
}
}
/// <summary>
/// Generates projects on market and sends it to other clients
/// </summary>
private void GenerateAndSendProjects()
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
string className = this.GetType().Name;
string debugInfo = string.Format("[{0}] generating {1} projects...",
className, MaxProjectsOnMarket - Projects.Count);
Debug.Log(debugInfo);
#endif
while (MaxProjectsOnMarket > Projects.Count)
{
SharedProject newProject = GenerateSingleProject();
this.photonView.RPC("AddProjectRPC", PhotonTargets.All, newProject);
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
debugInfo = string.Format("[{0}] generated {1} projects",
className, Projects.Count);
Debug.Log(debugInfo);
#endif
}
private int CalculateProjectCompleteBonus(SharedProject newProject)
{
int projectCompleteBonus = PROJECT_BONUS_BASE;
foreach (ProjectTechnology techonology in newProject.UsedTechnologies)
{
projectCompleteBonus += PROJECT_BONUS_PER_TECHNOLOGY;
}
//Used to calculate completion bonus taking project's completion time
//into consideration
float completionTimeMultiplier = 3f / Utils.MapRange(newProject.CompletionTime,
PROJECT_COMPLETION_TIME_MIN,
PROJECT_COMPLETION_TIME_MAX,
1f,
3f);
projectCompleteBonus = (int)(completionTimeMultiplier * projectCompleteBonus);
return(projectCompleteBonus);
}
private IQueryable <SharedProject> SharedProjectList()
{
var list = new List <SharedProject>();
for (int i = 1; i <= 5; i++)
{
var sharedProjects = new SharedProject
{
RecipientEmail = "Test" + i + "@generac.com",
ProjectID = i,
ID = i,
Active = true,
Project = new Project
{
ID = i
}
};
list.Add(sharedProjects);
}
return(list.AsQueryable());
}
private SharedProjectsDto AddSharedProjects(SharedProjectsDto sharedProjectsDto, string userID, string userName)
{
try
{
SharedProject sharedProjectDetails;
SharedProject sharedProject = _sharedProjectsRepository.GetSingle(s => s.ProjectID == sharedProjectsDto.ProjectID && s.RecipientEmail.Equals(sharedProjectsDto.RecipientEmail, StringComparison.InvariantCultureIgnoreCase));
if (sharedProject != null)
{
foreach (var sharedSolutionID in sharedProjectsDto.SelectedSolutionList)
{
if (sharedProject.SharedProjectSolution.Where(s => s.SharedProjectID == sharedProject.ID && s.SolutionID == sharedSolutionID).Count() <= 0)
{
sharedProject.SharedProjectSolution.Add(new SharedProjectSolution
{
SharedProjectID = sharedProject.ID,
SolutionID = sharedSolutionID,
CreatedDateTime = DateTime.UtcNow,
SharedDateTime = DateTime.UtcNow,
ModifiedDateTime = DateTime.UtcNow,
CreatedBy = userName,
ModifiedBy = userName,
Active = true
});
}
//else
//{
// sharedProject.SharedProjectSolution.Remove(_sharedProjectSolutionRespository.GetSingle(s => s.SolutionID == sharedSolutionID));
//}
}
_sharedProjectsEntityToSharedProjectsDtoMapper.UpdateMap(sharedProjectsDto, sharedProject, userID);
sharedProject.ModifiedDateTime = DateTime.UtcNow;
sharedProject.ModifiedBy = userName;
sharedProject.Active = true;
sharedProjectDetails = _sharedProjectsRepository.Update(sharedProject);
_sharedProjectsRepository.Commit();
}
else
{
sharedProject = _sharedProjectsEntityToSharedProjectsDtoMapper.AddMap(sharedProjectsDto, userID);
sharedProject.CreatedDateTime = DateTime.UtcNow;
sharedProject.CreatedBy = userName;
sharedProject.SharedDateTime = DateTime.UtcNow;
sharedProject.ModifiedDateTime = DateTime.UtcNow;
sharedProject.ModifiedBy = userName;
sharedProject.Active = true;
sharedProject.SharedProjectSolution = sharedProjectsDto.SelectedSolutionList.Select(solutionID => new SharedProjectSolution
{
SolutionID = solutionID,
CreatedDateTime = DateTime.UtcNow,
SharedDateTime = DateTime.UtcNow,
ModifiedDateTime = DateTime.UtcNow,
CreatedBy = userName,
ModifiedBy = userName,
Active = true
}).ToList();
sharedProjectDetails = _sharedProjectsRepository.Add(sharedProject);
_sharedProjectsRepository.Commit();
}
Project sharedProjectRow = _projectRepository.GetSingle(p => p.ID == sharedProjectsDto.ProjectID);
var sharedProjectName = sharedProjectRow.ProjectName;
var sharerUserName = sharedProjectRow.User.FirstName + " " + sharedProjectRow.User.LastName;
return(new SharedProjectsDto
{
SharedProjectID = sharedProjectDetails.ID,
SharedProjectName = sharedProjectName,
SharerUserName = sharerUserName
});
}
catch (Exception ex)
{
throw ex;
}
}
private void OnSelectedProjectCompletionTimeUpdated(SharedProject proj)
{
ListViewElementProject element = GetProjectListViewElement(ListViewCompanyProjects, proj);
element.Text.text = GetProjectListViewElementText((LocalProject)proj);
}
/// <summary>
/// Returns list view element associated with given project
/// </summary>
/// <param name="listView">List view element will be searched in this list view</param>
protected ListViewElementProject GetProjectListViewElement(ControlListView listView, SharedProject proj)
{
GameObject elementObject = null;
ListViewElementProject element = null;
elementObject = listView.Controls.Find(x =>
{
return(x.GetComponent <ListViewElementProject>().Project == proj);
});
if (null != elementObject)
{
element = elementObject.GetComponent <ListViewElementProject>();
}
return(element);
}
private void OnMarketProjectCompletionTimeUpdated(SharedProject proj)
{
ListViewElementProject element = GetProjectListViewElement(ListViewMarketProjects, proj);
element.Text.text = GetProjectListViewElementText(proj);
}
/*Public methods*/
public void RemoveProject(SharedProject projectToRemove)
{
this.photonView.RPC("RemoveProjectInternalRPC", PhotonTargets.All, projectToRemove.ID);
}
/// <summary>
/// Synchronizes the text and notes data on the SF server with the data on the Paratext server.
/// </summary>
public async Task SendReceiveAsync(UserSecret userSecret, string ptTargetId,
IProgress <ProgressState> progress = null)
{
if (userSecret == null || ptTargetId == null)
{
throw new ArgumentNullException();
}
IInternetSharedRepositorySource source = await GetInternetSharedRepositorySource(userSecret.Id);
IEnumerable <SharedRepository> repositories = source.GetRepositories();
IEnumerable <ProjectMetadata> projectsMetadata = source.GetProjectsMetaData();
IEnumerable <string> projectGuids = projectsMetadata.Select(pmd => pmd.ProjectGuid.Id);
Dictionary <string, ParatextProject> ptProjectsAvailable =
GetProjects(userSecret, repositories, projectsMetadata).ToDictionary(ptProject => ptProject.ParatextId);
if (!projectGuids.Contains(ptTargetId))
{
// See if this is a resource
IReadOnlyList <ParatextResource> resources = await this.GetResourcesInternalAsync(userSecret.Id, true);
ParatextResource resource = resources.SingleOrDefault(r => r.ParatextId == ptTargetId);
if (resource != null)
{
ptProjectsAvailable.Add(resource.ParatextId, resource);
}
else
{
_logger.LogWarning($"The target project did not have a full name available {ptTargetId}");
}
}
if (!ptProjectsAvailable.TryGetValue(ptTargetId, out ParatextProject targetPtProject))
{
throw new ArgumentException(
$"PT projects with the following PT ids were requested but without access or they don't exist: {ptTargetId}");
}
EnsureProjectReposExists(userSecret, targetPtProject, source);
StartProgressReporting(progress);
if (!(targetPtProject is ParatextResource))
{
SharedProject targetSharedProj = SharingLogicWrapper.CreateSharedProject(ptTargetId,
targetPtProject.ShortName, source.AsInternetSharedRepositorySource(), repositories);
string username = GetParatextUsername(userSecret);
// Specifically set the ScrText property of the SharedProject to indicate the project is available locally
targetSharedProj.ScrText = ScrTextCollection.FindById(username, ptTargetId);
targetSharedProj.Permissions = targetSharedProj.ScrText.Permissions;
List <SharedProject> sharedPtProjectsToSr = new List <SharedProject> {
targetSharedProj
};
// TODO report results
List <SendReceiveResult> results = Enumerable.Empty <SendReceiveResult>().ToList();
bool success = false;
bool noErrors = SharingLogicWrapper.HandleErrors(() => success = SharingLogicWrapper
.ShareChanges(sharedPtProjectsToSr, source.AsInternetSharedRepositorySource(),
out results, sharedPtProjectsToSr));
if (!noErrors || !success)
{
throw new InvalidOperationException(
"Failed: Errors occurred while performing the sync with the Paratext Server.");
}
}
}
internal static void Run()
{
var exe = Program.GetExeFile();
var data = File.ReadAllBytes(exe.FullName);
var mem = new BufferMemoryReader(data);
var version = FileVersionInfo.GetVersionInfo(exe.FullName).FileVersion;
PE = new PEHeaderReader(data);
var symbols = SymbolLocator.FindAll(data, mem);
uint containerManager;
var dir = new DirectoryInfo("enigma-d3-memory-" + new Version(version.Replace(", ", ".")));
dir.Create();
var objPtrs = new Dictionary <string, uint>();
objPtrs.Add("SNOGroups", symbols.BestMatch("SnoGroups"));
objPtrs.Add("SNOGroupsByCode", symbols.BestMatch("SnoGroupsByCode"));
objPtrs.Add("AttributeDescriptors", symbols.BestMatch("AttributeDescriptors"));
objPtrs.Add("MessageDescriptor", symbols.BestMatch("MessageDescriptor"));
objPtrs.Add("LocalData", symbols.BestMatch("LocalData"));
objPtrs.Add("ContainerManager", containerManager = symbols.BestMatch("ContainerManager"));
objPtrs.Add("ApplicationLoopCount", symbols.BestMatch("ApplicationLoopCount"));
objPtrs.Add("ObjectManager", symbols.BestMatch("ObjectManager"));
objPtrs.Add("ObjectManagerPristine", symbols.BestMatch("ObjectManagerPristine"));
objPtrs.Add("MapActId", symbols.BestMatch("MapActId"));
objPtrs.Add("VideoPreferences", symbols.BestMatch("VideoPreferences"));
objPtrs.Add("SoundPreferences", symbols.BestMatch("SoundPreferences"));
objPtrs.Add("GameplayPreferences", symbols.BestMatch("GameplayPreferences"));
objPtrs.Add("SocialPreferences", symbols.BestMatch("SocialPreferences"));
objPtrs.Add("ChatPreferences", symbols.BestMatch("ChatPreferences"));
objPtrs.Add("HotkeyPreferences", objPtrs["SoundPreferences"] == 0 ? 0 : objPtrs["SoundPreferences"] + 0x50);
objPtrs.Add("LevelArea", GetStatic_LevelArea(data, symbols));
objPtrs.Add("LevelAreaName", GetStatic_LevelAreaName(data, symbols));
WriteObjectPtrFile(Path.Combine(dir.FullName, "ObjectPtr.cs"), objPtrs);
var methodPtrs = new Dictionary <string, uint>();
methodPtrs.Add("SNOGroups_Initialize", TranslateToVA(symbols.BestMatch("CSnoGroups::Initialize")));
methodPtrs.Add("GameMessage_GetHandlerInfo", TranslateToVA(symbols.BestMatch("CGameMessage::GetHandlerInfo")));
WriteMethodPtrFile(Path.Combine(dir.FullName, "MethodPtr.cs"), methodPtrs);
var globals = new Dictionary <string, string>();
globals.Add("static readonly Version SupportedVersion", $"new Version({version})");
globals.Add("const int SNOGroupsCount", "60"); // TODO: Don't hardcode.
globals.Add("const int AttributeDescriptorsCount", GetAttributeDescriptorsCount(symbols).ToString());
var sizeof_playerdata = symbols.BestMatch("sizeof(PlayerData)"); // ((symbols.BestMatch("sizeof(PlayerDataManager)") - 0x038) / 8);
globals.Add("const int SizeOf_PlayerData", sizeof_playerdata.ToHex());
if (Engine.Current?.ProcessVersion == Engine.SupportedVersion)
{
globals.Add("const int Offset_PlayerData_HeroName", GetOffset_PlayerData_HeroName(sizeof_playerdata).ToHex());
globals.Add("const int Offset_PlayerData_LifePercentage", GetOffset_PlayerData_LifePercentage(sizeof_playerdata).ToHex());
}
else
{
globals.Add("const int Offset_PlayerData_HeroName", "0; // Run [CodeGen -memory -deploy] again");
globals.Add("const int Offset_PlayerData_LifePercentage", "0; // Run [CodeGen -memory -deploy] again");
}
// TODO: globals.Add("const int SizeOf_LevelArea", symbols.BestMatch("sizeof(LevelArea)").ToHex());
WriteGlobalsFile(Path.Combine(dir.FullName, "Globals.cs"), globals);
var project = new SharedProject("862a67ee-9ceb-42fe-9406-d7feafc55b00", "Enigma.D3.Memory");
project.AddCompileFile(Path.Combine(dir.FullName, "Globals.cs"));
project.AddCompileFile(Path.Combine(dir.FullName, "MethodPtr.cs"));
project.AddCompileFile(Path.Combine(dir.FullName, "ObjectPtr.cs"));
project.Save(Path.Combine(dir.FullName, "Enigma.D3.Memory.Generated.*"));
if (Program.DeployGeneratedCode)
{
project.Deploy(
dir,
Program.SolutionDirectory.CreateSubdirectory(project.RootNamespace + ".Generated"));
}
}
internal static void Run()
{
PrimitiveType.Register <float>("DT_ACCEL", "Acceleration", "(Value * 3600.0f).ToString(\"0.00\") + \" ft/s^2\";");
PrimitiveType.Register <float>("DT_ANGLE", "Angle", "(Value * RadianToDegree).ToString(\"0.00\") + \"-|\";", "public const float RadianToDegree = 180f / (float)Math.PI; //57.295776f;");
PrimitiveType.Register <float>("DT_ANGULARVELOCITY", "AngularVelocity", "((Value * RadianToDegree) * 60.0f).ToString(\"0.00\") + \"-|/s\";", "public const float RadianToDegree = 180f / (float)Math.PI; //57.295776f;");
PrimitiveType.Register <int>("DT_ATTRIBUTEPARAM", "AttributeParameter");
PrimitiveType.Register <int>("DT_DATAID", "DataId", "\"0x\" + Value.ToString(\"X8\");");
PrimitiveType.Register <int>("DT_GBID", "GBID");
PrimitiveType.Register <float>("DT_HIGHPRECISIONPERCENT", "HighPrecisionPercent", "(Value * 100.0f).ToString(\"0.0000\") + \"%\";");
PrimitiveType.Register <float>("DT_IMPULSE", "Impulse", "(Value * 60.0f).ToString(\"0.00\") + \" lb-sec\";");
PrimitiveType.Register <float>("DT_MASS", "Mass", "(Value * 32.2f).ToString(\"0.00\") + \" lb\";");
PrimitiveType.Register <byte>("DT_PERCENT", "Percent", "(((float)Value / 255.0f) * 100.0f).ToString(\"0.00\") + \"%\";");
PrimitiveType.Register <int>("DT_SNO", "SNO");
PrimitiveType.Register <int>("DT_SNO_GROUP", "SNOGroup", "((Enigma.D3.Enums.SNOType)Value).ToString().ToUpper() + \"_SNO\";");
PrimitiveType.Register <int>("DT_SNONAME_HANDLE", "SNONameHandle");
PrimitiveType.Register <float>("DT_TIME", "Time", "(Value / 60f).ToString(\"0.00 sec\");");
PrimitiveType.Register <int>("DT_TRANSLATEABLE", "Translateable");
PrimitiveType.Register <float>("DT_VELOCITY", "Velocity", "(Value * 60f).ToString(\"0.00\") + \" ft/s\";");
NativeTypes.Register <bool>("DT_FLAG");
NativeTypes.Register <byte>("DT_BYTE");
NativeTypes.Register <short>("DT_WORD");
NativeTypes.Register <int>("DT_INT");
NativeTypes.Register <long>("DT_INT64");
NativeTypes.Register <float>("DT_FLOAT");
NativeTypes.Register <int>("DT_ENUM");
NativeTypes.Register <Vector3>("DT_VECTOR3D");
NativeTypes.Register <Vector2>("DT_VECTOR2D");
NativeTypes.Register <Vector2I>("DT_IVECTOR2D");
NativeTypes.Register <Quaternion>("Quaternion");
NativeTypes.Register <QuaternionI>("Quaternion16");
NativeTypes.Register <AABB>("AABB");
NativeTypes.Register <Sphere>("Sphere");
NativeTypes.Register <Vector3>("dmFloat3");
NativeTypes.Register <Plane>("dmPlane");
NativeTypes.Register <Matrix4x4>("Matrix4x4");
NativeTypes.Register <SNOName>("SNOName");
var groups = MemoryContext.Current.DataSegment.SNOGroupStorage
.Select(p => p.Cast <SNOGroupStorage <MemoryObject> >().Dereference()).Where(a => a != null).ToList();
var project = new SharedProject("966c65df-1054-4d67-91ee-31c155f0c8f8", "Enigma.D3.Assets");
var outDir = Directory.CreateDirectory("enigma-d3-assets-" + MemoryContext.Current.MainModuleVersion);
foreach (var group in groups.OrderBy(a => a.Name))
{
Console.WriteLine(ConsoleTitleBase + " - " + group.Name);
var knownTypes = new List <KnownType>();
knownTypes.AddRange(PrimitiveType.GetRawNames().Select(a => (KnownType)a));
knownTypes.AddRange(NativeTypes.GetRawNames().Select(a => (KnownType)a));
knownTypes.Add(group.PtrDataType.Dereference());
knownTypes.Add("DT_VARIABLEARRAY");
knownTypes.Add("DT_CHARARRAY");
knownTypes.Add("DT_TAGMAP");
knownTypes.Add("DT_CSTRING");
knownTypes.Add("DT_FORMULA");
knownTypes.Add("SerializeData");
string filePath = Path.Combine(outDir.FullName, group.PtrDataType.Dereference().GetName() + ".cs");
using (var output = File.CreateText(filePath))
{
var baseType = group.PtrDataType.Dereference().ContainsSerializedData() ? "SerializeMemoryObject" : "MemoryObject";
AttachPrinterStream(output);
PrintLine("using System.Runtime.CompilerServices;");
PrintLine("using Enigma.D3.DataTypes;");
PrintLine("using Enigma.Memory;");
PrintLine();
PrintLine("namespace Enigma.D3.Assets");
PrintLine("{");
IndentLevel++;
PrintLine("[CompilerGenerated]");
PrintLine("public {2}class {0} : {1}", group.Name, baseType,
DeclarePartial ? "partial " : "");
PrintLine("{");
IndentLevel++;
PrintLine("public const int SizeOf = 0x{0:X}; // {0}", group.PtrDataType.Dereference().GetSizeOf());
PrintLine();
PrintLine("public SNOHeader x{0}_Header {{ get {{ return Read<SNOHeader>(0x{0}); }} }}", 0.ToString("X" + Math.Max(2, group.PtrDataType.Dereference().GetSizeOf().ToString("X").Length)));
Examine(knownTypes.Select(a => (KnownType)a).ToList(), group.PtrDataType.Dereference());
IndentLevel--;
PrintLine("}");
IndentLevel--;
PrintLine("}");
DetachPrinterStream(output);
project.AddCompileFile(filePath);
}
}
Console.Title = ConsoleTitleBase + " - Creating shared project...";
project.Save(Path.Combine(outDir.FullName, "Enigma.D3.Assets.Generated.*"));
if (Program.DeployGeneratedCode)
{
Console.Title = ConsoleTitleBase + " - Deploying shared project...";
project.Deploy(
outDir,
Program.SolutionDirectory.CreateSubdirectory(project.RootNamespace + ".Generated"));
}
}
