/// <summary>
/// Creates the planes of a bridge, The first and last one
/// </summary>
Trail CreateBridgePlanes(Trail current, RegFile regFile)
{
if (regFile.DominantSide == H.Vertic)
{
current.PlanesListVertic.Add(CreatePlane.CreatePlan(Root.createPlane,
Root.RetMaterialRoot(regFile.MaterialKey),
regFile.TilePosVert[0], scale: regFile.TileScale, container: current.transform));
current.PlanesListVertic.Add(CreatePlane.CreatePlan(Root.createPlane,
Root.RetMaterialRoot(regFile.MaterialKey),
regFile.TilePosVert[regFile.TilePosVert.Count - 1], scale: regFile.TileScale,
container: current.transform));
}
else if (regFile.DominantSide == H.Horiz)
{
current.PlanesListHor.Add(CreatePlane.CreatePlan(Root.createPlane,
Root.RetMaterialRoot(regFile.MaterialKey),
regFile.TilePosHor[0], scale: regFile.TileScale, container: current.transform));
current.PlanesListHor.Add(CreatePlane.CreatePlan(Root.createPlane,
Root.RetMaterialRoot(regFile.MaterialKey),
regFile.TilePosHor[regFile.TilePosHor.Count - 1], scale: regFile.TileScale,
container: current.transform));
}
return(current);
}
/// <summary>
/// Created to avoid exception that key exist already
/// </summary>
void AddToAll(RegFile regFile)
{
var key = regFile.MyId;
//if key exsit will add this number at the end .
//This can happen when spawing a building and an old building has the same name and ID #
if (_allBuilding.ContainsKey(key))
{
key = key + "1983";
}
regFile.MyId = key;
var build = BuildingPot.Control.CurrentSpawnBuild;
//means is a CancelDemolish
if (build == null)
{
build = SelectBuilding;
BuildingPot.Control.CurrentSpawnBuild = SelectBuilding;
}
build.MyId = key;
build.transform.name = key;
AllRegFile.Add(regFile);
_allBuilding.Add(key, build);
}
private void saveButton_Click(object sender, EventArgs e)
{
if (data == null)
{
return;
}
RegFile file = Registry.regFiles.Find(x => x.size == data.Length);
if (file == null && BitConverter.ToUInt32(data, 4) == 0x2A2A2A2A)
{
file = Registry.regFiles.Find(x => x.storage == "regdatahdd.db");
}
SaveFileDialog fileDialog = new SaveFileDialog();
fileDialog.Filter = "All files (*.*)|*.*";
fileDialog.FileName = file.file.Split('/')[3];
fileDialog.RestoreDirectory = true;
if (fileDialog.ShowDialog() == DialogResult.OK)
{
using (BinaryWriter writer = new BinaryWriter(File.Open(fileDialog.FileName, FileMode.Create)))
{
writer.Write(data);
}
}
}
/// <summary>
/// Will create a draggable category building (Farm, StockPile, Farm)
/// </summary>
void CreateDraggableSquare(RegFile regFile)
{
Control.CurrentSpawnBuild = Way.CreateWayObj(Root.farm, regFile.IniPos,
previewObjRoot: Root.previewTrail, hType: regFile.HType, isLoadingFromFile: true
, container: Program.BuildsContainer.transform);
Control.CurrentSpawnBuild.MyId = regFile.MyId;
Control.CurrentSpawnBuild.transform.name = regFile.MyId;
DragSquare f = (DragSquare)Control.CurrentSpawnBuild;
f.PlanesSoil = CreatePlanes(regFile.PlaneOnAirPos, f.transform, regFile.TileScale, regFile.MaterialKey, Control.CurrentSpawnBuild);
f.AddBoxCollider(regFile);
f.PositionFixed = true;
f.PeopleDict = regFile.PeopleDict;
f.transform.position = regFile.IniPos;
Program.gameScene.BatchAdd(f);
Control.Registro.DragSquares.Add(regFile.MyId, Control.CurrentSpawnBuild as DragSquare);
Control.Registro.AllBuilding.Add(regFile.MyId, Control.CurrentSpawnBuild);
}
private void saveButton_Click(object sender, EventArgs e)
{
if (_data == null)
{
return;
}
var file = RegFile.Open(_data);
if (file == null)
{
MessageBox.Show(@"Error saving file!");
return;
}
var fileDialog = new SaveFileDialog
{
Filter = @"All files (*.*)|*.*",
FileName = file.File.Split('/')[3],
RestoreDirectory = true
};
if (fileDialog.ShowDialog() == DialogResult.OK)
{
using (var fs = File.Open(fileDialog.FileName, FileMode.Create))
{
fs.Write(_data, 0, _data.Length);
}
}
}
/// <summary>
/// Will update Propersties on AllRegFile so when is saved is there to be loaded
///
/// Prop that Update so far:
/// BookedHome1
/// Instruction
/// Families
/// Invetory
/// PeopleDic
/// PositionFilled
/// Anchors
/// DollarsPay
/// Dock1
/// PlantSave1
/// /// Dispatch
/// BuildersManager1
/// CurrentProd
/// </summary>
public void ResaveOnRegistro(RegFile regFile, Building build, bool anchorsIsOn)
{
regFile.BookedHome1 = build.BookedHome1;
regFile.Instruction = build.Instruction;
regFile.Familes = build.Families;
regFile.Inventory = build.Inventory;
regFile.PeopleDict = build.PeopleDict;
//only need to be resave when Loaded Town spanws
if (anchorsIsOn && !build.MyId.Contains("Bridge"))
{
regFile.Anchors = build.Anchors.ToArray();
}
regFile.DollarsPay = build.DollarsPay;
regFile.Dock1 = build.Dock1;
regFile.Dispatch1 = build.Dispatch1;
regFile.BuildersManager1 = build.BuildersManager1;
regFile.PlantSave1 = build.PlantSave1;
regFile.CurrentProd = build.CurrentProd;
regFile.ProductionReport = build.ProductionReport;
regFile.MaxPeople = build.MaxPeople;
regFile.Name = build.NameBuilding();
}
//this cretes planes vertically and horizontally
List <CreatePlane> CreatePlanesVertAndHor(RegFile regFile, H which, Transform containerP, Trail trail)
{
List <CreatePlane> res = new List <CreatePlane>();
if (which == H.Vertic)
{
for (int i = 0; i < regFile.TilePosVert.Count; i++)
{
res.Add(CreatePlane.CreatePlan(Root.createPlane, Root.RetMaterialRoot(regFile.MaterialKey),
regFile.TilePosVert[i], scale: regFile.TileScale, container: containerP));
//to Refine
//Trail.AddToCrystals(H.PlanesVertic, i, regFile.TilePosVert[i], regFile.TilePosVert.Count,
// regFile.TilePosHor.Count, trail);
}
}
else if (which == H.Horiz)
{
for (int i = 0; i < regFile.TilePosHor.Count; i++)
{
res.Add(CreatePlane.CreatePlan(Root.createPlane, Root.RetMaterialRoot(regFile.MaterialKey),
regFile.TilePosHor[i], scale: regFile.TileScale, container: containerP));
//to Refine
//Trail.AddToCrystals(H.PlanesHor, i, regFile.TilePosHor[i], regFile.TilePosVert.Count,
// regFile.TilePosHor.Count, trail);
}
}
return(res);
}
/// <summary>
/// Will add a poly with the seq NW, NE, SE, SW to the _allBuilding List. then will call UpdateCurrentVertexRect()
/// Adds the file to Registro All that is the save list to file of buildings
/// </summary>
public void AddBuildToAll(Building build, List <Vector3> poly, Ca categ, Vector3 iniPosition,
Inventory inventory,
List <string> PeopleDict,
List <VectorLand> LandZone1,
List <Vector3> polyHoriz = null,
List <Vector3> tilePosVert = null, List <Vector3> tilePosHor = null, List <Vector3> planesOnAirPos = null,
Vector3 tileScale = new Vector3(), List <int> parts = null,
H dominantSide = H.None, H startingStage = H.None, int rotationFacerIndex = -1, string materialKey = "",
List <Vector3> planesOnSoilPos = null, List <int> partsOnSoil = null, Vector3 min = new Vector3(),
Vector3 max = new Vector3(), H instructionP = H.None, BookedHome BookedHome1 = null,
Dispatch dispatch = null, Family[] Families = null,
int dollarsPay = 0,
List <Vector3> anchors = null, Dock dock = null, string root = "",
BuildersManager buildersManager = null
)
{
// 12 hours to find this OMG!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// I was creating the recatblgele and not inverting Y.. then I invert Y but didint inverted in
//IsColliding() chet !!!! And i knew it bz i inverted the big rectangle...
//with the rectangles inverted works like a charm... we have to do it bz im using North as bigger
//and south as less... in the Rect cordinates is the other way around
//this is the usual poly will be filled for eg regular structures only use this one.
//For ways is the vertic bound
var to = ReturnDimOnMap(poly);
Rect toHoriz = new Rect();
if (polyHoriz != null)
{
toHoriz = U2D.FromPolyToRect(polyHoriz);
toHoriz = U2D.ReturnRectYInverted(toHoriz);
}
//ading to All
RegFile regFile = new RegFile(build, to, categ, iniPosition,
inventory,
PeopleDict, LandZone1,
toHoriz, tilePosVert: tilePosVert, tilePosHor: tilePosHor,
planesOnAirPos: planesOnAirPos, tileScale: tileScale, partsOnAir: parts, dominantSide: dominantSide, startingStage: startingStage, rotationFacerIndex: rotationFacerIndex,
materialKey: materialKey, planesOnSoilPos: planesOnSoilPos, partsOnSoil: partsOnSoil, min: min, max: max,
instructionP: instructionP, bookedHome: BookedHome1, dispatch: dispatch, familes: Families,
dollarsPay: dollarsPay,
anchors: anchors, dock: dock, root: root,
buildersManager: buildersManager);
//UVisHelp.CreateHelpers(anchors, Root.blueCube);
AddToAll(regFile);
AddToBuilderManager(build.MyId);
AddSpecToList(categ);
if (_locHoverVert.Count > 0)
{
UpdateCurrentVertexRect(_locHoverVert);
}
//use on the drawing debug functionalitie only:
//toDraw.Add(to);
//toDraw.Add(toHoriz);
}
string FindRootForStructure(RegFile regFile)
{
if (!string.IsNullOrEmpty(regFile.Root))
{
return(regFile.Root);
}
return(Root.RetBuildingRoot(regFile.HType));
}
public void ImportVirtualRegistryFromFile(string RegFileName, RegistryKey key)
{
RegistryKey writeKey = null;
RegFile regFile = new RegFile(RegFileName);
RegFileRegistryKey regFileRegistryKey;
KeyValuePair <string, string> virtReplaceKey = new KeyValuePair <string, string>("-", "");
while (regFile.readKey(out regFileRegistryKey))
{
if (writeKey != null)
{
writeKey.Close();
}
writeKey = null;
if (!regFileRegistryKey.keyName.StartsWith(virtReplaceKey.Key + '\\'))
{
virtReplaceKey = new KeyValuePair <string, string>("-", "");
foreach (KeyValuePair <string, string> value in virtualKeys)
{
if (regFileRegistryKey.keyName.StartsWith(value.Key))
{
virtReplaceKey = value;
break;
}
}
}
if (virtReplaceKey.Key != "-")
{
String virtKey = regFileRegistryKey.keyName.Remove(0, virtReplaceKey.Key.Length).Insert(0, virtReplaceKey.Value);
writeKey = key.CreateSubKey(virtKey);
}
else
{
regFile.errors.Append("\r\n\r\n#### Registry root key not supported in current import:" + regFileRegistryKey.keyName + " ####\r\n");
}
if (writeKey != null)
{
foreach (RegFileRegistryValue regFileRegistryValue in regFileRegistryKey.values)
{
if (regFileRegistryValue.type != RegistryValueKind.Unknown)
{
writeKey.SetValue(regFileRegistryValue.name, regFileRegistryValue.value, regFileRegistryValue.type);
}
}
}
}
regFile.Close();
if (regFile.errors.Length > 0)
{
MessageBox.Show("The following errors occured while importing the .reg file: " + regFile.errors);
}
}
/// <summary>
/// Creates the parts of a bridge visualiiy
/// </summary>
/// <param name="iniPos"></param>
List <StructureParent> CreateBridgePartList(RegFile regFile, Transform containerP)
{
List <StructureParent> res = new List <StructureParent>();
//below brdige instance is a dummy instance. Only useed to instantiate parts
Bridge b = new Bridge(regFile.HType, regFile.StartingStage);
res = b.CreatePartListOnAir(regFile.PlaneOnAirPos, regFile.PartsOnAir, containerP, regFile.DominantSide);
res.AddRange(b.CreatePartListOnGround(regFile.PlanesOnSoil, regFile.PartsOnSoil, containerP, regFile.DominantSide));
return(res);
}
/// <summary>
/// Creates the the new building, category: structure
/// </summary>
private void CreateStructure(RegFile regFile)
{
Control.CurrentSpawnBuild = Building.CreateBuild(FindRootForStructure(regFile), regFile.IniPos,
regFile.HType, isLoadingFromFile: true, materialKey: regFile.MaterialKey
, container: Program.BuildsContainer.transform);
//this is part of the Reduce Draw calls experiment
//Material n = Batcher.BuildsStatic[H.Tavern + "." + Ma.matBuildBase];
//n.name = "BaseOriginalRenamed";
//Control.CurrentSpawnBuild.Geometry.renderer.sharedMaterial = n;
Control.CurrentSpawnBuild.MyId = regFile.MyId;
Control.CurrentSpawnBuild.transform.name = regFile.MyId;
Structure s = Control.CurrentSpawnBuild as Structure;
s.StartingStage = regFile.StartingStage;
s.HType = regFile.HType;
s.Category = regFile.Category;
s.RotationFacerIndex = regFile.RotationFacerIndex;
s.PositionFixed = true;
s.Inventory = regFile.Inventory;
s.Instruction = regFile.Instruction;
s.PeopleDict = regFile.PeopleDict;
s.BookedHome1 = regFile.BookedHome1;
s.Dispatch1 = regFile.Dispatch1;
if (regFile.HType == H.Masonry)
{
var a = 1;
}
s.BuildersManager1 = regFile.BuildersManager1;
s.Families = regFile.Familes;
s.LandZone1 = regFile.LandZone1;
s.DollarsPay = regFile.DollarsPay;
s.Dock1 = regFile.Dock1;
s.PlantSave1 = regFile.PlantSave1;
s.CurrentProd = regFile.CurrentProd;
s.Anchors = regFile.Anchors.ToList();
s.ProductionReport = regFile.ProductionReport;
s.MaxPeople = regFile.MaxPeople;
s.Decoration1 = regFile.Decoration;
s.Name = regFile.Name;
Program.gameScene.BatchAdd(s);
Control.Registro.Structures.Add(s.MyId, Control.CurrentSpawnBuild as Structure);
Control.Registro.AllBuilding.Add(s.MyId, Control.CurrentSpawnBuild);
}
protected void bt_GetRemPS_Click(object sender, EventArgs e)
{
try
{
REG2CI.RegFile oReg = new RegFile(tb_REG.Text, "REG2PS");
string sRes = oReg.GetPSRemediateAll();
tb_PSSCript.Text = sRes.Replace("&", "&").Replace("<", "<").Replace(">", ">");
}
catch
{
ShowMessage("please upload your Registry content to https://github.com/rzander/Reg2CI/issues ", MessageType.Error);
}
}
private bool ReadInputFiles()
{
foreach (string filename in Filenames)
{
Console.WriteLine("Reading {0}...", filename);
IRegistryImporter importer = null;
try
{
if (File.Exists(filename))
{
if (filename.EndsWith(".xml", StringComparison.OrdinalIgnoreCase))
{
importer = new XmlRegFileImporter(File.ReadAllText(filename));
}
else if (filename.EndsWith(".reg", StringComparison.OrdinalIgnoreCase))
{
importer = RegFile.CreateImporterFromFile(filename, Options);
}
}
if (importer == null)
{
string rootPathWithoutHive;
RegistryKey key = Regis3.OpenRegistryHive(filename, out rootPathWithoutHive, CurrentRegistryView);
if (key != null)
{
importer = new RegistryImporter(key, rootPathWithoutHive);
}
else
{
importer = RegFile.CreateImporterFromFile(filename, Options);
}
}
Files.Add(importer.Import());
}
catch (System.Data.SyntaxErrorException e)
{
Console.WriteLine(e.Message);
return(false);
}
}
if (CompareAgainstRegistry)
{
Files.Add(new RegistryImportRelativeToExistingRegKeyEntry(Files[0], CurrentRegistryView).Import());
Filenames.Add("REGISTRY");
}
Console.WriteLine();
return(true);
}
/// <summary>
/// Routine that create all the building based on the category
/// that regFile brings
/// </summary>
/// <param name="regFile">The file that has all the information to load a new building</param>
void CreateAllBuildings(RegFile regFile)
{
if (regFile.Category == Ca.Structure || regFile.Category == Ca.Shore)
{
CreateStructure(regFile);
}
else if (regFile.Category == Ca.Way)
{
CreateWay(regFile);
}
else if (regFile.Category == Ca.DraggableSquare)
{
CreateDraggableSquare(regFile);
}
}
protected void bt_GetRemPS_Click(object sender, EventArgs e)
{
REG2CI.RegFile oReg = new RegFile(tb_REG.Text, "REG2PS");
tb_PSSCript.Text = oReg.GetPSRemediateAll();
}
protected void bt_Compile_Click(object sender, EventArgs e)
{
REG2CI.RegFile oReg = new RegFile(tb_REG.Text, "REG2PS");
tb_PSSCript.Text = oReg.GetPSCheckAll();
}
/// <summary>
/// TODO: Method too long, unify and outsource some code
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OpenFileButton_Click(object sender, EventArgs e)
{
var fileDialog = new OpenFileDialog
{
Filter = @"|*.*||system.idx;system.dat;system.eap;system.rec",
RestoreDirectory = true
};
if (fileDialog.ShowDialog() == DialogResult.OK)
{
_data = File.ReadAllBytes(fileDialog.FileName);
var file = RegFile.Open(_data);
if (file == null)
{
MessageBox.Show("Invalid registry file!\nOpen system.idx or system.dat or system.eap or system.rec !");
return;
}
if (file.Storage == "regcont_eap.db")
{
_registry = new ObfuscatedContainerReader(_data, false);
}
else if (file.Storage == "regi.recover")
{
_registry = new ObfuscatedContainerReader(_data, true);
}
else
{
if (file.Storage == "regcont.db")
{
var idx = _data;
fileDialog = new OpenFileDialog
{
Filter = @"|system.dat||*.*",
RestoreDirectory = true
};
if (fileDialog.ShowDialog() == DialogResult.OK)
{
_data = File.ReadAllBytes(fileDialog.FileName);
file = RegFile.Open(_data);
if (file == null || file.Storage != "regdatahdd.db")
{
MessageBox.Show(@"Invalid system.dat !");
return;
}
_registry = new DataContainerReader(_data, idx);
}
}
else if (file.Storage == "regdatahdd.db")
{
fileDialog = new OpenFileDialog
{
Filter = @"|system.idx||*.*",
RestoreDirectory = true
};
if (fileDialog.ShowDialog() == DialogResult.OK)
{
var idx = File.ReadAllBytes(fileDialog.FileName);
file = Preferences.RegFiles.Find(x => x.Size == idx.Length);
if (file == null || file.Storage != "regcont.db")
{
MessageBox.Show(@"Invalid system.idx !");
return;
}
_registry = new DataContainerReader(_data, idx);
}
}
}
listView.Clear();
var header = new ColumnHeader {
Width = listView.Width
};
listView.Columns.Add(header);
listView.View = View.Details;
listView.HeaderStyle = ColumnHeaderStyle.None;
_registry.Entries.ForEach(x => listView.Items.Add(x.Category));
}
}
private void OpenFileButton_Click(object sender, EventArgs e)
{
OpenFileDialog fileDialog = new OpenFileDialog();
fileDialog.Filter = "|*.*||system.idx;system.dat;system.eap;system.rec";
fileDialog.RestoreDirectory = true;
if (fileDialog.ShowDialog() == DialogResult.OK)
{
data = File.ReadAllBytes(fileDialog.FileName);
RegFile file = Registry.regFiles.Find(x => x.size == data.Length);
if (file == null && BitConverter.ToUInt32(data, 4) == 0x2A2A2A2A)
{
file = Registry.regFiles.Find(x => x.storage == "regdatahdd.db");
}
if (file == null)
{
MessageBox.Show("Invalid registry file!\nOpen system.idx or system.dat or system.eap or system.rec !");
return;
}
if (file.storage == "regcont_eap.db")
{
registry = new Reader();
registry.ObfuscatedContainerReader(data, false);
}
else if (file.storage == "regi.recover")
{
registry = new Reader();
registry.ObfuscatedContainerReader(data, true);
}
else if (file.storage == "regcont.db")
{
byte[] idx = data;
fileDialog = new OpenFileDialog();
fileDialog.Filter = "|system.dat||*.*";
fileDialog.RestoreDirectory = true;
if (fileDialog.ShowDialog() == DialogResult.OK)
{
data = File.ReadAllBytes(fileDialog.FileName);
file = Registry.regFiles.Find(x => x.size == data.Length);
if (file == null && BitConverter.ToUInt32(data, 4) == 0x2A2A2A2A)
{
file = Registry.regFiles.Find(x => x.storage == "regdatahdd.db");
}
if (file == null || file.storage != "regdatahdd.db")
{
MessageBox.Show("Invalid system.dat !");
return;
}
registry = new Reader();
registry.DataContainerReader(data, idx);
}
}
else if (file.storage == "regdatahdd.db")
{
fileDialog = new OpenFileDialog();
fileDialog.Filter = "|system.idx||*.*";
fileDialog.RestoreDirectory = true;
if (fileDialog.ShowDialog() == DialogResult.OK)
{
byte[] idx = File.ReadAllBytes(fileDialog.FileName);
file = Registry.regFiles.Find(x => x.size == idx.Length);
if (file == null || file.storage != "regcont.db")
{
MessageBox.Show("Invalid system.idx !");
return;
}
registry = new Reader();
registry.DataContainerReader(data, idx);
}
}
listView.Clear();
ColumnHeader header = new ColumnHeader();
header.Width = listView.Width;
listView.Columns.Add(header);
listView.View = View.Details;
listView.HeaderStyle = ColumnHeaderStyle.None;
foreach (var entry in registry.entries)
{
listView.Items.Add(entry.category);
}
}
}
/// <summary>
/// Creates a new way object
/// </summary>
void CreateWay(RegFile regFile)
{
if (regFile.HType == H.Trail)
{
trail = (Trail)Way.CreateWayObj(Root.trail, regFile.IniPos,
previewObjRoot: Root.previewTrail, hType: H.Trail, isLoadingFromFile: true
, container: Program.BuildsContainer.transform);
}
else if (regFile.HType == H.BridgeTrail)
{
trail = (Bridge)
Way.CreateWayObj(Root.bridge, regFile.IniPos, previewObjRoot: Root.previewTrail,
hType: H.BridgeTrail, isLoadingFromFile: true
, container: Program.BuildsContainer.transform);
}
else if (regFile.HType == H.BridgeRoad)
{
trail = (Bridge)
Way.CreateWayObj(Root.bridge, regFile.IniPos, previewObjRoot: Root.previewRoad,
hType: H.BridgeRoad, wideSquare: 5, radius: 5f, planeScale: 0.11f, maxStepsWay: 20,
isLoadingFromFile: true
, container: Program.BuildsContainer.transform);
}
trail.CurrentLoop = H.Done;
trail.FinishPlacingMode(H.Done);
if (regFile.HType.ToString().Contains(H.Bridge.ToString()))
{
trail.Pieces = CreateBridgePartList(regFile, trail.transform);
}
trail.name = regFile.MyId;
trail.MyId = regFile.MyId;
trail.PeopleDict = regFile.PeopleDict;
trail.LandZone1 = regFile.LandZone1;
trail.Instruction = regFile.Instruction;
trail.MaterialKey = regFile.MaterialKey;
trail.Anchors = regFile.Anchors.ToList();
//if (trail.name.Contains("Bridge"))
//{
// UVisHelp.CreateHelpers(trail.Anchors, Root.blueCube);
//}
trail.StartingStage = regFile.StartingStage;
//if is not a bridge
if (!regFile.HType.ToString().Contains(H.Bridge.ToString()))
{
trail.PlanesListVertic = CreatePlanesVertAndHor(regFile, H.Vertic, trail.transform, trail);
trail.PlanesListHor = CreatePlanesVertAndHor(regFile, H.Horiz, trail.transform, trail);
}
else
{
trail = CreateBridgePlanes(trail, regFile);
trail.AddBoxCollider(regFile.Min, regFile.Max);
//trail.LandZoningBridge();
}
Program.gameScene.BatchAdd(trail);
Control.CurrentSpawnBuild = trail;
Control.Registro.Ways.Add(trail.MyId, Control.CurrentSpawnBuild as Way);
Control.Registro.AllBuilding.Add(trail.MyId, Control.CurrentSpawnBuild);
Control.CurrentSpawnBuild = null;
}
void writeRegKeyValues(StreamWriter sw, int rootKeyLen, RegistryKey key)
{
//string keyname = key.Name;
string keyname = "";
if (rootKeyLen > key.Name.Length)
{
return;//should only happen for the vos root HKCU\..TempVirtReg\myApp\registry
}
keyname = key.Name.Substring(rootKeyLen);
if (String.IsNullOrEmpty(keyname))
{
return;
}
bool found = false;
string keynameCheck = keyname + '\\';
foreach (KeyValuePair <String, String> rs in virtualKeys)
{
if (keynameCheck.StartsWith(rs.Value, StringComparison.InvariantCultureIgnoreCase))
{
keyname = keyname.Substring(rs.Value.Length).Insert(0, rs.Key);
found = true;
break;
}
}
if (!found)
{
MessageBox.Show(String.Format("Not yet implemented registry key: {0}", keyname));
return;
}
sw.WriteLine("[{0}]", keyname);
foreach (string valuename in key.GetValueNames())
{
object value = null;
String regvalue = null;
RegistryValueKind kind = key.GetValueKind(valuename);
string regvaluename = valuename.Replace("\\", "\\\\");
regvaluename = regvaluename.Replace("\"", "\\\"");
if (regvaluename.Length == 0)
{
regvaluename = "@";
}
else
{
regvaluename = "\"" + regvaluename + "\"";
}
if (kind != RegistryValueKind.Unknown)
{
value = key.GetValue(valuename);
}
switch (kind)
{
case RegistryValueKind.Binary:
System.Byte[] x = (System.Byte[])value;
regvalue = RegFileHelper.ByteArrayToHexComma(x);
RegFile.ByteArrayFormatString(ref regvalue, regvaluename.Length + 5);
regvalue = "hex:" + regvalue;
break;
case RegistryValueKind.DWord:
regvalue = string.Format("dword:{0:x8}", value);
break;
case RegistryValueKind.ExpandString:
byte[] bytes = Encoding.Unicode.GetBytes((String)value);
regvalue = RegFileHelper.ByteArrayToHexComma(bytes);
regvalue += (regvalue != "" ? "," : "") + "00,00";
RegFile.ByteArrayFormatString(ref regvalue, regvaluename.Length + 8);
regvalue = "hex(2):" + regvalue;
break;
case RegistryValueKind.MultiString:
string[] sa = (string[])value;
regvalue = "";
for (int m = 0; m < sa.Length; m++)
{
bytes = Encoding.Unicode.GetBytes((String)sa[m]);
regvalue += RegFileHelper.ByteArrayToHexComma(bytes);
regvalue = regvalue + ",00,00,";
}
regvalue = regvalue + "00,00";
RegFile.ByteArrayFormatString(ref regvalue, regvaluename.Length + 8);
regvalue = "hex(7):" + regvalue;
break;
case RegistryValueKind.QWord:
{
long l = (long)value;
bytes = System.BitConverter.GetBytes(l);
regvalue += RegFileHelper.ByteArrayToHexComma(bytes);
regvalue = "hex(b):" + regvalue;
break;
}
case RegistryValueKind.String:
regvalue = ((string)value).Replace("\\", "\\\\");
regvalue = regvalue.Replace("\"", "\\\"");
regvalue = string.Format("\"{0}\"", regvalue);
break;
case RegistryValueKind.Unknown:
regvalue = "hex(0):";
break;
default:
errors.Append(String.Format("\r\nWARNING: RegistryFunctions.enumRegKeyValues RegistryValueKind.{0} not supported", kind));
break;
}
sw.WriteLine("{0}={1}", regvaluename, regvalue);
}
sw.WriteLine("");
}
