ZeroDream/CodeWalker
2
0
Fork 0
mirror of https://mirror.ghproxy.com/https://github.com/dexyfex/CodeWalker synced 2024-07-15 14:21:24 +08:00
Code Issues Packages Projects Releases Wiki Activity
a24ef35611
CodeWalker/Project/ProjectForm.cs

4918 lines
157 KiB
C#
Raw Blame History

using CodeWalker.GameFiles;
using CodeWalker.Project.Panels;
using CodeWalker.Properties;
using CodeWalker.World;
using SharpDX;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using WeifenLuo.WinFormsUI.Docking;
namespace CodeWalker.Project
{
public partial class ProjectForm : Form
{
public WorldForm WorldForm { get; private set; }
public ThemeBase Theme { get; private set; }
public ProjectExplorerPanel ProjectExplorer { get; set; }
public ProjectPanel PreviewPanel { get; set; }
public GameFileCache GameFileCache { get; private set; }
public RpfManager RpfMan { get; private set; }
public bool IsProjectLoaded
{
get { return CurrentProjectFile != null; }
}
public ProjectFile CurrentProjectFile;
private YmapFile CurrentYmapFile;
private YmapEntityDef CurrentEntity;
private YmapCarGen CurrentCarGen;
private YmapGrassInstanceBatch CurrentGrassBatch;
private YtypFile CurrentYtypFile;
//private Archetype CurrentArchetype;
private YndFile CurrentYndFile;
private YndNode CurrentPathNode;
private YndLink CurrentPathLink;
private YnvFile CurrentYnvFile;
private YnvPoly CurrentNavPoly;
private TrainTrack CurrentTrainTrack;
private TrainTrackNode CurrentTrainNode;
private YmtFile CurrentScenario;
private ScenarioNode CurrentScenarioNode;
private MCScenarioChainingEdge CurrentScenarioChainEdge;
private bool renderitems = true;
private bool hidegtavmap = false;
private object projectsyncroot = new object();
public object ProjectSyncRoot { get { return projectsyncroot; } }
private Dictionary<int, YndFile> visibleynds = new Dictionary<int, YndFile>();
private Dictionary<int, YnvFile> visibleynvs = new Dictionary<int, YnvFile>();
private Dictionary<string, TrainTrack> visibletrains = new Dictionary<string, TrainTrack>();
private Dictionary<string, YmtFile> visiblescenarios = new Dictionary<string, YmtFile>();
private bool ShowProjectItemInProcess = false;
public ProjectForm(WorldForm worldForm = null)
{
WorldForm = worldForm;
InitializeComponent();
SetTheme(Settings.Default.ProjectWindowTheme, false);
ShowDefaultPanels();
if ((WorldForm != null) && (WorldForm.GameFileCache != null))
{
GameFileCache = WorldForm.GameFileCache;
RpfMan = GameFileCache.RpfMan;
}
else
{
GameFileCache = GameFileCacheFactory.Create();
new Thread(new ThreadStart(() => {
GTA5Keys.LoadFromPath(GTAFolder.CurrentGTAFolder, Settings.Default.Key);
GameFileCache.Init(UpdateStatus, UpdateError);
RpfMan = GameFileCache.RpfMan;
})).Start();
}
}
private void UpdateStatus(string text)
{
try
{
if (InvokeRequired)
{
BeginInvoke(new Action(() => { UpdateStatus(text); }));
}
else
{
//TODO: status text
//StatusLabel.Text = text;
}
}
catch { }
}
private void UpdateError(string text)
{
try
{
if (InvokeRequired)
{
BeginInvoke(new Action(() => { UpdateError(text); }));
}
else
{
//TODO: error text
//ErrorLabel.Text = text;
}
}
catch { }
}
private void SetTheme(string themestr, bool changing = true)
{
if (changing && (CurrentProjectFile != null))
{
if (MessageBox.Show("Project will be closed before changing the theme. Are you sure you want to continue?", "Theme change", MessageBoxButtons.YesNo) != DialogResult.Yes)
{
return;
}
}
CloseProject();
//string configFile = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), "DockPanel.temp.config");
//MainDockPanel.SaveAsXml(configFile);
CloseAllContents();
ProjectExplorer = null;
PreviewPanel = null;
foreach (ToolStripMenuItem menu in ViewThemeMenu.DropDownItems)
{
menu.Checked = false;
}
Theme = null;
switch (themestr)
{
default:
case "Blue":
Theme = new VS2015BlueTheme();
ViewThemeBlueMenu.Checked = true;
break;
case "Light":
Theme = new VS2015LightTheme();
ViewThemeLightMenu.Checked = true;
break;
case "Dark":
Theme = new VS2015DarkTheme();
ViewThemeDarkMenu.Checked = true;
break;
}
Settings.Default.ProjectWindowTheme = themestr;
Settings.Default.Save();
Theme.Extender.FloatWindowFactory = new ProjectFloatWindowFactory();
MainDockPanel.Theme = Theme;
var version = VisualStudioToolStripExtender.VsVersion.Vs2015;
VSExtender.SetStyle(MainMenu, version, Theme);
VSExtender.SetStyle(MainToolbar, version, Theme);
//VSExtender.SetStyle(MainStatusBar, version, theme);
//if (File.Exists(configFile)) MainDockPanel.LoadFromXml(configFile, m_deserializeDockContent);
if (changing)
{
ShowDefaultPanels();
}
}
private T FindPanel<T>(Func<T, bool> findFunc) where T : ProjectPanel
{
foreach (var pane in MainDockPanel.Panes)
{
foreach (var content in pane.Contents)
{
var test = content as T;
if ((test != null) && findFunc(test))
{
return test;
}
}
}
return null;
}
private void ShowDefaultPanels()
{
ShowProjectExplorer();
ShowWelcomePanel();
}
private void ShowProjectExplorer()
{
if ((ProjectExplorer == null) || (ProjectExplorer.IsDisposed) || (ProjectExplorer.Disposing))
{
ProjectExplorer = new ProjectExplorerPanel(this);
ProjectExplorer.OnItemSelected += ProjectExplorer_OnItemSelected;
ProjectExplorer.OnItemActivated += ProjectExplorer_OnItemActivated;
ProjectExplorer.SetTheme(Theme);
ProjectExplorer.Show(MainDockPanel, DockState.DockLeft);
}
else
{
ProjectExplorer.Show();
}
}
private void ShowWelcomePanel()
{
ShowPreviewPanel(() => { return new WelcomePanel(); });
}
private void ShowPreviewPanel<T>(Func<T> createFunc, Action<T> updateAction = null) where T : ProjectPanel
{
if ((PreviewPanel != null) && (PreviewPanel is T))
{
PreviewPanel.BringToFront();//.Show();
updateAction?.Invoke(PreviewPanel as T);
}
else
{
var panel = createFunc();
panel.HideOnClose = true;
panel.SetTheme(Theme);
panel.Show(MainDockPanel, DockState.Document);
updateAction?.Invoke(panel);
if (PreviewPanel != null)
{
PreviewPanel.Close();
}
PreviewPanel = panel;
}
}
private void ShowPanel<T>(bool promote, Func<T> createFunc, Action<T> updateAction, Func<T,bool> findFunc) where T : ProjectPanel
{
T found = FindPanel(findFunc);
if ((found != null) && (found != PreviewPanel))
{
found.BringToFront();//.Show();
updateAction?.Invoke(found);
}
else
{
if (promote)
{
PromoteIfPreviewPanel(PreviewPanel);
if (found != null)
{
found.BringToFront();//.Show();
updateAction?.Invoke(found);
}
else
{
ShowPreviewPanel(createFunc, updateAction);
PreviewPanel = null;
}
}
else
{
ShowPreviewPanel(createFunc, updateAction);
}
}
}
private void ShowEditProjectPanel(bool promote)
{
ShowPanel(promote,
() => { return new EditProjectPanel(this); }, //createFunc
(panel) => { panel.SetProject(CurrentProjectFile); }, //updateFunc
(panel) => { return true; }); //findFunc
}
private void ShowEditProjectManifestPanel(bool promote)
{
ShowPanel(promote,
() => { return new EditProjectManifestPanel(this); }, //createFunc
(panel) => { panel.SetProject(CurrentProjectFile); }, //updateFunc
(panel) => { return true; }); //findFunc
}
private void ShowEditYmapPanel(bool promote)
{
ShowPanel(promote,
() => { return new EditYmapPanel(this); }, //createFunc
(panel) => { panel.SetYmap(CurrentYmapFile); }, //updateFunc
(panel) => { return panel.Ymap == CurrentYmapFile; }); //findFunc
}
private void ShowEditYmapEntityPanel(bool promote)
{
ShowPanel(promote,
() => { return new EditYmapEntityPanel(this); }, //createFunc
(panel) => { panel.SetEntity(CurrentEntity); }, //updateFunc
(panel) => { return panel.CurrentEntity == CurrentEntity; }); //findFunc
}
private void ShowEditYmapCarGenPanel(bool promote)
{
ShowPanel(promote,
() => { return new EditYmapCarGenPanel(this); }, //createFunc
(panel) => { panel.SetCarGen(CurrentCarGen); }, //updateFunc
(panel) => { return panel.CurrentCarGen == CurrentCarGen; }); //findFunc
}
private void ShowEditYmapGrassBatchPanel(bool promote)
{
ShowPanel(promote,
() => { return new EditYmapGrassPanel(this); }, //createFunc
(panel) => { panel.SetBatch(CurrentGrassBatch); }, //updateFunc
(panel) => { return panel.CurrentBatch == CurrentGrassBatch; }); //findFunc
}
private void ShowEditYtypPanel(bool promote)
{
ShowPanel(promote,
() => { return new EditYtypPanel(this); }, //createFunc
(panel) => { panel.SetYtyp(CurrentYtypFile); }, //updateFunc
(panel) => { return panel.Ytyp == CurrentYtypFile; }); //findFunc
}
private void ShowEditYndPanel(bool promote)
{
ShowPanel(promote,
() => { return new EditYndPanel(this); }, //createFunc
(panel) => { panel.SetYnd(CurrentYndFile); }, //updateFunc
(panel) => { return panel.Ynd == CurrentYndFile; }); //findFunc
}
private void ShowEditYndNodePanel(bool promote)
{
ShowPanel(promote,
() => { return new EditYndNodePanel(this); }, //createFunc
(panel) => { panel.SetPathNode(CurrentPathNode); }, //updateFunc
(panel) => { return panel.CurrentPathNode == CurrentPathNode; }); //findFunc
}
private void ShowEditYnvPanel(bool promote)
{
ShowPanel(promote,
() => { return new EditYnvPanel(this); }, //createFunc
(panel) => { panel.SetYnv(CurrentYnvFile); }, //updateFunc
(panel) => { return panel.Ynv == CurrentYnvFile; }); //findFunc
}
private void ShowEditYnvPolyPanel(bool promote)
{
ShowPanel(promote,
() => { return new EditYnvPolyPanel(this); }, //createFunc
(panel) => { panel.SetYnvPoly(CurrentNavPoly); }, //updateFunc
(panel) => { return panel.YnvPoly == CurrentNavPoly; }); //findFunc
}
private void ShowEditTrainTrackPanel(bool promote)
{
ShowPanel(promote,
() => { return new EditTrainTrackPanel(this); }, //createFunc
(panel) => { panel.SetTrainTrack(CurrentTrainTrack); }, //updateFunc
(panel) => { return panel.Track == CurrentTrainTrack; }); //findFunc
}
private void ShowEditTrainNodePanel(bool promote)
{
ShowPanel(promote,
() => { return new EditTrainNodePanel(this); }, //createFunc
(panel) => { panel.SetTrainNode(CurrentTrainNode); }, //updateFunc
(panel) => { return panel.TrainNode == CurrentTrainNode; }); //findFunc
}
private void ShowEditScenarioYmtPanel(bool promote)
{
ShowPanel(promote,
() => { return new EditScenarioYmtPanel(this); }, //createFunc
(panel) => { panel.SetScenarioYmt(CurrentScenario); }, //updateFunc
(panel) => { return panel.CurrentScenario == CurrentScenario; }); //findFunc
}
private void ShowEditScenarioNodePanel(bool promote)
{
ShowPanel(promote,
() => { return new EditScenarioNodePanel(this); }, //createFunc
(panel) => { panel.SetScenarioNode(CurrentScenarioNode); }, //updateFunc
(panel) => { return panel.CurrentScenarioNode == CurrentScenarioNode; }); //findFunc
}
private void ShowCurrentProjectItem(bool promote)
{
if (CurrentEntity != null)
{
ShowEditYmapEntityPanel(promote);
}
else if (CurrentCarGen != null)
{
ShowEditYmapCarGenPanel(promote);
}
else if (CurrentGrassBatch != null)
{
ShowEditYmapGrassBatchPanel(promote);
}
else if (CurrentYmapFile != null)
{
ShowEditYmapPanel(promote);
}
if (CurrentYtypFile != null)
{
ShowEditYtypPanel(promote);
}
if (CurrentPathNode != null)
{
ShowEditYndNodePanel(promote);
}
else if (CurrentYndFile != null)
{
ShowEditYndPanel(promote);
}
if (CurrentNavPoly != null)
{
ShowEditYnvPolyPanel(promote);
}
else if (CurrentYnvFile != null)
{
ShowEditYnvPanel(promote);
}
if (CurrentTrainNode != null)
{
ShowEditTrainNodePanel(promote);
}
else if (CurrentTrainTrack != null)
{
ShowEditTrainTrackPanel(promote);
}
if (CurrentScenarioNode != null)
{
ShowEditScenarioNodePanel(promote);
}
else if (CurrentScenario != null)
{
ShowEditScenarioYmtPanel(promote);
}
}
public void ShowProjectItem(object item, bool promote)
{
ShowProjectItemInProcess = true;
SetProjectItem(item);
if (item == CurrentProjectFile)
{
ShowEditProjectPanel(promote);
}
else
{
ShowCurrentProjectItem(promote);
}
ShowProjectItemInProcess = false;
}
public void SetProjectItem(object item)
{
CurrentYmapFile = item as YmapFile;
CurrentEntity = item as YmapEntityDef;
CurrentCarGen = item as YmapCarGen;
CurrentGrassBatch = item as YmapGrassInstanceBatch;
CurrentYtypFile = item as YtypFile;
CurrentYndFile = item as YndFile;
CurrentPathNode = item as YndNode;
CurrentYnvFile = item as YnvFile;
CurrentNavPoly = item as YnvPoly;
CurrentTrainTrack = item as TrainTrack;
CurrentTrainNode = item as TrainTrackNode;
CurrentScenario = item as YmtFile;
CurrentScenarioNode = item as ScenarioNode;
CurrentScenarioChainEdge = item as MCScenarioChainingEdge;
if (CurrentEntity != null)
{
CurrentYmapFile = CurrentEntity.Ymap;
}
else if (CurrentCarGen != null)
{
CurrentYmapFile = CurrentCarGen.Ymap;
}
else if (CurrentGrassBatch != null)
{
CurrentYmapFile = CurrentGrassBatch.Ymap;
}
if (CurrentPathNode != null)
{
CurrentYndFile = CurrentPathNode.Ynd;
}
if (CurrentNavPoly != null)
{
CurrentYnvFile = CurrentNavPoly.Ynv;
}
if (CurrentTrainNode != null)
{
CurrentTrainTrack = CurrentTrainNode.Track;
}
if ((CurrentScenario != null) && (CurrentScenario.ScenarioRegion == null))
{
CurrentScenario = null;//incase other types of ymt files make it into the project...
}
if (CurrentScenarioNode != null)
{
CurrentScenario = CurrentScenarioNode.Ymt;
}
if (CurrentScenarioChainEdge != null)
{
CurrentScenario = CurrentScenarioChainEdge.Region?.Ymt;
}
RefreshUI();
}
private void ClosePanel<T>(Func<T,bool> findFunc) where T : ProjectPanel
{
var panel = FindPanel(findFunc);
if (PreviewPanel == panel)
{
PreviewPanel = null;
}
panel?.Close();
}
private void CloseAllDocuments()
{
if (MainDockPanel.DocumentStyle == DocumentStyle.SystemMdi)
{
foreach (Form form in MdiChildren) form.Close();
}
else
{
foreach (IDockContent document in MainDockPanel.DocumentsToArray())
{
// IMPORANT: dispose all panes.
document.DockHandler.DockPanel = null;
document.DockHandler.Close();
}
}
}
private void CloseAllContents()
{
// we don't want to create another instance of tool window, set DockPanel to null
if (ProjectExplorer != null) ProjectExplorer.DockPanel = null;
if (PreviewPanel != null) PreviewPanel.DockPanel = null;
// Close all other document windows
CloseAllDocuments();
// IMPORTANT: dispose all float windows.
foreach (var window in MainDockPanel.FloatWindows.ToList()) window.Dispose();
System.Diagnostics.Debug.Assert(MainDockPanel.Panes.Count == 0);
System.Diagnostics.Debug.Assert(MainDockPanel.Contents.Count == 0);
System.Diagnostics.Debug.Assert(MainDockPanel.FloatWindows.Count == 0);
}
private void CloseAllProjectItems()
{
foreach (var pane in MainDockPanel.Panes.ToArray())
{
foreach (var content in pane.Contents.ToArray())
{
var panel = content as ProjectPanel;
if (panel?.Tag != null)
{
panel.Close();
}
}
}
}
private void PromoteIfPreviewPanel(IDockContent panel)
{
if (panel == PreviewPanel)
{
if (PreviewPanel != null)
{
PreviewPanel.HideOnClose = false;
}
PreviewPanel = null;
}
}
private void PromoteIfPreviewPanelActive()
{
PromoteIfPreviewPanel(MainDockPanel.ActiveContent);
}
//######## Public methods
public void NewProject()
{
if (CurrentProjectFile != null)
{
////unload current project first
CloseProject();
}
CurrentProjectFile = new ProjectFile();
CurrentProjectFile.Name = "New CodeWalker Project";
CurrentProjectFile.Version = 1;
CurrentProjectFile.HasChanged = true;
LoadProjectUI();
}
public void OpenProject()
{
string file = ShowOpenDialog("CodeWalker Projects|*.cwproj", string.Empty);
if (string.IsNullOrEmpty(file))
{
return;
}
CloseProject();
CurrentProjectFile = new ProjectFile();
CurrentProjectFile.Load(file);
string cpath = new FileInfo(CurrentProjectFile.Filepath).Directory.FullName;
foreach (var ymap in CurrentProjectFile.YmapFiles)
{
string filename = ymap.FilePath;
if (!File.Exists(filename))
{
filename = cpath + "\\" + filename;
}
if (File.Exists(filename))
{
LoadYmapFromFile(ymap, filename);
}
else
{
MessageBox.Show("Couldn't find file: " + filename);
}
}
foreach (var ytyp in CurrentProjectFile.YtypFiles)
{
string filename = ytyp.FilePath;
if (!File.Exists(filename))
{
filename = cpath + "\\" + filename;
}
if (File.Exists(filename))
{
LoadYtypFromFile(ytyp, filename);
}
else
{
MessageBox.Show("Couldn't find file: " + filename);
}
}
foreach (var ynd in CurrentProjectFile.YndFiles)
{
string filename = ynd.FilePath;
if (!File.Exists(filename))
{
filename = cpath + "\\" + filename;
}
if (File.Exists(filename))
{
LoadYndFromFile(ynd, filename);
}
else
{
MessageBox.Show("Couldn't find file: " + filename);
}
}
foreach (var ynv in CurrentProjectFile.YnvFiles)
{
string filename = ynv.FilePath;
if (!File.Exists(filename))
{
filename = cpath + "\\" + filename;
}
if (File.Exists(filename))
{
LoadYnvFromFile(ynv, filename);
}
else
{
MessageBox.Show("Couldn't find file: " + filename);
}
}
foreach (var track in CurrentProjectFile.TrainsFiles)
{
string filename = track.FilePath;
if (!File.Exists(filename))
{
filename = cpath + "\\" + filename;
}
if (File.Exists(filename))
{
LoadTrainTrackFromFile(track, filename);
}
else
{
MessageBox.Show("Couldn't find file: " + filename);
}
}
foreach (var scenario in CurrentProjectFile.ScenarioFiles)
{
string filename = scenario.FilePath;
if (!File.Exists(filename))
{
filename = cpath + "\\" + filename;
}
if (File.Exists(filename))
{
LoadScenarioFromFile(scenario, filename);
}
else
{
MessageBox.Show("Couldn't find file: " + filename);
}
}
LoadProjectUI();
}
public void CloseProject()
{
if (CurrentProjectFile == null) return;
foreach (var ymap in CurrentProjectFile.YmapFiles)
{
if ((ymap != null) && (ymap.HasChanged))
{
//save the current ymap first?
if (MessageBox.Show("Would you like to save " + ymap.Name + " before closing?", "Save .ymap before closing?", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
CurrentYmapFile = ymap;
SaveYmap();
}
}
}
foreach (var ytyp in CurrentProjectFile.YtypFiles)
{
if ((ytyp != null) && (ytyp.HasChanged))
{
//save the current ytyp first?
if (MessageBox.Show("Would you like to save " + ytyp.Name + " before closing?", "Save .ytyp before closing?", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
CurrentYtypFile = ytyp;
SaveYtyp();
}
}
}
foreach (var ynd in CurrentProjectFile.YndFiles)
{
if ((ynd != null) && (ynd.HasChanged))
{
//save the current ynd first?
if (MessageBox.Show("Would you like to save " + ynd.Name + " before closing?", "Save .ynd before closing?", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
CurrentYndFile = ynd;
SaveYnd();
}
}
}
foreach (var ynv in CurrentProjectFile.YnvFiles)
{
if ((ynv != null) && (ynv.HasChanged))
{
//save the current ynv first?
if (MessageBox.Show("Would you like to save " + ynv.Name + " before closing?", "Save .ynv before closing?", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
CurrentYnvFile = ynv;
SaveYnv();
}
}
}
foreach (var trains in CurrentProjectFile.TrainsFiles)
{
if ((trains != null) && (trains.HasChanged))
{
//save the current trains file first?
if (MessageBox.Show("Would you like to save " + trains.Name + " before closing?", "Save trains file before closing?", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
CurrentTrainTrack = trains;
SaveTrainTrack();
}
}
}
foreach (var scenario in CurrentProjectFile.ScenarioFiles)
{
if ((scenario != null) && (scenario.HasChanged))
{
//save the current scenario file first?
if (MessageBox.Show("Would you like to save " + scenario.Name + " before closing?", "Save scenario file before closing?", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
CurrentScenario = scenario;
SaveScenario();
}
}
}
if (CurrentProjectFile.HasChanged)
{
//save the current project first?
if (MessageBox.Show("Would you like to save the current project before closing?", "Save project before closing?", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
SaveProject();
}
}
CloseAllProjectItems();
CurrentProjectFile = null;
CurrentYmapFile = null;
CurrentYtypFile = null;
CurrentYndFile = null;
CurrentYnvFile = null;
CurrentTrainTrack = null;
CurrentScenario = null;
LoadProjectUI();
if (WorldForm != null)
{
WorldForm.SelectItem(null);//make sure current selected item isn't still selected...
}
}
public void SaveProject(bool saveas = false)
{
if (CurrentProjectFile == null) return;
if (string.IsNullOrEmpty(CurrentProjectFile.Filepath) || saveas)
{
string fileName = ShowSaveDialog("CodeWalker Projects|*.cwproj", CurrentProjectFile.Filepath);
if (string.IsNullOrEmpty(fileName))
{ return; } //user cancelled
string oldpath = CurrentProjectFile.Filepath;
CurrentProjectFile.Filepath = fileName;
CurrentProjectFile.Filename = new FileInfo(fileName).Name;
CurrentProjectFile.UpdateFilenames(oldpath);
}
CurrentProjectFile.Save();
SetProjectHasChanged(false);
}
public void Save()
{
if (CurrentYmapFile != null)
{
SaveYmap();
}
else if (CurrentYtypFile != null)
{
SaveYtyp();
}
else if (CurrentYndFile != null)
{
SaveYnd();
}
else if (CurrentYnvFile != null)
{
SaveYnv();
}
else if (CurrentTrainTrack != null)
{
SaveTrainTrack();
}
else if (CurrentScenario != null)
{
SaveScenario();
}
else if (CurrentProjectFile != null)
{
SaveProject();
}
}
public void SaveAll()
{
if (CurrentProjectFile != null)
{
if (CurrentProjectFile.YmapFiles != null)
{
var cymap = CurrentYmapFile;
foreach (var ymap in CurrentProjectFile.YmapFiles)
{
CurrentYmapFile = ymap;
SaveYmap();
}
CurrentYmapFile = cymap;
//ShowEditYmapPanel(false);
}
if (CurrentProjectFile.YtypFiles != null)
{
var cytyp = CurrentYtypFile;
foreach (var ytyp in CurrentProjectFile.YtypFiles)
{
CurrentYtypFile = ytyp;
SaveYtyp();
}
CurrentYtypFile = cytyp;
//ShowEditYtypPanel(false);
}
if (CurrentProjectFile.YndFiles != null)
{
var cynd = CurrentYndFile;
foreach (var ynd in CurrentProjectFile.YndFiles)
{
CurrentYndFile = ynd;
SaveYnd();
}
CurrentYndFile = cynd;
//ShowEditYndPanel(false);
}
if (CurrentProjectFile.YnvFiles != null)
{
var cynv = CurrentYnvFile;
foreach (var ynv in CurrentProjectFile.YnvFiles)
{
CurrentYnvFile = ynv;
SaveYnv();
}
CurrentYnvFile = cynv;
//ShowEditYnvPanel(false);
}
if (CurrentProjectFile.TrainsFiles != null)
{
var ctrack = CurrentTrainTrack;
foreach (var track in CurrentProjectFile.TrainsFiles)
{
CurrentTrainTrack = track;
SaveYnd();
}
CurrentTrainTrack = ctrack;
//ShowEditTrainTrackPanel(false);
}
if (CurrentProjectFile.ScenarioFiles != null)
{
var cscen = CurrentScenario;
foreach (var scen in CurrentProjectFile.ScenarioFiles)
{
CurrentScenario = scen;
SaveScenario();
}
CurrentScenario = cscen;
//ShowEditScenarioPanel(false);
}
SaveProject();
}
}
public void SaveCurrentItem(bool saveas = false)
{
if (CurrentYmapFile != null)
{
SaveYmap(saveas);
}
else if (CurrentYtypFile != null)
{
SaveYtyp(saveas);
}
else if (CurrentYndFile != null)
{
SaveYnd(saveas);
}
else if (CurrentYnvFile != null)
{
SaveYnv(saveas);
}
else if (CurrentTrainTrack != null)
{
SaveTrainTrack(saveas);
}
else if (CurrentScenario != null)
{
SaveScenario(saveas);
}
}
public void NewYmap()
{
if (CurrentProjectFile == null)
{
NewProject();
}
if (CurrentProjectFile == null) return;
int testi = 1;
string fname = string.Empty;
bool filenameok = false;
while (!filenameok)
{
fname = "map" + testi.ToString() + ".ymap";
filenameok = !CurrentProjectFile.ContainsYmap(fname);
testi++;
}
lock (projectsyncroot)
{
YmapFile ymap = CurrentProjectFile.AddYmapFile(fname);
if (ymap != null)
{
ymap.Loaded = true;
ymap.HasChanged = true; //new ymap, flag as not saved
ymap._CMapData.contentFlags = 65; //stream flags value
}
}
CurrentProjectFile.HasChanged = true;
LoadProjectTree();
}
public void OpenYmap()
{
string[] files = ShowOpenDialogMulti("Ymap files|*.ymap", string.Empty);
if (files == null)
{
return;
}
if (CurrentProjectFile == null)
{
NewProject();
}
foreach (string file in files)
{
if (!File.Exists(file)) continue;
var ymap = CurrentProjectFile.AddYmapFile(file);
if (ymap != null)
{
SetProjectHasChanged(true);
LoadYmapFromFile(ymap, file);
LoadProjectTree();
}
else
{
MessageBox.Show("Couldn't add\n" + file + "\n - the file already exists in the project.");
}
}
}
public void SaveYmap(bool saveas = false)
{
if (CurrentYmapFile == null) return;
string ymapname = CurrentYmapFile.Name;
string filepath = CurrentYmapFile.FilePath;
if (string.IsNullOrEmpty(filepath))
{
filepath = ymapname;
}
string origfile = filepath;
if (!File.Exists(filepath))
{
saveas = true;
}
byte[] data;
lock (projectsyncroot) //need to sync writes to ymap objects...
{
saveas = saveas || string.IsNullOrEmpty(filepath);
if (saveas)
{
filepath = ShowSaveDialog("Ymap files|*.ymap", filepath);
if (string.IsNullOrEmpty(filepath))
{ return; }
string newname = Path.GetFileNameWithoutExtension(filepath);
JenkIndex.Ensure(newname);
CurrentYmapFile.FilePath = filepath;
CurrentYmapFile.RpfFileEntry.Name = new FileInfo(filepath).Name;
CurrentYmapFile.Name = CurrentYmapFile.RpfFileEntry.Name;
CurrentYmapFile._CMapData.name = new MetaHash(JenkHash.GenHash(newname));
}
data = CurrentYmapFile.Save();
}
if (data != null)
{
File.WriteAllBytes(filepath, data);
}
SetYmapHasChanged(false);
if (saveas)
{
//ShowEditYmapPanel(false);
if (CurrentProjectFile != null)
{
string origpath = CurrentProjectFile.GetRelativePath(origfile);
string newpath = CurrentProjectFile.GetRelativePath(CurrentYmapFile.FilePath);
if (!CurrentProjectFile.RenameYmap(origpath, newpath))
{ //couldn't rename it in the project?
MessageBox.Show("Couldn't rename ymap in project! This shouldn't happen - check the project file XML.");
}
}
SetProjectHasChanged(true);
SetCurrentSaveItem();
}
if (CurrentYmapFile.SaveWarnings != null)
{
string w = string.Join("\n", CurrentYmapFile.SaveWarnings);
MessageBox.Show(CurrentYmapFile.SaveWarnings.Count.ToString() + " warnings were generated while saving the ymap:\n" + w);
CurrentYmapFile.SaveWarnings = null;//clear it out for next time..
}
}
public void AddYmapToProject(YmapFile ymap)
{
if (ymap == null) return;
if (CurrentProjectFile == null)
{
NewProject();
}
if (YmapExistsInProject(ymap)) return;
if (CurrentProjectFile.AddYmapFile(ymap))
{
ymap.HasChanged = true;
CurrentProjectFile.HasChanged = true;
LoadProjectTree();
}
CurrentYmapFile = ymap;
RefreshUI();
if (CurrentEntity != null)
{
ProjectExplorer?.TrySelectEntityTreeNode(CurrentEntity);
}
else if (CurrentCarGen != null)
{
ProjectExplorer?.TrySelectCarGenTreeNode(CurrentCarGen);
}
}
public void RemoveYmapFromProject()
{
if (CurrentYmapFile == null) return;
if (CurrentProjectFile == null) return;
CurrentProjectFile.RemoveYmapFile(CurrentYmapFile);
CurrentYmapFile = null;
LoadProjectTree();
RefreshUI();
}
public bool YmapExistsInProject(YmapFile ymap)
{
if (ymap == null) return false;
if (CurrentProjectFile == null) return false;
return CurrentProjectFile.ContainsYmap(ymap);
}
public void NewEntity(YmapEntityDef copy = null, bool copyPosition = false)
{
if (CurrentYmapFile == null) return;
float spawndist = 5.0f; //use archetype BSradius if starting with a copy...
if (copy != null)
{
spawndist = copy.BSRadius * 2.5f;
}
bool cp = copyPosition && (copy != null);
Vector3 pos = cp ? copy.Position : GetSpawnPos(spawndist);
CEntityDef cent = new CEntityDef();
if (copy != null)
{
cent = copy.CEntityDef;
//TODO: copy entity extensions!
}
else
{
cent.archetypeName = new MetaHash(JenkHash.GenHash("prop_alien_egg_01"));
cent.rotation = new Vector4(0, 0, 0, 1);
cent.scaleXY = 1.0f;
cent.scaleZ = 1.0f;
cent.flags = 1572872;
cent.parentIndex = -1;
cent.lodDist = 200.0f;
cent.lodLevel = Unk_1264241711.LODTYPES_DEPTH_ORPHANHD;
cent.priorityLevel = Unk_648413703.PRI_REQUIRED;
cent.ambientOcclusionMultiplier = 255;
cent.artificialAmbientOcclusion = 255;
}
cent.position = pos;
YmapEntityDef ent = new YmapEntityDef(CurrentYmapFile, 0, ref cent);
ent.SetArchetype(GameFileCache.GetArchetype(cent.archetypeName));
if (WorldForm != null)
{
lock (WorldForm.RenderSyncRoot) //don't try to do this while rendering...
{
CurrentYmapFile.AddEntity(ent);
}
}
else
{
CurrentYmapFile.AddEntity(ent);
}
LoadProjectTree();
ProjectExplorer?.TrySelectEntityTreeNode(ent);
CurrentEntity = ent;
ShowEditYmapEntityPanel(false);
}
public void AddEntityToProject()
{
if (CurrentEntity == null) return;
if (CurrentEntity.Ymap == null)
{
MessageBox.Show("Sorry, interior entities cannot currently be added to the project.");
return;
}
CurrentYmapFile = CurrentEntity.Ymap;
if (!YmapExistsInProject(CurrentYmapFile))
{
var ent = CurrentEntity;
CurrentYmapFile.HasChanged = true;
AddYmapToProject(CurrentYmapFile);
CurrentEntity = ent; //bug fix for some reason the treeview selects the project node here.
CurrentYmapFile = ent.Ymap;
ProjectExplorer?.TrySelectEntityTreeNode(ent);
}
}
public bool DeleteEntity()
{
if (CurrentYmapFile == null) return false;
if (CurrentEntity == null) return false;
if (CurrentEntity.Ymap != CurrentYmapFile) return false;
if (CurrentYmapFile.AllEntities == null) return false; //nothing to delete..
if (CurrentYmapFile.RootEntities == null) return false; //nothing to delete..
if (CurrentEntity._CEntityDef.numChildren != 0)
{
MessageBox.Show("This entity's numChildren is not 0 - deleting entities with children is not currently supported by CodeWalker.");
return true;
}
int idx = CurrentEntity.Index;
for (int i = idx + 1; i < CurrentYmapFile.AllEntities.Length; i++)
{
var ent = CurrentYmapFile.AllEntities[i];
if (ent._CEntityDef.numChildren != 0)
{
MessageBox.Show("There are other entities present in this .ymap that have children. Deleting this entity is not currently supported by CodeWalker.");
return true;
}
}
if (MessageBox.Show("Are you sure you want to delete this entity?\n" + CurrentEntity._CEntityDef.archetypeName.ToString() + "\n" + CurrentEntity.Position.ToString() + "\n\nThis operation cannot be undone. Continue?", "Confirm delete", MessageBoxButtons.YesNo) != DialogResult.Yes)
{
return true;
}
bool res = false;
if (WorldForm != null)
{
lock (WorldForm.RenderSyncRoot) //don't try to do this while rendering...
{
res = CurrentYmapFile.RemoveEntity(CurrentEntity);
//WorldForm.SelectItem(null, null, null);
}
}
else
{
res = CurrentYmapFile.RemoveEntity(CurrentEntity);
}
if (!res)
{
MessageBox.Show("Entity.Index didn't match the index of the entity in the ymap. This shouldn't happen, check LOD linkages!");
}
var delent = CurrentEntity;
var delymap = CurrentYmapFile;
ProjectExplorer?.RemoveEntityTreeNode(delent);
ProjectExplorer?.SetYmapHasChanged(delymap, true);
ClosePanel((EditYmapEntityPanel p) => { return p.Tag == delent; });
CurrentEntity = null;
return true;
}
public bool IsCurrentEntity(YmapEntityDef ent)
{
return CurrentEntity == ent;
}
public void NewCarGen(YmapCarGen copy = null, bool copyPosition = false)
{
if (CurrentYmapFile == null) return;
Vector3 pos = GetSpawnPos(10.0f);
CCarGen ccg = new CCarGen();
if (copy != null)
{
ccg = copy.CCarGen;
}
else
{
ccg.flags = 3680;
ccg.orientX = 5.0f;
ccg.perpendicularLength = 2.6f;
//TODO: set default values for cargen
}
if (!copyPosition || (copy == null))
{
ccg.position = pos;
}
YmapCarGen cg = new YmapCarGen(CurrentYmapFile, ccg);
if (WorldForm != null)
{
lock (WorldForm.RenderSyncRoot) //don't try to do this while rendering...
{
CurrentYmapFile.AddCarGen(cg);
}
}
else
{
CurrentYmapFile.AddCarGen(cg);
}
LoadProjectTree();
ProjectExplorer?.TrySelectCarGenTreeNode(cg);
CurrentCarGen = cg;
ShowEditYmapCarGenPanel(false);
}
public void AddCarGenToProject()
{
if (CurrentCarGen == null) return;
CurrentYmapFile = CurrentCarGen.Ymap;
if (!YmapExistsInProject(CurrentYmapFile))
{
var cargen = CurrentCarGen;
CurrentYmapFile.HasChanged = true;
AddYmapToProject(CurrentYmapFile);
CurrentCarGen = cargen; //bug fix for some reason the treeview selects the project node here.
CurrentYmapFile = cargen.Ymap;
ProjectExplorer?.TrySelectCarGenTreeNode(cargen);
}
}
public bool DeleteCarGen()
{
if (CurrentYmapFile == null) return false;
if (CurrentCarGen == null) return false;
if (CurrentCarGen.Ymap != CurrentYmapFile) return false;
if (CurrentYmapFile.CarGenerators == null) return false; //nothing to delete..
if (MessageBox.Show("Are you sure you want to delete this car generator?\n" + CurrentCarGen.ToString() + "\n\nThis operation cannot be undone. Continue?", "Confirm delete", MessageBoxButtons.YesNo) != DialogResult.Yes)
{
return true;
}
bool res = false;
if (WorldForm != null)
{
lock (WorldForm.RenderSyncRoot) //don't try to do this while rendering...
{
res = CurrentYmapFile.RemoveCarGen(CurrentCarGen);
//WorldForm.SelectItem(null, null, null);
}
}
else
{
res = CurrentYmapFile.RemoveCarGen(CurrentCarGen);
}
if (!res)
{
MessageBox.Show("Unable to delete the car generator. This shouldn't happen!");
}
var delgen = CurrentCarGen;
ProjectExplorer?.RemoveCarGenTreeNode(CurrentCarGen);
ProjectExplorer?.SetYmapHasChanged(CurrentYmapFile, true);
ClosePanel((EditYmapCarGenPanel p) => { return p.Tag == delgen; });
CurrentCarGen = null;
return true;
}
public bool IsCurrentCarGen(YmapCarGen cargen)
{
return CurrentCarGen == cargen;
}
private void ImportMenyooXml()
{
if (CurrentProjectFile == null)
{
NewProject();
}
var xmlpath = ShowOpenDialog("XML Files|*.xml", string.Empty);
if (string.IsNullOrEmpty(xmlpath)) return;
var xmlstr = string.Empty;
try
{
xmlstr = File.ReadAllText(xmlpath);
}
catch (Exception ex)
{
MessageBox.Show("Error loading file!\n" + ex.ToString());
}
if (string.IsNullOrEmpty(xmlstr)) return;
var finf = new FileInfo(xmlpath);
MenyooXml menyooXml = new MenyooXml();
menyooXml.FilePath = xmlpath;
menyooXml.FileName = finf.Name;
menyooXml.Name = Path.GetFileNameWithoutExtension(finf.Name);
menyooXml.Init(xmlstr);
string fname = menyooXml.Name + ".ymap";
lock (ProjectSyncRoot)
{
YmapFile ymap = CurrentProjectFile.AddYmapFile(fname);
if (ymap != null)
{
ymap.Loaded = true;
ymap.HasChanged = true; //new ymap, flag as not saved
ymap._CMapData.contentFlags = 65; //stream flags value
}
CurrentYmapFile = ymap;
}
CurrentProjectFile.HasChanged = true;
int pedcount = 0;
int carcount = 0;
int entcount = 0;
int unkcount = 0;
foreach (var placement in menyooXml.Placements)
{
if (placement.Type == 1)
{
pedcount++;
}
else if (placement.Type == 2)
{
CCarGen ccg = new CCarGen();
var rotq = Quaternion.Invert(new Quaternion(placement.Rotation));
Vector3 cdir = rotq.Multiply(new Vector3(0, 5, 0));
ccg.flags = 3680;
ccg.orientX = cdir.X;
ccg.orientY = cdir.Y;
ccg.perpendicularLength = 2.6f;
ccg.position = placement.Position;
ccg.carModel = placement.ModelHash;
YmapCarGen cg = new YmapCarGen(CurrentYmapFile, ccg);
if (WorldForm != null)
{
lock (WorldForm.RenderSyncRoot) //don't try to do this while rendering...
{
CurrentYmapFile.AddCarGen(cg);
}
}
else
{
CurrentYmapFile.AddCarGen(cg);
}
carcount++;
}
else if (placement.Type == 3) //standard entity
{
CEntityDef cent = new CEntityDef();
cent.archetypeName = placement.ModelHash;
cent.position = placement.Position;
cent.rotation = placement.Rotation;
cent.scaleXY = 1.0f;
cent.scaleZ = 1.0f;
cent.flags = placement.Dynamic ? 32u : 0;// 1572872; //?
cent.parentIndex = -1;
cent.lodDist = placement.LodDistance;
cent.lodLevel = Unk_1264241711.LODTYPES_DEPTH_ORPHANHD;
cent.priorityLevel = Unk_648413703.PRI_REQUIRED;
cent.ambientOcclusionMultiplier = 255;
cent.artificialAmbientOcclusion = 255;
YmapEntityDef ent = new YmapEntityDef(CurrentYmapFile, 0, ref cent);
ent.SetArchetype(GameFileCache.GetArchetype(cent.archetypeName));
if (WorldForm != null)
{
lock (WorldForm.RenderSyncRoot) //don't try to do this while rendering...
{
CurrentYmapFile.AddEntity(ent);
}
}
else
{
CurrentYmapFile.AddEntity(ent);
}
entcount++;
}
else
{
unkcount++;
}
}
lock (ProjectSyncRoot)
{
CurrentYmapFile.CalcFlags();
CurrentYmapFile.CalcExtents();
}
LoadProjectTree();
ShowProjectItem(CurrentYmapFile, false);
MessageBox.Show(entcount.ToString() + " entities imported. \n" + carcount.ToString() + " car generators imported. \n" + pedcount.ToString() + " peds ignored. \n" + unkcount.ToString() + " others ignored.");
}
public void NewYtyp()
{
if (CurrentProjectFile == null)
{
NewProject();
}
if (CurrentProjectFile == null) return;
int testi = 1;
string fname = string.Empty;
bool filenameok = false;
while (!filenameok)
{
fname = "types" + testi.ToString() + ".ytyp";
filenameok = !CurrentProjectFile.ContainsYtyp(fname);
testi++;
}
lock (projectsyncroot)
{
YtypFile ytyp = CurrentProjectFile.AddYtypFile(fname);
if (ytyp != null)
{
//ytyp.Loaded = true;
ytyp.HasChanged = true; //new ytyp, flag as not saved
}
}
CurrentProjectFile.HasChanged = true;
LoadProjectTree();
}
public void OpenYtyp()
{
string[] files = ShowOpenDialogMulti("Ytyp files|*.ytyp", string.Empty);
if (files == null)
{
return;
}
if (CurrentProjectFile == null)
{
NewProject();
}
foreach (string file in files)
{
if (!File.Exists(file)) continue;
var ytyp = CurrentProjectFile.AddYtypFile(file);
if (ytyp != null)
{
SetProjectHasChanged(true);
LoadYtypFromFile(ytyp, file);
LoadProjectTree();
}
else
{
MessageBox.Show("Couldn't add\n" + file + "\n - the file already exists in the project.");
}
}
}
public void SaveYtyp(bool saveas = false) //TODO!
{
}
public void AddYtypToProject(YtypFile ytyp)
{
if (ytyp == null) return;
if (CurrentProjectFile == null)
{
NewProject();
}
if (YtypExistsInProject(ytyp)) return;
if (CurrentProjectFile.AddYtypFile(ytyp))
{
ytyp.HasChanged = true;
CurrentProjectFile.HasChanged = true;
LoadProjectTree();
}
CurrentYtypFile = ytyp;
RefreshUI();
}
public void RemoveYtypFromProject()
{
if (CurrentYtypFile == null) return;
if (CurrentProjectFile == null) return;
CurrentProjectFile.RemoveYtypFile(CurrentYtypFile);
CurrentYtypFile = null;
LoadProjectTree();
RefreshUI();
}
public bool YtypExistsInProject(YtypFile ytyp)
{
if (ytyp == null) return false;
if (CurrentProjectFile == null) return false;
return CurrentProjectFile.ContainsYtyp(ytyp);
}
public void NewYnd()
{
if (CurrentProjectFile == null)
{
NewProject();
}
if (CurrentProjectFile == null) return;
int testi = 1;
string fname = string.Empty;
bool filenameok = false;
while (!filenameok)
{
fname = "nodes" + testi.ToString() + ".ynd";
filenameok = !CurrentProjectFile.ContainsYnd(fname);
testi++;
}
lock (projectsyncroot)
{
YndFile ynd = CurrentProjectFile.AddYndFile(fname);
if (ynd != null)
{
ynd.Loaded = true;
ynd.HasChanged = true; //new ynd, flag as not saved
//TODO: set new ynd default values...
ynd.NodeDictionary = new NodeDictionary();
}
}
CurrentProjectFile.HasChanged = true;
LoadProjectTree();
}
public void OpenYnd()
{
string[] files = ShowOpenDialogMulti("Ynd files|*.ynd", string.Empty);
if (files == null)
{
return;
}
if (CurrentProjectFile == null)
{
NewProject();
}
foreach (string file in files)
{
if (!File.Exists(file)) continue;
var ynd = CurrentProjectFile.AddYndFile(file);
if (ynd != null)
{
SetProjectHasChanged(true);
LoadYndFromFile(ynd, file);
LoadProjectTree();
}
else
{
MessageBox.Show("Couldn't add\n" + file + "\n - the file already exists in the project.");
}
}
}
public void SaveYnd(bool saveas = false)
{
if ((CurrentYndFile == null) && (CurrentPathNode != null)) CurrentYndFile = CurrentPathNode.Ynd;
if (CurrentYndFile == null) return;
string yndname = CurrentYndFile.Name;
string filepath = CurrentYndFile.FilePath;
if (string.IsNullOrEmpty(filepath))
{
filepath = yndname;
}
string origfile = filepath;
if (!File.Exists(filepath))
{
saveas = true;
}
byte[] data;
lock (projectsyncroot) //need to sync writes to ynd objects...
{
saveas = saveas || string.IsNullOrEmpty(filepath);
if (saveas)
{
filepath = ShowSaveDialog("Ynd files|*.ynd", filepath);
if (string.IsNullOrEmpty(filepath))
{ return; }
string newname = Path.GetFileNameWithoutExtension(filepath);
JenkIndex.Ensure(newname);
CurrentYndFile.FilePath = filepath;
CurrentYndFile.RpfFileEntry.Name = new FileInfo(filepath).Name;
CurrentYndFile.Name = CurrentYndFile.RpfFileEntry.Name;
}
data = CurrentYndFile.Save();
}
if (data != null)
{
File.WriteAllBytes(filepath, data);
}
SetYndHasChanged(false);
if (saveas)
{
//ShowEditYndPanel(false);
if (CurrentProjectFile != null)
{
string origpath = CurrentProjectFile.GetRelativePath(origfile);
string newpath = CurrentProjectFile.GetRelativePath(CurrentYndFile.FilePath);
if (!CurrentProjectFile.RenameYnd(origpath, newpath))
{ //couldn't rename it in the project? happens when project not saved yet...
//MessageBox.Show("Couldn't rename ynd in project! This shouldn't happen - check the project file XML.");
}
}
SetProjectHasChanged(true);
SetCurrentSaveItem();
}
}
public void AddYndToProject(YndFile ynd)
{
if (ynd == null) return;
if (CurrentProjectFile == null)
{
NewProject();
}
if (YndExistsInProject(ynd)) return;
if (CurrentProjectFile.AddYndFile(ynd))
{
ynd.HasChanged = true;
CurrentProjectFile.HasChanged = true;
LoadProjectTree();
}
CurrentYndFile = ynd;
RefreshUI();
if (CurrentPathNode != null)
{
ProjectExplorer?.TrySelectPathNodeTreeNode(CurrentPathNode);
}
}
public void RemoveYndFromProject()
{
if (CurrentYndFile == null) return;
if (CurrentProjectFile == null) return;
CurrentProjectFile.RemoveYndFile(CurrentYndFile);
CurrentYndFile = null;
LoadProjectTree();
RefreshUI();
}
public bool YndExistsInProject(YndFile ynd)
{
if (ynd == null) return false;
if (CurrentProjectFile == null) return false;
return CurrentProjectFile.ContainsYnd(ynd);
}
public void NewPathNode(YndNode copy = null, bool copyPosition = false)
{
if (CurrentYndFile == null) return;
var n = CurrentYndFile.AddNode();
var areaid = n.AreaID;
var nodeid = n.NodeID;
if (copy == null)
{
copy = CurrentPathNode;
}
if (copy != null)
{
n.Init(CurrentYndFile, copy.RawData);
n.LinkCountUnk = copy.LinkCountUnk;
}
n.AreaID = areaid;
n.NodeID = nodeid;
bool cp = copyPosition && (copy != null);
Vector3 pos = cp ? copy.Position : GetSpawnPos(10.0f);
n.SetPosition(pos);
if (copy != null)
{
var link1 = n.AddLink(copy);
var link2 = copy.AddLink(n);
if ((copy.Links != null) && (copy.Links.Length > 0))
{
var clink = copy.Links[0];
link1.CopyFlags(clink);
var clnode = clink.Node2;
if (clnode.Links != null)
{
for (int i = 0; i < clnode.Links.Length; i++)
{
var clnlink = clnode.Links[i];
if (clnlink.Node2 == copy)
{
link2.CopyFlags(clnlink);
break;
}
}
}
}
}
CurrentYndFile.UpdateAllNodePositions(); //for the graphics...
CurrentYndFile.BuildBVH();
LoadProjectTree();
ProjectExplorer?.TrySelectPathNodeTreeNode(n);
CurrentPathNode = n;
//ShowEditYndPanel(false);;
ShowEditYndNodePanel(false);
if (WorldForm != null)
{
WorldForm.UpdatePathYndGraphics(CurrentYndFile, false);
}
}
public bool DeletePathNode()
{
if (CurrentYndFile == null) return false;
if (CurrentPathNode == null) return false;
if (CurrentPathNode.Ynd != CurrentYndFile) return false;
if (CurrentYndFile.Nodes == null) return false; //nothing to delete..
if (MessageBox.Show("Are you sure you want to delete this path node?\n" + CurrentPathNode.ToString() + "\n\nThis operation cannot be undone. Continue?", "Confirm delete", MessageBoxButtons.YesNo) != DialogResult.Yes)
{
return true;
}
bool res = false;
if (WorldForm != null)
{
lock (WorldForm.RenderSyncRoot) //don't try to do this while rendering...
{
res = CurrentYndFile.RemoveNode(CurrentPathNode);
//WorldForm.SelectItem(null, null, null);
}
}
else
{
res = CurrentYndFile.RemoveNode(CurrentPathNode);
}
if (!res)
{
MessageBox.Show("Unable to delete the path node. This shouldn't happen!");
}
var delnode = CurrentPathNode;
ProjectExplorer?.RemovePathNodeTreeNode(CurrentPathNode);
ProjectExplorer?.SetYndHasChanged(CurrentYndFile, true);
ClosePanel((EditYndNodePanel p) => { return p.Tag == delnode; });
CurrentPathNode = null;
if (WorldForm != null)
{
WorldForm.UpdatePathYndGraphics(CurrentYndFile, false);
}
return true;
}
public bool IsCurrentPathNode(YndNode pathnode)
{
return CurrentPathNode == pathnode;
}
public void NewYnv()//TODO!
{
}
public void OpenYnv()//TODO!
{
}
public void SaveYnv(bool saveas = false)//TODO!
{
}
public void AddYnvToProject(YnvFile ynv)
{
if (ynv == null) return;
if (CurrentProjectFile == null)
{
NewProject();
}
if (YnvExistsInProject(ynv)) return;
if (CurrentProjectFile.AddYnvFile(ynv))
{
ynv.HasChanged = true;
CurrentProjectFile.HasChanged = true;
LoadProjectTree();
}
CurrentYnvFile = ynv;
RefreshUI();
if (CurrentNavPoly != null)
{
ProjectExplorer?.TrySelectNavPolyTreeNode(CurrentNavPoly);
}
}
public void RemoveYnvFromProject()
{
if (CurrentYnvFile == null) return;
if (CurrentProjectFile == null) return;
CurrentProjectFile.RemoveYnvFile(CurrentYnvFile);
CurrentYnvFile = null;
LoadProjectTree();
RefreshUI();
}
public bool YnvExistsInProject(YnvFile ynv)
{
if (ynv == null) return false;
if (CurrentProjectFile == null) return false;
return CurrentProjectFile.ContainsYnv(ynv);
}
public void NewNavPoly(YnvPoly copy = null, bool copyposition = false)//TODO!
{
}
public bool DeleteNavPoly()//TODO!
{
return false;
}
public bool IsCurrentNavPoly(YnvPoly poly)
{
return false;// poly == CurrentNavPoly;
}
public void NewTrainTrack()
{
if (CurrentProjectFile == null)
{
NewProject();
}
if (CurrentProjectFile == null) return;
int testi = 13;
string fname = string.Empty;
bool filenameok = false;
while (!filenameok)
{
fname = "trains" + testi.ToString() + ".dat";
filenameok = !CurrentProjectFile.ContainsTrainTrack(fname);
testi++;
}
lock (projectsyncroot)
{
TrainTrack track = CurrentProjectFile.AddTrainsFile(fname);
if (track != null)
{
track.Loaded = true;
track.HasChanged = true; //new track, flag as not saved
//TODO: set new train track default values...
}
}
CurrentProjectFile.HasChanged = true;
LoadProjectTree();
}
public void OpenTrainTrack()
{
string[] files = ShowOpenDialogMulti("Dat files|*.dat", string.Empty);
if (files == null)
{
return;
}
if (CurrentProjectFile == null)
{
NewProject();
}
foreach (string file in files)
{
if (!File.Exists(file)) continue;
var track = CurrentProjectFile.AddTrainsFile(file);
if (track != null)
{
SetProjectHasChanged(true);
LoadTrainTrackFromFile(track, file);
LoadProjectTree();
}
else
{
MessageBox.Show("Couldn't add\n" + file + "\n - the file already exists in the project.");
}
}
}
public void SaveTrainTrack(bool saveas = false)
{
if ((CurrentTrainTrack == null) && (CurrentTrainNode != null)) CurrentTrainTrack = CurrentTrainNode.Track;
if (CurrentTrainTrack == null) return;
string trackname = CurrentTrainTrack.Name;
string filepath = CurrentTrainTrack.FilePath;
if (string.IsNullOrEmpty(filepath))
{
filepath = trackname;
}
string origfile = filepath;
if (!File.Exists(filepath))
{
saveas = true;
}
byte[] data;
lock (projectsyncroot) //need to sync writes to objects...
{
saveas = saveas || string.IsNullOrEmpty(filepath);
if (saveas)
{
filepath = ShowSaveDialog("Dat files|*.dat", filepath);
if (string.IsNullOrEmpty(filepath))
{ return; }
string newname = Path.GetFileNameWithoutExtension(filepath);
//////JenkIndex.Ensure(newname);
CurrentTrainTrack.FilePath = filepath;
CurrentTrainTrack.RpfFileEntry.Name = new FileInfo(filepath).Name;
CurrentTrainTrack.Name = CurrentTrainTrack.RpfFileEntry.Name;
}
data = CurrentTrainTrack.Save();
}
if (data != null)
{
File.WriteAllBytes(filepath, data);
}
SetTrainTrackHasChanged(false);
if (saveas)
{
//ShowEditTrainTrackPanel(false);
if (CurrentProjectFile != null)
{
string origpath = CurrentProjectFile.GetRelativePath(origfile);
string newpath = CurrentProjectFile.GetRelativePath(CurrentTrainTrack.FilePath);
if (!CurrentProjectFile.RenameTrainTrack(origpath, newpath))
{ //couldn't rename it in the project? happens when project not saved yet...
//MessageBox.Show("Couldn't rename train track in project! This shouldn't happen - check the project file XML.");
}
}
SetProjectHasChanged(true);
SetCurrentSaveItem();
}
}
public void AddTrainTrackToProject(TrainTrack track)
{
if (track == null) return;
if (CurrentProjectFile == null)
{
NewProject();
}
if (TrainTrackExistsInProject(track)) return;
if (CurrentProjectFile.AddTrainsFile(track))
{
track.HasChanged = true;
CurrentProjectFile.HasChanged = true;
LoadProjectTree();
}
CurrentTrainTrack = track;
RefreshUI();
if (CurrentTrainNode != null)
{
ProjectExplorer?.TrySelectTrainNodeTreeNode(CurrentTrainNode);
}
}
public void RemoveTrainTrackFromProject()
{
if (CurrentTrainTrack == null) return;
if (CurrentProjectFile == null) return;
CurrentProjectFile.RemoveTrainsFile(CurrentTrainTrack);
CurrentTrainTrack = null;
LoadProjectTree();
RefreshUI();
}
public bool TrainTrackExistsInProject(TrainTrack track)
{
if (track == null) return false;
if (CurrentProjectFile == null) return false;
return CurrentProjectFile.ContainsTrainTrack(track);
}
public void NewTrainNode(TrainTrackNode copy = null, bool copyPosition = false)
{
if (CurrentTrainTrack == null) return;
var afternode = copyPosition ? copy : null;
var n = CurrentTrainTrack.AddNode(afternode);
if (copy == null)
{
copy = CurrentTrainNode;
}
if (copy != null)
{
n.NodeType = copy.NodeType;
}
bool cp = copyPosition && (copy != null);
Vector3 pos = cp ? copy.Position : GetSpawnPos(10.0f);
n.SetPosition(pos);
//CurrentTrainTrack.BuildVertices(); //for the graphics...
CurrentTrainTrack.BuildBVH();
LoadProjectTree();
ProjectExplorer?.TrySelectTrainNodeTreeNode(n);
CurrentTrainNode = n;
ShowEditTrainNodePanel(false);
if (WorldForm != null)
{
WorldForm.UpdateTrainTrackGraphics(CurrentTrainTrack, false);
}
}
public bool DeleteTrainNode()
{
if (CurrentTrainTrack == null) return false;
if (CurrentTrainNode == null) return false;
if (CurrentTrainNode.Track != CurrentTrainTrack) return false;
if (CurrentTrainTrack.Nodes == null) return false; //nothing to delete..
if (MessageBox.Show("Are you sure you want to delete this train track node?\n" + CurrentTrainNode.ToString() + "\n\nThis operation cannot be undone. Continue?", "Confirm delete", MessageBoxButtons.YesNo) != DialogResult.Yes)
{
return true;
}
bool res = false;
if (WorldForm != null)
{
lock (WorldForm.RenderSyncRoot) //don't try to do this while rendering...
{
res = CurrentTrainTrack.RemoveNode(CurrentTrainNode);
//WorldForm.SelectItem(null, null, null);
}
}
else
{
res = CurrentTrainTrack.RemoveNode(CurrentTrainNode);
}
if (!res)
{
MessageBox.Show("Unable to delete the train track node. This shouldn't happen!");
}
var delnode = CurrentTrainNode;
ProjectExplorer?.RemoveTrainNodeTreeNode(CurrentTrainNode);
ProjectExplorer?.SetTrainTrackHasChanged(CurrentTrainTrack, true);
ClosePanel((EditTrainNodePanel p) => { return p.Tag == delnode; });
CurrentTrainNode = null;
if (WorldForm != null)
{
WorldForm.UpdateTrainTrackGraphics(CurrentTrainTrack, false);
}
return true;
}
public bool IsCurrentTrainNode(TrainTrackNode node)
{
return node == CurrentTrainNode;
}
public void NewScenario()
{
if (CurrentProjectFile == null)
{
NewProject();
}
if (CurrentProjectFile == null) return;
int testi = 1;
string fname = string.Empty;
bool filenameok = false;
while (!filenameok)
{
fname = "scenario" + testi.ToString() + ".ymt";
filenameok = !CurrentProjectFile.ContainsScenario(fname);
testi++;
}
lock (projectsyncroot)
{
YmtFile ymt = CurrentProjectFile.AddScenarioFile(fname);
if (ymt != null)
{
ymt.CScenarioPointRegion = new MCScenarioPointRegion();
ymt.CScenarioPointRegion.Ymt = ymt;
ymt.CScenarioPointRegion.Points = new MCScenarioPointContainer(ymt.CScenarioPointRegion);
ymt.CScenarioPointRegion.Paths = new MUnk_4023740759(ymt.CScenarioPointRegion);
ymt.CScenarioPointRegion.LookUps = new MCScenarioPointLookUps(ymt.CScenarioPointRegion);
ymt.ScenarioRegion = new ScenarioRegion();
ymt.ScenarioRegion.Region = ymt.CScenarioPointRegion;
ymt.ScenarioRegion.Ymt = ymt;
ymt.ScenarioRegion.BuildNodes(); //should be empty
ymt.ScenarioRegion.BuildBVH(); //should be empty
ymt.ScenarioRegion.BuildVertices(); //should be empty
ymt.HasChanged = true; //new ymt, flag as not saved
ymt.Loaded = true;
}
}
CurrentProjectFile.HasChanged = true;
LoadProjectTree();
}
public void OpenScenario()
{
string[] files = ShowOpenDialogMulti("Ymt files|*.ymt", string.Empty);
if (files == null)
{
return;
}
if (CurrentProjectFile == null)
{
NewProject();
}
foreach (string file in files)
{
if (!File.Exists(file)) continue;
var ymt = CurrentProjectFile.AddScenarioFile(file);
if (ymt != null)
{
SetProjectHasChanged(true);
LoadScenarioFromFile(ymt, file);
LoadProjectTree();
}
else
{
MessageBox.Show("Couldn't add\n" + file + "\n - the file already exists in the project.");
}
}
}
public void SaveScenario(bool saveas = false)
{
if ((CurrentScenario == null) && (CurrentScenarioNode != null)) CurrentScenario = CurrentScenarioNode.Ymt;
if (CurrentScenario == null) return;
string ymtname = CurrentScenario.Name;
string filepath = CurrentScenario.FilePath;
if (string.IsNullOrEmpty(filepath))
{
filepath = ymtname;
}
string origfile = filepath;
if (!File.Exists(filepath))
{
saveas = true;
}
byte[] data;
lock (projectsyncroot) //need to sync writes to scenario...
{
saveas = saveas || string.IsNullOrEmpty(filepath);
if (saveas)
{
filepath = ShowSaveDialog("Ymt files|*.ymt", filepath);
if (string.IsNullOrEmpty(filepath))
{ return; }
string newname = Path.GetFileNameWithoutExtension(filepath);
JenkIndex.Ensure(newname);
CurrentScenario.FilePath = filepath;
CurrentScenario.RpfFileEntry.Name = new FileInfo(filepath).Name;
CurrentScenario.Name = CurrentScenario.RpfFileEntry.Name;
}
CurrentScenario.ContentType = YmtFileContentType.ScenarioPointRegion;//just to be sure..
data = CurrentScenario.Save();
}
if (data != null)
{
File.WriteAllBytes(filepath, data);
}
SetScenarioHasChanged(false);
if (saveas)
{
//ShowEditScenarioPanel(false);
if (CurrentProjectFile != null)
{
string origpath = CurrentProjectFile.GetRelativePath(origfile);
string newpath = CurrentProjectFile.GetRelativePath(CurrentScenario.FilePath);
if (!CurrentProjectFile.RenameScenario(origpath, newpath))
{ //couldn't rename it in the project? happens when project not saved yet...
//MessageBox.Show("Couldn't rename scenario in project! This shouldn't happen - check the project file XML.");
}
}
SetProjectHasChanged(true);
SetCurrentSaveItem();
}
}
public void AddScenarioToProject(YmtFile ymt)
{
if (ymt == null) return;
if (CurrentProjectFile == null)
{
NewProject();
}
if (ScenarioExistsInProject(ymt)) return;
if (CurrentProjectFile.AddScenarioFile(ymt))
{
ymt.HasChanged = true;
CurrentProjectFile.HasChanged = true;
LoadProjectTree();
}
CurrentScenario = ymt;
RefreshUI();
if (CurrentScenarioNode != null)
{
ProjectExplorer?.TrySelectScenarioNodeTreeNode(CurrentScenarioNode);
}
}
public void RemoveScenarioFromProject()
{
if (CurrentScenario == null) return;
if (CurrentProjectFile == null) return;
CurrentProjectFile.RemoveScenarioFile(CurrentScenario);
CurrentScenario = null;
LoadProjectTree();
RefreshUI();
}
public bool ScenarioExistsInProject(YmtFile ymt)
{
if (ymt == null) return false;
if (CurrentProjectFile == null) return false;
return CurrentProjectFile.ContainsScenario(ymt);
}
public void NewScenarioNode(ScenarioNode copy = null, bool copyPosition = false)
{
if (CurrentScenario == null) return;
if (CurrentScenario.ScenarioRegion == null) return;
if (copy == null)
{
copy = CurrentScenarioNode;
}
var n = CurrentScenario.ScenarioRegion.AddNode(copy);
bool cp = copyPosition && (copy != null);
Vector3 pos = cp ? copy.Position : GetSpawnPos(10.0f);
Quaternion ori = cp ? copy.Orientation : Quaternion.Identity;
n.SetPosition(pos);
n.SetOrientation(ori);
LoadProjectTree();
ProjectExplorer?.TrySelectScenarioNodeTreeNode(n);
CurrentScenarioNode = n;
//ShowEditScenarioPanel(false);
ShowEditScenarioNodePanel(false);
if (WorldForm != null)
{
WorldForm.UpdateScenarioGraphics(CurrentScenario, false);
}
else
{
CurrentScenario.ScenarioRegion.BuildBVH();
CurrentScenario.ScenarioRegion.BuildVertices(); //for the graphics...
}
}
public bool DeleteScenarioNode()
{
if (CurrentScenario == null) return false;
if (CurrentScenario.ScenarioRegion == null) return false;
if (CurrentScenarioNode == null) return false;
if (MessageBox.Show("Are you sure you want to delete this scenario node?\n" + CurrentScenarioNode.ToString() + "\n\nThis operation cannot be undone. Continue?", "Confirm delete", MessageBoxButtons.YesNo) != DialogResult.Yes)
{
return true;
}
bool res = false;
if (WorldForm != null)
{
lock (WorldForm.RenderSyncRoot) //don't try to do this while rendering...
{
res = CurrentScenario.ScenarioRegion.RemoveNode(CurrentScenarioNode);
}
}
else
{
res = CurrentScenario.ScenarioRegion.RemoveNode(CurrentScenarioNode);
}
if (!res)
{
MessageBox.Show("Unable to delete the scenario node. This shouldn't happen!");
}
var delnode = CurrentScenarioNode;
ProjectExplorer?.RemoveScenarioNodeTreeNode(CurrentScenarioNode);
ProjectExplorer?.SetScenarioHasChanged(CurrentScenario, true);
ClosePanel((EditScenarioNodePanel p) => { return p.Tag == delnode; });
CurrentScenarioNode = null;
if (WorldForm != null)
{
WorldForm.UpdateScenarioGraphics(CurrentScenario, false);
}
return true;
}
public bool IsCurrentScenarioNode(ScenarioNode node)
{
return node == CurrentScenarioNode;
}
public void SetScenarioChainEdge(MCScenarioChainingEdge e)
{
CurrentScenarioChainEdge = e;
}
public void AddScenarioChain()
{
if (CurrentScenario.ScenarioRegion == null) return;
var paths = CurrentScenario?.CScenarioPointRegion?.Paths;
if (paths == null) return;
var copy = CurrentScenarioNode?.ChainingNode?.Chain;
var copyn = CurrentScenarioNode?.ChainingNode;
var copyp = CurrentScenarioNode?.MyPoint;
var copye = CurrentScenarioChainEdge;
var copycl = CurrentScenarioNode?.Cluster;
MCScenarioChain chain = new MCScenarioChain();
chain.Unk1 = 1; //default value
if (copy != null)
{
chain.Data = copy.Data;
chain._Data.EdgeIds = new Array_ushort(); //start empty.. not really necessary
}
paths.AddChain(chain);
//add 2 new nodes to the new chain.
var pos1 = GetSpawnPos(10.0f);
var pos2 = pos1 + Vector3.UnitX;
ScenarioNode n1 = null;// CurrentScenario.ScenarioRegion.AddNode();
if (copycl != null)
{
ScenarioNode copyclnode = new ScenarioNode(CurrentScenario);
copyclnode.Cluster = copycl;
copyclnode.ClusterMyPoint = new MCScenarioPoint(CurrentScenario.CScenarioPointRegion);
copyclnode.ClusterMyPoint.InteriorName = 493038497; //JenkHash.GenHash("none");
copyclnode.ClusterMyPoint.GroupName = 493038497;
copyclnode.ClusterMyPoint.IMapName = 493038497;
copyclnode.ClusterMyPoint.TimeStart = 0;
copyclnode.ClusterMyPoint.TimeEnd = 24;
n1 = CurrentScenario.ScenarioRegion.AddNode(copyclnode);
}
else
{
n1 = CurrentScenario.ScenarioRegion.AddNode();
}
ScenarioNode n2 = CurrentScenario.ScenarioRegion.AddNode();
if (copyp != null)
{
n1.MyPoint.CopyFrom(copyp);
n2.MyPoint.CopyFrom(copyp);
}
n1.ChainingNode = new MCScenarioChainingNode();
n2.ChainingNode = new MCScenarioChainingNode();
if (copyn != null)
{
n1.ChainingNode.CopyFrom(copyn);
n2.ChainingNode.CopyFrom(copyn);
}
n1.ChainingNode.NotLast = true;
n2.ChainingNode.NotFirst = true;
n1.ChainingNode.ScenarioNode = n1;
n2.ChainingNode.ScenarioNode = n2;
paths.AddNode(n1.ChainingNode);
paths.AddNode(n2.ChainingNode);
n1.ChainingNode.Chain = chain;
n2.ChainingNode.Chain = chain;
var ed = new MCScenarioChainingEdge();
if (copye != null)
{
ed.Data = copye.Data;
}
ed.NodeFrom = n1.ChainingNode;
ed.NodeTo = n2.ChainingNode;
ed.NodeIndexFrom = (ushort)n1.ChainingNode.NodeIndex;
ed.NodeIndexTo = (ushort)n2.ChainingNode.NodeIndex;
paths.AddEdge(ed);
chain.AddEdge(ed);
n1.SetPosition(pos1);
n2.SetPosition(pos2);
ProjectExplorer?.LoadProjectTree(CurrentProjectFile);
ProjectExplorer?.TrySelectScenarioNodeTreeNode(n1);
CurrentScenarioNode = n1;
CurrentScenarioChainEdge = ed;
//LoadScenarioChainTabPage();
////LoadScenarioTabPage();
////LoadScenarioNodeTabPages();
if (WorldForm != null)
{
WorldForm.UpdateScenarioGraphics(CurrentScenario, false);
}
else
{
CurrentScenario.ScenarioRegion.BuildBVH();
CurrentScenario.ScenarioRegion.BuildVertices(); //for the graphics...
}
}
public void AddScenarioCluster()//TODO: add defualt cluster points to new cluster
{
if (CurrentScenario == null) return;
var sr = CurrentScenario.ScenarioRegion;
if (sr == null) return;
var rgn = CurrentScenario.CScenarioPointRegion;
if (rgn == null) return;
var copy = CurrentScenarioNode?.Cluster;
MCScenarioPointCluster cluster = new MCScenarioPointCluster(rgn, copy);
List<MCScenarioPoint> clusterpoints = new List<MCScenarioPoint>();
if (copy != null)
{
if (copy.Points?.MyPoints != null)
{
clusterpoints.AddRange(copy.Points.MyPoints);
}
}
rgn.AddCluster(cluster); //add the base cluster to the region.
var pos1 = GetSpawnPos(10.0f);
var ncopy = new ScenarioNode(CurrentScenario);//copy an empty node to start with, to avoid creating default MyPoint
var nc = sr.AddNode(ncopy); //add the base cluster's display node.
nc.Cluster = cluster;
nc.SetPosition(pos1);
if (cluster.Points != null)
{
foreach (var cpt in clusterpoints)
{
//TODO: copy cluster points....
//or create some default points!
}
}
ProjectExplorer?.LoadProjectTree(CurrentProjectFile);
ProjectExplorer?.TrySelectScenarioNodeTreeNode(nc);
CurrentScenarioNode = nc;
//LoadScenarioClusterTabPage();
if (WorldForm != null)
{
WorldForm.UpdateScenarioGraphics(CurrentScenario, false);
}
else
{
CurrentScenario.ScenarioRegion.BuildBVH();
CurrentScenario.ScenarioRegion.BuildVertices(); //for the graphics...
}
}
public void AddScenarioClusterPoint()
{
if (CurrentScenario == null) return;
var sr = CurrentScenario.ScenarioRegion;
if (sr == null) return;
var rgn = CurrentScenario.CScenarioPointRegion;
if (rgn == null) return;
var cluster = CurrentScenarioNode?.Cluster;
if (cluster == null) return;
if (cluster.Points == null)
{
cluster.Points = new MCScenarioPointContainer(rgn);
cluster.Points.Parent = cluster;
}
var copy = CurrentScenarioNode?.ClusterMyPoint;
var pos1 = GetSpawnPos(10.0f);
var ori1 = copy?.Orientation ?? Quaternion.Identity;
var cn = new ScenarioNode(CurrentScenario);//copy a blank node
var n = sr.AddNode(cn);
var np = new MCScenarioPoint(rgn, copy);
cluster.Points.AddMyPoint(np);
n.ClusterMyPoint = np;
n.Cluster = cluster;
n.SetPosition(pos1);
n.SetOrientation(ori1);
ProjectExplorer?.LoadProjectTree(CurrentProjectFile);
ProjectExplorer?.TrySelectScenarioNodeTreeNode(n);
CurrentScenarioNode = n;
//LoadScenarioClusterTabPage();
//LoadScenarioClusterPointTabPage();
////LoadScenarioTabPage();
////LoadScenarioNodeTabPages();
if (WorldForm != null)
{
WorldForm.UpdateScenarioGraphics(CurrentScenario, false);
}
else
{
CurrentScenario.ScenarioRegion.BuildBVH();
CurrentScenario.ScenarioRegion.BuildVertices(); //for the graphics...
}
}
public void AddScenarioEntity()//TODO: add default entity point(s) to entity
{
if (CurrentScenario == null) return;
var sr = CurrentScenario.ScenarioRegion;
if (sr == null) return;
var rgn = CurrentScenario.CScenarioPointRegion;
if (rgn == null) return;
var copy = CurrentScenarioNode?.Entity;
MCScenarioEntityOverride entity = new MCScenarioEntityOverride(rgn, copy);
List<MCExtensionDefSpawnPoint> entpoints = new List<MCExtensionDefSpawnPoint>();
if (copy != null)
{
if (copy.ScenarioPoints != null)
{
entpoints.AddRange(copy.ScenarioPoints);
}
}
rgn.AddEntity(entity); //add the base entity to the region.
var pos1 = GetSpawnPos(10.0f);
var ncopy = new ScenarioNode(CurrentScenario);//copy an empty node to start with, to avoid creating default MyPoint
var ne = sr.AddNode(ncopy); //add the base entity's display node.
ne.Entity = entity;
ne.SetPosition(pos1);
if (entity.ScenarioPoints != null)
{
foreach (var cpt in entpoints)
{
//TODO: copy entity points....
//or create some default points!
}
}
ProjectExplorer?.LoadProjectTree(CurrentProjectFile);
ProjectExplorer?.TrySelectScenarioNodeTreeNode(ne);
CurrentScenarioNode = ne;
//LoadScenarioEntityTabPage();
if (WorldForm != null)
{
WorldForm.UpdateScenarioGraphics(CurrentScenario, false);
}
else
{
CurrentScenario.ScenarioRegion.BuildBVH();
CurrentScenario.ScenarioRegion.BuildVertices(); //for the graphics...
}
}
public void AddScenarioEntityPoint()
{
if (CurrentScenario == null) return;
var sr = CurrentScenario.ScenarioRegion;
if (sr == null) return;
var rgn = CurrentScenario.CScenarioPointRegion;
if (rgn == null) return;
var entity = CurrentScenarioNode?.Entity;
if (entity == null) return;
var copy = CurrentScenarioNode?.EntityPoint;
var pos1 = GetSpawnPos(10.0f);
var ori1 = copy?.Orientation ?? Quaternion.Identity;
var cn = new ScenarioNode(CurrentScenario);//copy a blank node
var n = sr.AddNode(cn);
var np = new MCExtensionDefSpawnPoint(rgn, copy);
entity.AddScenarioPoint(np);
n.EntityPoint = np;
n.Entity = entity;
n.SetPosition(pos1);
n.SetOrientation(ori1);
ProjectExplorer?.LoadProjectTree(CurrentProjectFile);
ProjectExplorer?.TrySelectScenarioNodeTreeNode(n);
CurrentScenarioNode = n;
//LoadScenarioEntityTabPage();
//LoadScenarioEntityPointTabPage();
////LoadScenarioTabPage();
////LoadScenarioNodeTabPages();
if (WorldForm != null)
{
WorldForm.UpdateScenarioGraphics(CurrentScenario, false);
}
else
{
CurrentScenario.ScenarioRegion.BuildBVH();
CurrentScenario.ScenarioRegion.BuildVertices(); //for the graphics...
}
}
public void DeleteScenarioChain()
{
if (CurrentScenario == null) return;
if (CurrentScenarioNode == null) return;
if (CurrentScenarioNode.ChainingNode == null) return;
if (CurrentScenarioNode.ChainingNode.Chain == null) return;
var chain = CurrentScenarioNode.ChainingNode.Chain;
var paths = CurrentScenario.CScenarioPointRegion?.Paths;
if (paths == null) return;
var rgn = CurrentScenario.ScenarioRegion;
if (rgn == null) return;
if (MessageBox.Show("Are you sure you want to delete this scenario chain?\n" + chain.ToString() + "\n\nThis operation cannot be undone. Continue?", "Confirm delete", MessageBoxButtons.YesNo) != DialogResult.Yes)
{
return;
}
bool delpoints = false;
if (MessageBox.Show("Delete all Scenario Points for this chain as well?", "Confirm delete points", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
delpoints = true;
}
Dictionary<MCScenarioChainingNode, int> ndict = new Dictionary<MCScenarioChainingNode, int>();
var edges = chain.Edges;
if (edges != null)
{
foreach (var edge in edges)
{
//paths.RemoveEdge(edge); //removing nodes also removes edges!
paths.RemoveNode(edge.NodeFrom);
paths.RemoveNode(edge.NodeTo);
ndict[edge.NodeFrom] = 1;
ndict[edge.NodeTo] = 1;
}
}
paths.RemoveChain(chain);
List<ScenarioNode> delnodes = new List<ScenarioNode>();
foreach (var node in rgn.Nodes)
{
if ((node.ChainingNode != null) && (ndict.ContainsKey(node.ChainingNode)))
{
delnodes.Add(node);
}
}
foreach (var delnode in delnodes)
{
delnode.ChainingNode = null;//this chaining node has been removed from the region. remove this association.
if (delpoints)
{
rgn.RemoveNode(delnode);
}
}
var cn = CurrentScenarioNode;
var cs = CurrentScenario;
ProjectExplorer?.LoadProjectTree(CurrentProjectFile);
if (!delpoints && (cn != null))
{
ProjectExplorer?.TrySelectScenarioNodeTreeNode(cn);
}
else
{
ProjectExplorer?.TrySelectScenarioTreeNode(cs);
}
ClosePanel((EditScenarioNodePanel p) => { return p.Tag == cn; });
if (WorldForm != null)
{
WorldForm.UpdateScenarioGraphics(cs, false);
if (delpoints)
{
WorldForm.SelectItem(null);
}
}
else if (cs?.ScenarioRegion != null)
{
cs.ScenarioRegion.BuildBVH();
cs.ScenarioRegion.BuildVertices(); //for the graphics...
}
}
public void DeleteScenarioCluster()
{
if (CurrentScenario == null) return;
if (CurrentScenarioNode == null) return;
if (CurrentScenarioNode.Cluster == null) return;
var cluster = CurrentScenarioNode.Cluster;
var rgn = CurrentScenario.ScenarioRegion;
if (rgn == null) return;
var crgn = CurrentScenario.CScenarioPointRegion;
if (crgn == null) return;
if (MessageBox.Show("Are you sure you want to delete this scenario cluster?\n" + cluster.ToString() + "\n\nThis operation cannot be undone. Continue?", "Confirm delete", MessageBoxButtons.YesNo) != DialogResult.Yes)
{
return;
}
bool delpoints = false;
if (MessageBox.Show("Delete all Scenario Points for this cluster as well?", "Confirm delete points", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
delpoints = true;
}
crgn.RemoveCluster(cluster);
Dictionary<MCScenarioPoint, int> ndict = new Dictionary<MCScenarioPoint, int>();
if (cluster?.Points?.MyPoints != null)
{
foreach (var point in cluster.Points.MyPoints)
{
ndict[point] = 1;
}
}
List<ScenarioNode> delnodes = new List<ScenarioNode>();
foreach (var node in rgn.Nodes)
{
if ((node.ClusterMyPoint != null) && (ndict.ContainsKey(node.ClusterMyPoint)))
{
delnodes.Add(node);
}
else if (node.Cluster == cluster)
{
delnodes.Add(node);
}
}
foreach (var delnode in delnodes)
{
if (!delpoints && (crgn.Points != null) && (delnode.ClusterMyPoint != null))
{
var copypt = new MCScenarioPoint(crgn, delnode.ClusterMyPoint);
crgn.Points.AddMyPoint(copypt);
delnode.MyPoint = copypt;
}
bool iscl = false;
if ((delnode.Cluster != null) && (delnode.ClusterMyPoint == null) && (delnode.ClusterLoadSavePoint == null))
{
iscl = true;
}
delnode.Cluster = null;
delnode.ClusterMyPoint = null;//this cluster point has been removed from the region. remove this association.
delnode.ClusterLoadSavePoint = null;
if (delpoints)
{
//if ((delnode.ChainingNode == null) && (delnode.EntityPoint == null))
{
rgn.RemoveNode(delnode);
}
}
else if (iscl)
{
rgn.RemoveNode(delnode); //remove the cluster node itself.
}
}
var cn = CurrentScenarioNode;
var cs = CurrentScenario;
ProjectExplorer?.LoadProjectTree(CurrentProjectFile);
if (!delpoints && (cn != null))
{
ProjectExplorer?.TrySelectScenarioNodeTreeNode(cn);
}
else
{
ProjectExplorer?.TrySelectScenarioTreeNode(cs);
}
ClosePanel((EditScenarioNodePanel p) => { return p.Tag == cn; });
if (WorldForm != null)
{
WorldForm.UpdateScenarioGraphics(cs, false);
if (delpoints || ((cn != null) && (cn.MyPoint == null)))
{
WorldForm.SelectItem(null);
}
}
else if (cs?.ScenarioRegion != null)
{
cs.ScenarioRegion.BuildBVH();
cs.ScenarioRegion.BuildVertices(); //for the graphics...
}
}
public void DeleteScenarioEntity()
{
if (CurrentScenario == null) return;
if (CurrentScenarioNode == null) return;
if (CurrentScenarioNode.Entity == null) return;
var entity = CurrentScenarioNode.Entity;
var rgn = CurrentScenario.ScenarioRegion;
if (rgn == null) return;
var crgn = CurrentScenario.CScenarioPointRegion;
if (crgn == null) return;
if (MessageBox.Show("Are you sure you want to delete this scenario entity override, and all its override points?\n" + entity.ToString() + "\n\nThis operation cannot be undone. Continue?", "Confirm delete", MessageBoxButtons.YesNo) != DialogResult.Yes)
{
return;
}
//bool delpoints = false;
//if (MessageBox.Show("Delete all Scenario Points for this entity override as well?", "Confirm delete points", MessageBoxButtons.YesNo) == DialogResult.Yes)
//{
// delpoints = true;
//}
crgn.RemoveEntity(entity);
Dictionary<MCExtensionDefSpawnPoint, int> ndict = new Dictionary<MCExtensionDefSpawnPoint, int>();
if (entity.ScenarioPoints != null)
{
foreach (var point in entity.ScenarioPoints)
{
ndict[point] = 1;
}
}
List<ScenarioNode> delnodes = new List<ScenarioNode>();
foreach (var node in rgn.Nodes)
{
if ((node.EntityPoint != null) && (ndict.ContainsKey(node.EntityPoint)))
{
delnodes.Add(node);
}
else if (node.Entity == entity)
{
delnodes.Add(node);
}
}
foreach (var delnode in delnodes)
{
delnode.Entity = null;
delnode.EntityPoint = null;//this entity point has been removed from the region. remove this association.
rgn.RemoveNode(delnode);
}
var cn = CurrentScenarioNode;
var cs = CurrentScenario;
ProjectExplorer?.LoadProjectTree(CurrentProjectFile);
ProjectExplorer?.TrySelectScenarioTreeNode(cs);
ClosePanel((EditScenarioNodePanel p) => { return p.Tag == cn; });
if (WorldForm != null)
{
WorldForm.UpdateScenarioGraphics(cs, false);
WorldForm.SelectItem(null);
}
else if (cs?.ScenarioRegion != null)
{
cs.ScenarioRegion.BuildBVH();
cs.ScenarioRegion.BuildVertices(); //for the graphics...
}
}
public void ImportScenarioChain()
{
var paths = CurrentScenario?.CScenarioPointRegion?.Paths;
if (paths == null) return;
var rgn = CurrentScenario.ScenarioRegion;
if (rgn == null) return;
TextInputForm f = new TextInputForm();
f.TitleText = "Import scenario chain points";
f.PromptText = "Input chain points in CSV (or TSV) format. Direction is in radians. NavSpeed is from 0 to 15. NavMode can be either Direct, NavMesh, or Roads. ScenarioType is the name of the scenario type to use.";
f.MainText = "X, Y, Z, Direction, NavSpeed, NavMode, ScenarioType, ModelSet, Flags";
if (f.ShowDialog() == DialogResult.Cancel) return;
var stypes = Scenarios.ScenarioTypes; //these are loaded by Scenarios.Init
ScenarioType defaulttype = null;
if (stypes != null)
{
defaulttype = stypes.GetScenarioType(1194480618); //"drive";
}
AmbientModelSet defaultmodelset = null;
uint defaultflags = 0;
ScenarioNode thisnode = null;
ScenarioNode lastnode = null;
MCScenarioChainingEdge lastedge = null;
var str = f.MainText;
var lines = str.Split('\n');
if (lines.Length < 2)
{
return;//need at least 2 lines (1 point) to work with...
}
MCScenarioChain chain = new MCScenarioChain();
paths.AddChain(chain);
for (int i = 0; i < lines.Length; i++)
{
var line = lines[i];
var delim = line.Contains(",") ? "," : " ";
var vals = line.Split(new[] { delim }, StringSplitOptions.RemoveEmptyEntries);
if (vals.Length < 3) continue;
if (vals[0].StartsWith("X")) continue;
Vector3 pos = Vector3.Zero;
float dir = 0;
var action = Unk_3609807418.Move;
var navMode = Unk_3971773454.Direct;
var navSpeed = Unk_941086046.Unk_00_3279574318;
var stype = defaulttype;
var modelset = defaultmodelset;
var flags = defaultflags;
var ok = true;
ok = ok && FloatUtil.TryParse(vals[0].Trim(), out pos.X);
ok = ok && FloatUtil.TryParse(vals[1].Trim(), out pos.Y);
ok = ok && FloatUtil.TryParse(vals[2].Trim(), out pos.Z);
if (vals.Length > 3)
{
ok = ok && FloatUtil.TryParse(vals[3].Trim(), out dir);
while (dir > Math.PI) dir -= 2.0f * (float)Math.PI;
while (dir < -Math.PI) dir += 2.0f * (float)Math.PI;
}
if (vals.Length > 4)
{
byte nsb = 0;
byte.TryParse(vals[4].Trim(), out nsb);
if (nsb > 15) nsb = 15;
navSpeed = (Unk_941086046)nsb;
}
if (vals.Length > 5)
{
switch (vals[5].Trim())
{
case "Direct": navMode = Unk_3971773454.Direct; break;
case "NavMesh": navMode = Unk_3971773454.NavMesh; break;
case "Roads": navMode = Unk_3971773454.Roads; break;
}
}
if (vals.Length > 6)
{
var sthash = JenkHash.GenHash(vals[6].Trim().ToLowerInvariant());
stype = stypes?.GetScenarioType(sthash) ?? defaulttype;
}
if (vals.Length > 7)
{
var mshash = JenkHash.GenHash(vals[7].Trim().ToLowerInvariant());
modelset = stypes?.GetPedModelSet(mshash) ?? null;
if (modelset == null) modelset = stypes?.GetVehicleModelSet(mshash) ?? null;
}
if (vals.Length > 8)
{
if (!uint.TryParse(vals[8].Trim(), out flags)) flags = defaultflags;
}
if (!ok) continue;
thisnode = rgn.AddNode();
thisnode.MyPoint.Direction = dir;
thisnode.MyPoint.Type = stype;
thisnode.MyPoint.ModelSet = modelset;
thisnode.MyPoint.Flags = (Unk_700327466)flags;
thisnode.ChainingNode = new MCScenarioChainingNode();
thisnode.ChainingNode.ScenarioNode = thisnode;
thisnode.ChainingNode.Chain = chain;
thisnode.ChainingNode.Type = stype;
thisnode.ChainingNode.TypeHash = stype?.NameHash ?? 0;
thisnode.ChainingNode.NotLast = (i < (lines.Length - 1));
thisnode.ChainingNode.NotFirst = (lastnode != null);
thisnode.SetPosition(pos);
thisnode.Orientation = thisnode.MyPoint.Orientation;
paths.AddNode(thisnode.ChainingNode);
if (lastnode != null)
{
var edge = new MCScenarioChainingEdge();
edge.NodeFrom = lastnode.ChainingNode;
edge.NodeTo = thisnode.ChainingNode;
edge.NodeIndexFrom = (ushort)lastnode.ChainingNode.NodeIndex;
edge.NodeIndexTo = (ushort)thisnode.ChainingNode.NodeIndex;
edge.Action = action;
edge.NavMode = navMode;
edge.NavSpeed = navSpeed;
paths.AddEdge(edge);
chain.AddEdge(edge);
lastedge = edge;
}
lastnode = thisnode;
}
LoadProjectTree();
if (lastnode != null)
{
ProjectExplorer?.TrySelectScenarioNodeTreeNode(lastnode);
CurrentScenarioNode = lastnode;
}
//CurrentScenarioChainEdge = lastedge;
//LoadScenarioChainTabPage();
//LoadScenarioTabPage();
//LoadScenarioNodeTabPages();
if (WorldForm != null)
{
WorldForm.UpdateScenarioGraphics(CurrentScenario, false);
}
else
{
CurrentScenario.ScenarioRegion.BuildBVH();
CurrentScenario.ScenarioRegion.BuildVertices(); //for the graphics...
}
}
public void GetVisibleYmaps(Camera camera, Dictionary<MetaHash, YmapFile> ymaps)
{
if (hidegtavmap)
{
ymaps.Clear(); //remove all the gtav ymaps.
}
if (renderitems && (CurrentProjectFile != null))
{
lock (projectsyncroot)
{
for (int i = 0; i < CurrentProjectFile.YmapFiles.Count; i++)
{
var ymap = CurrentProjectFile.YmapFiles[i];
if (ymap.Loaded)
{
ymaps[ymap._CMapData.name] = ymap;
}
}
}
}
}
public void GetVisibleCollisionMeshes(Camera camera, List<BoundsStoreItem> items)
{
if (hidegtavmap)
{
items.Clear();
}
}
public void GetVisibleWaterQuads(Camera camera, List<WaterQuad> quads)
{
if (hidegtavmap)
{
quads.Clear();
}
}
public void GetVisibleYnds(Camera camera, List<YndFile> ynds)
{
if (hidegtavmap)
{
ynds.Clear();
}
if (CurrentProjectFile == null) return;
lock (projectsyncroot)
{
visibleynds.Clear();
for (int i = 0; i < ynds.Count; i++)
{
var ynd = ynds[i];
visibleynds[ynd.AreaID] = ynd;
}
for (int i = 0; i < CurrentProjectFile.YndFiles.Count; i++)
{
var ynd = CurrentProjectFile.YndFiles[i];
if (ynd.Loaded)
{
visibleynds[ynd.AreaID] = ynd;
}
}
ynds.Clear();
foreach (var ynd in visibleynds.Values)
{
ynds.Add(ynd);
}
}
}
public void GetVisibleYnvs(Camera camera, List<YnvFile> ynvs)
{
if (hidegtavmap)
{
ynvs.Clear();
}
if (CurrentProjectFile == null) return;
lock (projectsyncroot)
{
visibleynvs.Clear();
for (int i = 0; i < ynvs.Count; i++)
{
var ynv = ynvs[i];
visibleynvs[ynv.AreaID] = ynv;
}
for (int i = 0; i < CurrentProjectFile.YnvFiles.Count; i++)
{
var ynv = CurrentProjectFile.YnvFiles[i];
if (ynv.Loaded)
{
visibleynvs[ynv.AreaID] = ynv;
}
}
ynvs.Clear();
foreach (var ynv in visibleynvs.Values)
{
ynvs.Add(ynv);
}
}
}
public void GetVisibleTrainTracks(Camera camera, List<TrainTrack> tracks)
{
if (hidegtavmap)
{
tracks.Clear();
}
if (CurrentProjectFile == null) return;
lock (projectsyncroot)
{
visibletrains.Clear();
for (int i = 0; i < tracks.Count; i++)
{
var track = tracks[i];
visibletrains[track.Name] = track;
}
for (int i = 0; i < CurrentProjectFile.TrainsFiles.Count; i++)
{
var track = CurrentProjectFile.TrainsFiles[i];
if (track.Loaded)
{
visibletrains[track.Name] = track;
}
}
tracks.Clear();
foreach (var track in visibletrains.Values)
{
tracks.Add(track);
}
}
}
public void GetVisibleScenarios(Camera camera, List<YmtFile> ymts)
{
if (hidegtavmap)
{
ymts.Clear();
}
if (CurrentProjectFile == null) return;
lock (projectsyncroot)
{
visiblescenarios.Clear();
for (int i = 0; i < ymts.Count; i++)
{
var ymt = ymts[i];
visiblescenarios[ymt.Name] = ymt;
}
for (int i = 0; i < CurrentProjectFile.ScenarioFiles.Count; i++)
{
var scenario = CurrentProjectFile.ScenarioFiles[i];
if (scenario.Loaded)
{
visiblescenarios[scenario.Name] = scenario;
}
}
ymts.Clear();
foreach (var ymt in visiblescenarios.Values)
{
ymts.Add(ymt);
}
}
}
public void OnWorldSelectionChanged(MapSelection sel)
{
try
{
if (InvokeRequired)
{
BeginInvoke(new Action(() => { OnWorldSelectionChanged(sel); }));
}
else
{
var ent = sel.EntityDef;
var cargen = sel.CarGenerator;
var grassbatch = sel.GrassBatch;
var pathnode = sel.PathNode;
var pathlink = sel.PathLink;
var navpoly = sel.NavPoly;
var trainnode = sel.TrainTrackNode;
var scenariond = sel.ScenarioNode;
var scenarioedge = sel.ScenarioEdge;
YmapFile ymap = ent?.Ymap ?? cargen?.Ymap ?? grassbatch?.Ymap;
YndFile ynd = pathnode?.Ynd;
YnvFile ynv = navpoly?.Ynv;
TrainTrack traintrack = trainnode?.Track;
YmtFile scenario = scenariond?.Ymt ?? scenarioedge?.Region?.Ymt;
bool showcurrent = false;
if (YmapExistsInProject(ymap))
{
if (ent != CurrentEntity)
{
ProjectExplorer?.TrySelectEntityTreeNode(ent);
}
if (cargen != CurrentCarGen)
{
ProjectExplorer?.TrySelectCarGenTreeNode(cargen);
}
}
else if (YndExistsInProject(ynd))
{
if (pathnode != CurrentPathNode)
{
ProjectExplorer?.TrySelectPathNodeTreeNode(pathnode);
}
}
else if (YnvExistsInProject(ynv))
{
if (navpoly != CurrentNavPoly)
{
ProjectExplorer?.TrySelectNavPolyTreeNode(navpoly);
}
}
else if (TrainTrackExistsInProject(traintrack))
{
if (trainnode != CurrentTrainNode)
{
ProjectExplorer?.TrySelectTrainNodeTreeNode(trainnode);
}
}
else if (ScenarioExistsInProject(scenario))
{
if ((scenariond != null) && (scenariond != CurrentScenarioNode))
{
ProjectExplorer?.TrySelectScenarioNodeTreeNode(scenariond);
}
}
else
{
ProjectExplorer?.DeselectNode();
showcurrent = true;
}
CurrentYmapFile = ymap;
CurrentYtypFile = null;//TODO: interiors!
CurrentEntity = ent;
CurrentCarGen = cargen;
CurrentGrassBatch = grassbatch;
CurrentYndFile = ynd;
CurrentPathNode = pathnode;
CurrentPathLink = pathlink;
CurrentYnvFile = ynv;
CurrentNavPoly = navpoly;
CurrentTrainTrack = traintrack;
CurrentTrainNode = trainnode;
CurrentScenario = scenario;
CurrentScenarioNode = scenariond;
CurrentScenarioChainEdge = scenarioedge;
RefreshUI();
if (showcurrent)
{
ShowProjectItemInProcess = true;
ShowCurrentProjectItem(false);
ShowProjectItemInProcess = false;
}
}
}
catch { }
}
public void OnWorldSelectionModified(MapSelection sel, List<MapSelection> items)
{
if (sel.MultipleSelection)
{
//TODO!!
}
else if (sel.EntityDef != null)
{
OnWorldEntityModified(sel.EntityDef);
}
else if (sel.CarGenerator != null)
{
OnWorldCarGenModified(sel.CarGenerator);
}
else if (sel.PathNode != null)
{
OnWorldPathNodeModified(sel.PathNode, sel.PathLink);
}
else if (sel.NavPoly != null)
{
OnWorldNavPolyModified(sel.NavPoly);
}
else if (sel.TrainTrackNode != null)
{
OnWorldTrainNodeModified(sel.TrainTrackNode);
}
else if (sel.ScenarioNode != null)
{
OnWorldScenarioNodeModified(sel.ScenarioNode);
}
}
private void OnWorldEntityModified(YmapEntityDef ent)
{
try
{
if (InvokeRequired)
{
BeginInvoke(new Action(() => { OnWorldEntityModified(ent); }));
}
else
{
if ((ent.Ymap == null) || (ent.MloParent != null))
{
return;//TODO: properly handle interior entities!
}
if (CurrentProjectFile == null)
{
NewProject();
}
if (!YmapExistsInProject(ent.Ymap))
{
ent.Ymap.HasChanged = true;
AddYmapToProject(ent.Ymap);
ProjectExplorer?.TrySelectEntityTreeNode(ent);
}
if (ent != CurrentEntity)
{
CurrentEntity = ent;
ProjectExplorer?.TrySelectEntityTreeNode(ent);
}
if (ent == CurrentEntity)
{
ShowEditYmapEntityPanel(false);
if (ent.Ymap != null)
{
SetYmapHasChanged(true);
}
}
}
}
catch { }
}
private void OnWorldCarGenModified(YmapCarGen cargen)
{
try
{
if (InvokeRequired)
{
BeginInvoke(new Action(() => { OnWorldCarGenModified(cargen); }));
}
else
{
if (cargen?.Ymap == null) return;
if (CurrentProjectFile == null)
{
NewProject();
}
if (!YmapExistsInProject(cargen.Ymap))
{
cargen.Ymap.HasChanged = true;
AddYmapToProject(cargen.Ymap);
ProjectExplorer?.TrySelectCarGenTreeNode(cargen);
}
if (cargen != CurrentCarGen)
{
CurrentCarGen = cargen;
ProjectExplorer?.TrySelectCarGenTreeNode(cargen);
}
if (cargen == CurrentCarGen)
{
ShowEditYmapCarGenPanel(false);
ProjectExplorer?.UpdateCarGenTreeNode(cargen);
if (cargen.Ymap != null)
{
SetYmapHasChanged(true);
}
}
}
}
catch { }
}
private void OnWorldPathNodeModified(YndNode node, YndLink link)
{
try
{
if (InvokeRequired)
{
BeginInvoke(new Action(() => { OnWorldPathNodeModified(node, link); }));
}
else
{
if (node?.Ynd == null) return;
if (CurrentProjectFile == null)
{
NewProject();
}
if (!YndExistsInProject(node.Ynd))
{
node.Ynd.HasChanged = true;
AddYndToProject(node.Ynd);
ProjectExplorer?.TrySelectPathNodeTreeNode(node);
}
if (node != CurrentPathNode)
{
CurrentPathNode = node;
ProjectExplorer?.TrySelectPathNodeTreeNode(node);
}
//////if (link != CurrentPathLink)
//////{
////// CurrentPathLink = link;
////// ShowEditYndLinkPanel(false);
//////}
if (node == CurrentPathNode)
{
//////ShowEditYndPanel(false);
ShowEditYndNodePanel(false);
//////UpdatePathNodeTreeNode(node);
if (node.Ynd != null)
{
SetYndHasChanged(true);
}
}
}
}
catch { }
}
private void OnWorldNavPolyModified(YnvPoly poly)
{
try
{
if (InvokeRequired)
{
BeginInvoke(new Action(() => { OnWorldNavPolyModified(poly); }));
}
else
{
if (poly?.Ynv == null) return;
if (CurrentProjectFile == null)
{
NewProject();
}
if (!YnvExistsInProject(poly.Ynv))
{
poly.Ynv.HasChanged = true;
AddYnvToProject(poly.Ynv);
ProjectExplorer?.TrySelectNavPolyTreeNode(poly);
}
if (poly != CurrentNavPoly)
{
CurrentNavPoly = poly;
ProjectExplorer?.TrySelectNavPolyTreeNode(poly);
}
if (poly == CurrentNavPoly)
{
ShowEditYnvPolyPanel(false);
//////UpdateNavPolyTreeNode(poly);
if (poly.Ynv != null)
{
SetYnvHasChanged(true);
}
}
}
}
catch { }
}
private void OnWorldTrainNodeModified(TrainTrackNode node)
{
try
{
if (InvokeRequired)
{
BeginInvoke(new Action(() => { OnWorldTrainNodeModified(node); }));
}
else
{
if (node?.Track == null) return;
if (CurrentProjectFile == null)
{
NewProject();
}
if (!TrainTrackExistsInProject(node.Track))
{
node.Track.HasChanged = true;
AddTrainTrackToProject(node.Track);
ProjectExplorer?.TrySelectTrainNodeTreeNode(node);
}
if (node != CurrentTrainNode)
{
CurrentTrainNode = node;
ProjectExplorer?.TrySelectTrainNodeTreeNode(node);
}
if (node == CurrentTrainNode)
{
ShowEditTrainNodePanel(false);
if (node.Track != null)
{
SetTrainTrackHasChanged(true);
}
}
}
}
catch { }
}
private void OnWorldScenarioNodeModified(ScenarioNode node)
{
try
{
if (InvokeRequired)
{
BeginInvoke(new Action(() => { OnWorldScenarioNodeModified(node); }));
}
else
{
if (node?.Ymt == null) return;
if (CurrentProjectFile == null)
{
NewProject();
}
if (!ScenarioExistsInProject(node.Ymt))
{
node.Ymt.HasChanged = true;
AddScenarioToProject(node.Ymt);
ProjectExplorer?.TrySelectScenarioNodeTreeNode(node);
}
if (node != CurrentScenarioNode)
{
CurrentScenarioNode = node;
ProjectExplorer?.TrySelectScenarioNodeTreeNode(node);
}
if (node == CurrentScenarioNode)
{
//ShowEditScenarioPanel(false);
ShowEditScenarioNodePanel(false);
if (node?.Ymt != null)
{
SetScenarioHasChanged(true);
}
}
}
}
catch { }
}
public Vector3 GetSpawnPos(float dist)
{
Vector3 pos = Vector3.Zero;
if (WorldForm != null)
{
Vector3 campos = WorldForm.GetCameraPosition();
Vector3 camdir = WorldForm.GetCameraViewDir();
pos = campos + camdir * dist;
}
return pos;
}
public void SetProjectHasChanged(bool changed)
{
if (CurrentProjectFile == null) return;
CurrentProjectFile.HasChanged = changed;
ProjectExplorer?.SetProjectHasChanged(changed);
UpdateFormTitleText();
}
public void SetYmapHasChanged(bool changed)
{
if (CurrentYmapFile == null) return;
bool changechange = changed != CurrentYmapFile.HasChanged;
if (!changechange) return;
CurrentYmapFile.HasChanged = changed;
ProjectExplorer?.SetYmapHasChanged(CurrentYmapFile, changed);
PromoteIfPreviewPanelActive();
}
public void SetYtypHasChanged(bool changed)
{
if (CurrentYtypFile == null) return;
bool changechange = changed != CurrentYtypFile.HasChanged;
if (!changechange) return;
CurrentYtypFile.HasChanged = changed;
ProjectExplorer?.SetYtypHasChanged(CurrentYtypFile, changed);
PromoteIfPreviewPanelActive();
}
public void SetYndHasChanged(bool changed)
{
if (CurrentYndFile == null) return;
bool changechange = changed != CurrentYndFile.HasChanged;
if (!changechange) return;
CurrentYndFile.HasChanged = changed;
ProjectExplorer?.SetYndHasChanged(CurrentYndFile, changed);
PromoteIfPreviewPanelActive();
}
public void SetYnvHasChanged(bool changed)
{
if (CurrentYnvFile == null) return;
bool changechange = changed != CurrentYnvFile.HasChanged;
if (!changechange) return;
CurrentYnvFile.HasChanged = changed;
ProjectExplorer?.SetYnvHasChanged(CurrentYnvFile, changed);
PromoteIfPreviewPanelActive();
}
public void SetTrainTrackHasChanged(bool changed)
{
if (CurrentTrainTrack == null) return;
bool changechange = changed != CurrentTrainTrack.HasChanged;
if (!changechange) return;
CurrentTrainTrack.HasChanged = changed;
ProjectExplorer?.SetTrainTrackHasChanged(CurrentTrainTrack, changed);
PromoteIfPreviewPanelActive();
}
public void SetScenarioHasChanged(bool changed)
{
if (CurrentScenario == null) return;
bool changechange = changed != CurrentScenario.HasChanged;
if (!changechange) return;
CurrentScenario.HasChanged = changed;
ProjectExplorer?.SetScenarioHasChanged(CurrentScenario, changed);
PromoteIfPreviewPanelActive();
}
public RpfFileEntry FindParentYmapEntry(uint hash)
{
if (CurrentProjectFile != null)
{
foreach (var ymap in CurrentProjectFile.YmapFiles)
{
if ((ymap._CMapData.name.Hash == hash) || (JenkHash.GenHash(Path.GetFileNameWithoutExtension(ymap.Name)) == hash))
{
return ymap.RpfFileEntry;
}
}
}
if ((GameFileCache != null) && (GameFileCache.IsInited))
{
return GameFileCache.GetYmapEntry(hash);
}
return null;
}
//######## Private methods
private void LoadYmapFromFile(YmapFile ymap, string filename)
{
byte[] data = File.ReadAllBytes(filename);
ymap.Load(data);
GameFileCache.InitYmapEntityArchetypes(ymap); //this needs to be done after calling YmapFile.Load()
}
private void LoadYtypFromFile(YtypFile ytyp, string filename)
{
byte[] data = File.ReadAllBytes(filename);
ytyp.Load(data);
}
private void LoadYndFromFile(YndFile ynd, string filename)
{
byte[] data = File.ReadAllBytes(filename);
ynd.Load(data);
if (WorldForm != null)
{
WorldForm.UpdatePathYndGraphics(ynd, true); //links don't get drawn until something changes otherwise
//note: this is actually necessary to properly populate junctions data........
}
}
private void LoadYnvFromFile(YnvFile ynv, string filename)//TODO!
{
}
private void LoadTrainTrackFromFile(TrainTrack track, string filename)
{
byte[] data = File.ReadAllBytes(filename);
string fname = new FileInfo(filename).Name;
track.Load(data);
track.Name = fname;
track.FilePath = filename;
track.RpfFileEntry.Name = fname;
track.RpfFileEntry.NameLower = fname.ToLowerInvariant();
if (WorldForm != null)
{
WorldForm.UpdateTrainTrackGraphics(track, true); //links don't get drawn until something changes otherwise
}
}
private void LoadScenarioFromFile(YmtFile ymt, string filename)
{
byte[] data = File.ReadAllBytes(filename);
ymt.LoadRSC(data);
}
private void LoadProjectUI()
{
RefreshProjectUI();
UpdateFormTitleText();
LoadProjectTree();
RefreshUI();
}
private void LoadProjectTree()
{
ProjectExplorer?.LoadProjectTree(CurrentProjectFile);
}
private void UpdateFormTitleText()
{
if (CurrentProjectFile == null)
{
Text = "Project - CodeWalker by dexyfex";
}
else
{
Text = CurrentProjectFile.Name + " - CodeWalker by dexyfex";
}
}
private void RefreshProjectUI()
{
bool enable = (CurrentProjectFile != null);
FileCloseProjectMenu.Enabled = enable;
FileSaveProjectMenu.Enabled = enable;
FileSaveProjectAsMenu.Enabled = enable;
}
private void RefreshUI()
{
RefreshYmapUI();
RefreshEntityUI();
RefreshCarGenUI();
RefreshYtypUI();
RefreshYndUI();
RefreshYnvUI();
RefreshTrainTrackUI();
RefreshScenarioUI();
SetCurrentSaveItem();
//ShowEditYmapPanel(false);
//ShowEditYmapEntityPanel(false);
//ShowEditYmapCarGenPanel(false);
//ShowEditYtypPanel(false);
//ShowEditYndPanel(false);
//ShowEditYnvPanel(false);
//ShowEditYndNodePanel(false);
//ShowEditTrainTrackPanel(false);
//ShowEditTrainNodePanel(false);
//ShowEditScenarioPanel(false);
//ShowEditScenarioNodePanel(false);
}
private void RefreshYmapUI()
{
bool enable = (CurrentYmapFile != null);
bool inproj = YmapExistsInProject(CurrentYmapFile);
YmapNewEntityMenu.Enabled = enable && inproj;
YmapNewCarGenMenu.Enabled = enable && inproj;
if (CurrentYmapFile != null)
{
YmapNameMenu.Text = "(" + CurrentYmapFile.Name + ")";
}
else
{
YmapNameMenu.Text = "(No .ymap file selected)";
}
YmapAddToProjectMenu.Enabled = enable && !inproj;
YmapRemoveFromProjectMenu.Enabled = inproj;
YmapMenu.Visible = enable;
if (WorldForm != null)
{
WorldForm.EnableYmapUI(enable, CurrentYmapFile?.Name ?? "");
}
}
private void RefreshEntityUI()
{
//bool enable = (CurrentEntity != null);
//bool isinproj = false;
//if (CurrentEntity != null)
//{
// isinproj = YmapExistsInProject(CurrentEntity.Ymap);
//}
//EntityAddToProjectButton.Enabled = !isinproj;
//EntityDeleteButton.Enabled = isinproj;
}
private void RefreshCarGenUI()
{
//bool enable = (CurrentCarGen != null);
//bool isinproj = false;
//if (CurrentCarGen != null)
//{
// isinproj = YmapExistsInProject(CurrentCarGen.Ymap);
//}
//CarAddToProjectButton.Enabled = !isinproj;
//CarDeleteButton.Enabled = isinproj;
}
private void RefreshYtypUI()
{
bool enable = (CurrentYtypFile != null);
bool inproj = YtypExistsInProject(CurrentYtypFile);
YtypNewArchetypeMenu.Enabled = enable && inproj;
if (CurrentYtypFile != null)
{
YtypNameMenu.Text = "(" + CurrentYtypFile.Name + ")";
}
else
{
YtypNameMenu.Text = "(No .ytyp file selected)";
}
YtypAddToProjectMenu.Enabled = enable && !inproj;
YtypRemoveFromProjectMenu.Enabled = inproj;
YtypMenu.Visible = enable;
if (WorldForm != null)
{
//WorldForm.EnableYtypUI(enable, CurrentYtypFile?.Name ?? "");
}
}
private void RefreshYndUI()
{
bool enable = (CurrentYndFile != null);
bool inproj = YndExistsInProject(CurrentYndFile);
YndNewNodeMenu.Enabled = enable && inproj;
if (CurrentYndFile != null)
{
YndNameMenu.Text = "(" + CurrentYndFile.Name + ")";
}
else
{
YndNameMenu.Text = "(No .ynd file selected)";
}
YndAddToProjectMenu.Enabled = enable && !inproj;
YndRemoveFromProjectMenu.Enabled = inproj;
YndMenu.Visible = enable;
if (WorldForm != null)
{
WorldForm.EnableYndUI(enable, CurrentYndFile?.Name ?? "");
}
}
private void RefreshYnvUI()
{
bool enable = (CurrentYnvFile != null);
bool inproj = YnvExistsInProject(CurrentYnvFile);
YnvNewPolygonMenu.Enabled = enable && inproj;
if (CurrentYnvFile != null)
{
YnvNameMenu.Text = "(" + CurrentYnvFile.Name + ")";
}
else
{
YnvNameMenu.Text = "(No .ynv file selected)";
}
YnvAddToProjectMenu.Enabled = enable && !inproj;
YnvRemoveFromProjectMenu.Enabled = inproj;
YnvMenu.Visible = enable;
if (WorldForm != null)
{
WorldForm.EnableYnvUI(enable, CurrentYnvFile?.Name ?? "");
}
}
private void RefreshTrainTrackUI()
{
bool enable = (CurrentTrainTrack != null);
bool inproj = TrainTrackExistsInProject(CurrentTrainTrack);
TrainsNewNodeMenu.Enabled = enable && inproj;
if (CurrentTrainTrack != null)
{
TrainsNameMenu.Text = "(" + CurrentTrainTrack.Name + ")";
}
else
{
TrainsNameMenu.Text = "(No train track selected)";
}
TrainsAddToProjectMenu.Enabled = enable && !inproj;
TrainsRemoveFromProjectMenu.Enabled = inproj;
TrainsMenu.Visible = enable;
if (WorldForm != null)
{
WorldForm.EnableTrainsUI(enable, CurrentTrainTrack?.Name ?? "");
}
}
private void RefreshScenarioUI()
{
bool enable = (CurrentScenario != null);
bool inproj = ScenarioExistsInProject(CurrentScenario);
ScenarioNewPointMenu.Enabled = enable && inproj;
ScenarioNewPointFromSelectedMenu.Enabled = enable && inproj && (CurrentScenarioNode != null);
ScenarioNewEntityOverrideMenu.Enabled = enable && inproj;
ScenarioNewChainMenu.Enabled = enable && inproj;
ScenarioNewClusterMenu.Enabled = enable && inproj;
ScenarioImportChainMenu.Enabled = enable && inproj;
if (CurrentScenario != null)
{
ScenarioNameMenu.Text = "(" + CurrentScenario.Name + ")";
}
else
{
ScenarioNameMenu.Text = "(No scenario region selected)";
}
ScenarioAddToProjectMenu.Enabled = enable && !inproj;
ScenarioRemoveFromProjectMenu.Enabled = inproj;
ScenarioMenu.Visible = enable;
if (WorldForm != null)
{
WorldForm.EnableScenarioUI(enable, CurrentScenario?.Name ?? "");
}
}
private void SetCurrentSaveItem()
{
string filename = null;
if (CurrentYmapFile != null)
{
filename = CurrentYmapFile.RpfFileEntry?.Name;
}
else if (CurrentYtypFile != null)
{
filename = CurrentYtypFile.RpfFileEntry?.Name;
}
else if (CurrentYndFile != null)
{
filename = CurrentYndFile.RpfFileEntry?.Name;
}
else if (CurrentYnvFile != null)
{
filename = CurrentYnvFile.RpfFileEntry?.Name;
}
else if (CurrentTrainTrack != null)
{
filename = CurrentTrainTrack.RpfFileEntry?.Name;
}
else if (CurrentScenario != null)
{
filename = CurrentScenario.RpfFileEntry?.Name;
}
bool enable = !string.IsNullOrEmpty(filename);
if (enable)
{
FileSaveItemMenu.Text = "Save " + filename;
FileSaveItemAsMenu.Text = "Save " + filename + " As...";
ToolbarSaveButton.Text = "Save " + filename;
}
else
{
FileSaveItemMenu.Text = "Save";
FileSaveItemAsMenu.Text = "Save As...";
ToolbarSaveButton.Text = "Save";
}
FileSaveItemMenu.Tag = filename;
FileSaveItemAsMenu.Tag = filename;
FileSaveItemMenu.Enabled = enable;
FileSaveItemMenu.Visible = enable;
FileSaveItemAsMenu.Enabled = enable;
FileSaveItemAsMenu.Visible = enable;
ToolbarSaveButton.Enabled = enable;
if (WorldForm != null)
{
WorldForm.SetCurrentSaveItem(filename);
}
}
private string ShowSaveDialog(string filter, string filename)
{
SaveFileDialog.FileName = filename;
SaveFileDialog.Filter = filter;
if (SaveFileDialog.ShowDialog(this) != DialogResult.OK)
{
return string.Empty;
}
return SaveFileDialog.FileName;
}
private string ShowOpenDialog(string filter, string filename)
{
OpenFileDialog.FileName = filename;
OpenFileDialog.Filter = filter;
OpenFileDialog.Multiselect = false;
if (OpenFileDialog.ShowDialog(this) != DialogResult.OK)
{
return string.Empty;
}
return OpenFileDialog.FileName;
}
private string[] ShowOpenDialogMulti(string filter, string filename)
{
OpenFileDialog.FileName = filename;
OpenFileDialog.Filter = filter;
OpenFileDialog.Multiselect = true;
if (OpenFileDialog.ShowDialog(this) != DialogResult.OK)
{
return null;
}
return OpenFileDialog.FileNames;
}
//######## events
private void ProjectForm_FormClosing(object sender, FormClosingEventArgs e)
{
CloseProject();
}
private void ProjectForm_FormClosed(object sender, FormClosedEventArgs e)
{
if (WorldForm != null)
{
WorldForm.OnProjectFormClosed();
}
}
private void ProjectExplorer_OnItemSelected(object item)
{
ShowProjectItem(item, false);
}
private void ProjectExplorer_OnItemActivated(object item)
{
//promote from preview panel to full panel...
ShowProjectItem(item, true);
}
private void MainDockPanel_ActiveContentChanged(object sender, EventArgs e)
{
if (!ShowProjectItemInProcess)
{
var panel = MainDockPanel.ActiveContent as ProjectPanel;
if (panel != null)
{
MainDockPanel.DefaultFloatWindowSize = panel.Size;
}
if (panel?.Tag != null)
{
SetProjectItem(panel.Tag);
RefreshUI();
}
}
}
private void MainDockPanel_DocumentDragged(object sender, EventArgs e)
{
PromoteIfPreviewPanel(MainDockPanel.ActiveContent);
}
private void FileNewProjectMenu_Click(object sender, EventArgs e)
{
NewProject();
}
private void FileNewYmapMenu_Click(object sender, EventArgs e)
{
NewYmap();
}
private void FileNewYtypMenu_Click(object sender, EventArgs e)
{
NewYtyp();
}
private void FileNewYndMenu_Click(object sender, EventArgs e)
{
NewYnd();
}
private void FileNewYnvMenu_Click(object sender, EventArgs e)
{
NewYnv();
}
private void FileNewTrainsMenu_Click(object sender, EventArgs e)
{
NewTrainTrack();
}
private void FileNewScenarioMenu_Click(object sender, EventArgs e)
{
NewScenario();
}
private void FileOpenProjectMenu_Click(object sender, EventArgs e)
{
OpenProject();
}
private void FileOpenYmapMenu_Click(object sender, EventArgs e)
{
OpenYmap();
}
private void FileOpenYtypMenu_Click(object sender, EventArgs e)
{
OpenYtyp();
}
private void FileOpenYndMenu_Click(object sender, EventArgs e)
{
OpenYnd();
}
private void FileOpenYnvMenu_Click(object sender, EventArgs e)
{
OpenYnv();
}
private void FileOpenTrainsMenu_Click(object sender, EventArgs e)
{
OpenTrainTrack();
}
private void FileOpenScenarioMenu_Click(object sender, EventArgs e)
{
OpenScenario();
}
private void FileCloseProjectMenu_Click(object sender, EventArgs e)
{
CloseProject();
}
private void FileSaveProjectMenu_Click(object sender, EventArgs e)
{
SaveProject();
}
private void FileSaveProjectAsMenu_Click(object sender, EventArgs e)
{
SaveProject(true);
}
private void FileSaveItemMenu_Click(object sender, EventArgs e)
{
SaveCurrentItem();
}
private void FileSaveItemAsMenu_Click(object sender, EventArgs e)
{
SaveCurrentItem(true);
}
private void ViewProjectExplorerMenu_Click(object sender, EventArgs e)
{
ShowProjectExplorer();
}
private void ViewThemeBlueMenu_Click(object sender, EventArgs e)
{
SetTheme("Blue");
}
private void ViewThemeLightMenu_Click(object sender, EventArgs e)
{
SetTheme("Light");
}
private void ViewThemeDarkMenu_Click(object sender, EventArgs e)
{
SetTheme("Dark");
}
private void YmapNewEntityMenu_Click(object sender, EventArgs e)
{
NewEntity();
}
private void YmapNewCarGenMenu_Click(object sender, EventArgs e)
{
NewCarGen();
}
private void YmapAddToProjectMenu_Click(object sender, EventArgs e)
{
AddYmapToProject(CurrentYmapFile);
}
private void YmapRemoveFromProjectMenu_Click(object sender, EventArgs e)
{
RemoveYmapFromProject();
}
private void YtypNewArchetypeMenu_Click(object sender, EventArgs e)
{
//NewArchetype();
}
private void YtypAddToProjectMenu_Click(object sender, EventArgs e)
{
AddYtypToProject(CurrentYtypFile);
}
private void YtypRemoveFromProjectMenu_Click(object sender, EventArgs e)
{
RemoveYtypFromProject();
}
private void YndNewNodeMenu_Click(object sender, EventArgs e)
{
NewPathNode();
}
private void YndAddToProjectMenu_Click(object sender, EventArgs e)
{
AddYndToProject(CurrentYndFile);
}
private void YndRemoveFromProjectMenu_Click(object sender, EventArgs e)
{
RemoveYndFromProject();
}
private void YnvNewPolygonMenu_Click(object sender, EventArgs e)
{
NewNavPoly();
}
private void YnvAddToProjectMenu_Click(object sender, EventArgs e)
{
AddYnvToProject(CurrentYnvFile);
}
private void YnvRemoveFromProjectMenu_Click(object sender, EventArgs e)
{
RemoveYnvFromProject();
}
private void TrainsNewNodeMenu_Click(object sender, EventArgs e)
{
NewTrainNode();
}
private void TrainsAddToProjectMenu_Click(object sender, EventArgs e)
{
AddTrainTrackToProject(CurrentTrainTrack);
}
private void TrainsRemoveFromProjectMenu_Click(object sender, EventArgs e)
{
RemoveTrainTrackFromProject();
}
private void ScenarioNewPointMenu_Click(object sender, EventArgs e)
{
CurrentScenarioNode = null;
NewScenarioNode();
}
private void ScenarioNewPointFromSelectedMenu_Click(object sender, EventArgs e)
{
NewScenarioNode();
}
private void ScenarioNewEntityOverrideMenu_Click(object sender, EventArgs e)
{
AddScenarioEntity();
}
private void ScenarioNewChainMenu_Click(object sender, EventArgs e)
{
AddScenarioChain();
}
private void ScenarioNewClusterMenu_Click(object sender, EventArgs e)
{
AddScenarioCluster();
}
private void ScenarioImportChainMenu_Click(object sender, EventArgs e)
{
ImportScenarioChain();
}
private void ScenarioAddToProjectMenu_Click(object sender, EventArgs e)
{
AddScenarioToProject(CurrentScenario);
}
private void ScenarioRemoveFromProjectMenu_Click(object sender, EventArgs e)
{
RemoveScenarioFromProject();
}
private void ToolsManifestGeneratorMenu_Click(object sender, EventArgs e)
{
ShowEditProjectManifestPanel(false);
}
private void ToolsImportMenyooXmlMenu_Click(object sender, EventArgs e)
{
ImportMenyooXml();
}
private void RenderShowGtavMapMenu_Click(object sender, EventArgs e)
{
RenderShowGtavMapMenu.Checked = !RenderShowGtavMapMenu.Checked;
hidegtavmap = !RenderShowGtavMapMenu.Checked;
}
private void RenderShowProjectItemsMenu_Click(object sender, EventArgs e)
{
RenderShowProjectItemsMenu.Checked = !RenderShowProjectItemsMenu.Checked;
renderitems = RenderShowProjectItemsMenu.Checked;
}
private void ToolbarNewButton_ButtonClick(object sender, EventArgs e)
{
if (CurrentProjectFile == null)
{
NewProject();
}
else
{
NewYmap();
}
}
private void ToolbarNewProjectMenu_Click(object sender, EventArgs e)
{
NewProject();
}
private void ToolbarNewYmapMenu_Click(object sender, EventArgs e)
{
NewYmap();
}
private void ToolbarNewYtypMenu_Click(object sender, EventArgs e)
{
NewYtyp();
}
private void ToolbarNewYndMenu_Click(object sender, EventArgs e)
{
NewYnd();
}
private void ToolbarNewYnvMenu_Click(object sender, EventArgs e)
{
NewYnv();
}
private void ToolbarNewTrainsMenu_Click(object sender, EventArgs e)
{
NewTrainTrack();
}
private void ToolbarNewScenarioMenu_Click(object sender, EventArgs e)
{
NewScenario();
}
private void ToolbarOpenButton_ButtonClick(object sender, EventArgs e)
{
if (CurrentProjectFile == null)
{
OpenProject();
}
else
{
OpenYmap();
}
}
private void ToolbarOpenProjectMenu_Click(object sender, EventArgs e)
{
OpenProject();
}
private void ToolbarOpenYmapMenu_Click(object sender, EventArgs e)
{
OpenYmap();
}
private void ToolbarOpenYtypMenu_Click(object sender, EventArgs e)
{
OpenYtyp();
}
private void ToolbarOpenYndMenu_Click(object sender, EventArgs e)
{
OpenYnd();
}
private void ToolbarOpenYnvMenu_Click(object sender, EventArgs e)
{
OpenYnv();
}
private void ToolbarOpenTrainsMenu_Click(object sender, EventArgs e)
{
OpenTrainTrack();
}
private void ToolbarOpenScenarioMenu_Click(object sender, EventArgs e)
{
OpenScenario();
}
private void ToolbarSaveButton_Click(object sender, EventArgs e)
{
Save();
}
private void ToolbarSaveAllButton_Click(object sender, EventArgs e)
{
SaveAll();
}
}
}
Reference in New Issue View Git Blame Copy Permalink