private static void AddRectangleCloneAtXY(MapLayer layer, float tileDimension, AxisAlignedRectangle rectangle, List <uint> tiles, long tilesetTileGid, int x, int y,
TileCollisions.TileShapeCollection collectionForThisName)
{
var i = y * layer.width + x;
var strippedId = tiles[i] & 0x0fffffff;
if (strippedId == tilesetTileGid)
{
float xIndex = i % layer.width;
// intentional int division
float yIndex = i / layer.width;
var cloned = rectangle.Clone();
// Offset by .5 since polygons are positioned by their center, tiles by top left
//cloned.X = (xIndex + .5f) * tileDimension;
//cloned.Y = -(yIndex + .5f) * tileDimension;
// Actually use the X and Y to get the top left, then use the actual rectangle's X and Y values so that
// its offset applies:
cloned.X = rectangle.X + (xIndex) * tileDimension;
cloned.Y = rectangle.Y - (yIndex) * tileDimension;
collectionForThisName.Rectangles.Add(cloned);
}
}
private static void AddRectangleCloneAtXY(MapLayer layer, float tileDimension, AxisAlignedRectangle rectangle, List <uint> tiles, long tilesetTileGid, int x, int y,
Dictionary <string, TileCollisions.TileShapeCollection> dictionary, ref TileCollisions.TileShapeCollection collectionForThisName)
{
var i = y * layer.width + x;
var stripedId = tiles[i] & 0x0fffffff;
if (stripedId == tilesetTileGid)
{
if (collectionForThisName == null)
{
collectionForThisName = GetOrAddTileShapeCollection(rectangle.Name ?? layer.Name, dictionary);
}
float xIndex = i % layer.width;
// intentional int division
float yIndex = i / layer.width;
var cloned = rectangle.Clone();
// Offset by .5 since polygons are positioned by their center, tiles by top left
cloned.X = (xIndex + .5f) * tileDimension;
cloned.Y = -(yIndex + .5f) * tileDimension;
collectionForThisName.Rectangles.Add(cloned);
}
}
private static void AddRectangleCloneAtXY(MapLayer layer, float tileDimension, TileCollisions.TileShapeCollection toReturn, AxisAlignedRectangle rectangle, List <uint> tiles, long tilesetTileGid, int x, int y)
{
var i = y * layer.width + x;
if (tiles[i] == tilesetTileGid)
{
float xIndex = i % layer.width;
// intentional int division
float yIndex = i / layer.width;
var cloned = rectangle.Clone();
// Offset by .5 since polygons are positioned by their center, tiles by top left
cloned.X = (xIndex + .5f) * tileDimension;
cloned.Y = -(yIndex + .5f) * tileDimension;
toReturn.Rectangles.Add(cloned);
}
}
/// <summary>
/// Creates a runtime object and adds the LoadedFile to the element.
/// </summary>
/// <param name="objectToLoad"></param>
/// <param name="container"></param>
/// <param name="elementRuntime"></param>
/// <param name="objectType"></param>
/// <param name="objectJustLoaded"></param>
/// <param name="newElementRuntime"></param>
/// <param name="toAddTo"></param>
/// <param name="layerToAddTo"></param>
/// <param name="rfs"></param>
/// <param name="pullsFromEntireNamedObject"></param>
/// <returns></returns>
private static LoadedFile CreateRuntimeObjectForNamedObject(NamedObjectSave objectToLoad,
IElement container, ElementRuntime elementRuntime, string objectType,
LoadedFile objectJustLoaded,
ElementRuntime newElementRuntime,
object toAddTo,
Layer layerToAddTo, ReferencedFileSave rfs, bool pullsFromEntireNamedObject)
{
var fileName = ElementRuntime.ContentDirectory + objectToLoad.SourceFile;
bool shouldClone = rfs != null && (rfs.IsSharedStatic && !(container is ScreenSave)) && !pullsFromEntireNamedObject;
LoadedFile toReturn = null;
// This could have a ( in the name in a file like .scnx, so use the last (
//int indexOfType = objectToLoad.SourceName.IndexOf("(");
int indexOfType = objectToLoad.SourceName.LastIndexOf("(");
string objectName = objectToLoad.SourceName.Substring(0, indexOfType - 1);
switch (objectType)
{
case "Scene":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
foreach (Text text in scene.Texts)
{
text.AdjustPositionForPixelPerfectDrawing = true;
if (ObjectFinder.Self.GlueProject.UsesTranslation)
{
text.DisplayText = LocalizationManager.Translate(text.DisplayText);
}
}
if (shouldClone)
{
scene = scene.Clone();
elementRuntime.EntireScenes.Add(objectToLoad.SourceFile, scene);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = scene;
loadedFile.FilePath = objectToLoad.SourceFile;
loadedFile.ReferencedFileSave = rfs;
toReturn = loadedFile;
newElementRuntime.ReferencedFileRuntimeList.Add(loadedFile);
scene.AddToManagers(layerToAddTo);
}
}
break;
case "Sprite":
{
Sprite loadedSprite = null;
Scene scene = objectJustLoaded.RuntimeObject as Scene;
if (scene != null)
{
loadedSprite = scene.Sprites.FindByName(objectName);
}
if (loadedSprite == null)
{
System.Windows.Forms.MessageBox.Show("There is a missing Sprite called\n\n" + objectName + "\n\n" +
"in the object\n\n" + elementRuntime.Name + "\n\n" +
"This probably happened if someone changed the name of a Sprite in a .scnx file but didn't update " +
"the associated object in Glue", "Missing Sprite");
}
else
{
if (shouldClone)
{
loadedSprite = loadedSprite.Clone();
(toAddTo as Scene).Sprites.Add(loadedSprite);
SpriteManager.AddToLayer(loadedSprite, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedSprite;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
}
break;
case "SpriteFrame":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
SpriteFrame loadedSpriteFrame = scene.SpriteFrames.FindByName(objectName);
if (loadedSpriteFrame != null)
{
if (shouldClone)
{
loadedSpriteFrame = loadedSpriteFrame.Clone();
(toAddTo as Scene).SpriteFrames.Add(loadedSpriteFrame);
SpriteManager.AddToLayer(loadedSpriteFrame, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedSpriteFrame;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
}
break;
case "SpriteGrid":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
SpriteGrid spriteGrid = null;
for (int i = 0; i < scene.SpriteGrids.Count; i++)
{
if (scene.SpriteGrids[i].Name == objectName)
{
spriteGrid = scene.SpriteGrids[i];
break;
}
}
if (spriteGrid != null)
{
if (shouldClone)
{
spriteGrid = spriteGrid.Clone();
(toAddTo as Scene).SpriteGrids.Add(spriteGrid);
spriteGrid.Layer = layerToAddTo;
spriteGrid.PopulateGrid();
spriteGrid.RefreshPaint();
spriteGrid.Manage();
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = spriteGrid;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
}
break;
case "Text":
{
Scene scene = objectJustLoaded.RuntimeObject as Scene;
Text loadedText = scene.Texts.FindByName(objectName);
if (loadedText != null)
{
if (shouldClone)
{
loadedText = loadedText.Clone();
(toAddTo as Scene).Texts.Add(loadedText);
TextManager.AddToLayer(loadedText, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedText;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
loadedText.AdjustPositionForPixelPerfectDrawing = true;
if (LocalizationManager.HasDatabase)
{
loadedText.DisplayText = LocalizationManager.Translate(loadedText.DisplayText);
}
}
}
break;
case "ShapeCollection":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
if (shouldClone)
{
shapeCollection = shapeCollection.Clone();
elementRuntime.EntireShapeCollections.Add(objectToLoad.SourceFile, shapeCollection);
newElementRuntime.ReferencedFileRuntimeList.LoadedShapeCollections.Add(shapeCollection);
shapeCollection.AddToManagers(layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = shapeCollection;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
// Most cases are handled below in an AttachTo method, but
// ShapeCollection isn't a PositionedObject so we have to do it manually here
if (objectToLoad.AttachToContainer)
{
shapeCollection.AttachTo(elementRuntime, true);
}
}
break;
case "AxisAlignedCube":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
AxisAlignedCube loadedAxisAlignedCube = shapeCollection.AxisAlignedCubes.FindByName(objectName);
if (shouldClone)
{
loadedAxisAlignedCube = loadedAxisAlignedCube.Clone();
(toAddTo as ShapeCollection).AxisAlignedCubes.Add(loadedAxisAlignedCube);
ShapeManager.AddToLayer(loadedAxisAlignedCube, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedAxisAlignedCube;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "AxisAlignedRectangle":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
AxisAlignedRectangle loadedAxisAlignedRectangle = shapeCollection.AxisAlignedRectangles.FindByName(objectName);
if (shouldClone)
{
loadedAxisAlignedRectangle = loadedAxisAlignedRectangle.Clone();
(toAddTo as ShapeCollection).AxisAlignedRectangles.Add(loadedAxisAlignedRectangle);
ShapeManager.AddToLayer(loadedAxisAlignedRectangle, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedAxisAlignedRectangle;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Circle":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Circle loadedCircle = shapeCollection.Circles.FindByName(objectName);
if (shouldClone)
{
loadedCircle = loadedCircle.Clone();
(toAddTo as ShapeCollection).Circles.Add(loadedCircle);
ShapeManager.AddToLayer(loadedCircle, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedCircle;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Polygon":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Polygon loadedPolygon = shapeCollection.Polygons.FindByName(objectName);
if (shouldClone)
{
loadedPolygon = loadedPolygon.Clone();
(toAddTo as ShapeCollection).Polygons.Add(loadedPolygon);
ShapeManager.AddToLayer(loadedPolygon, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedPolygon;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Sphere":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Sphere loadedSphere = shapeCollection.Spheres.FindByName(objectName);
if (shouldClone)
{
loadedSphere = loadedSphere.Clone();
(toAddTo as ShapeCollection).Spheres.Add(loadedSphere);
ShapeManager.AddToLayer(loadedSphere, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedSphere;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Capsule2D":
{
ShapeCollection shapeCollection = objectJustLoaded.RuntimeObject as ShapeCollection;
Capsule2D loadedCapsule2D = shapeCollection.Capsule2Ds.FindByName(objectName);
if (shouldClone)
{
loadedCapsule2D = loadedCapsule2D.Clone();
(toAddTo as ShapeCollection).Capsule2Ds.Add(loadedCapsule2D);
ShapeManager.AddToLayer(loadedCapsule2D, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedCapsule2D;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Emitter":
{
EmitterList emitterList = objectJustLoaded.RuntimeObject as EmitterList;
Emitter loadedEmitter = emitterList.FindByName(objectName);
if (shouldClone && loadedEmitter != null)
{
loadedEmitter = loadedEmitter.Clone();
(toAddTo as EmitterList).Add(loadedEmitter);
SpriteManager.AddEmitter(loadedEmitter, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = loadedEmitter;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "EmitterList":
{
EmitterList emitterList = objectJustLoaded.RuntimeObject as EmitterList;
if (shouldClone && emitterList != null)
{
emitterList = emitterList.Clone();
foreach (var item in emitterList)
{
SpriteManager.AddEmitter(item);
}
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = emitterList;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "NodeNetwork":
{
NodeNetwork nodeNetwork = objectJustLoaded.RuntimeObject as NodeNetwork;
if (shouldClone)
{
nodeNetwork = nodeNetwork.Clone();
elementRuntime.EntireNodeNetworks.Add(objectToLoad.SourceFile, nodeNetwork);
newElementRuntime.ReferencedFileRuntimeList.LoadedNodeNetworks.Add(nodeNetwork);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = nodeNetwork;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "SplineList":
{
SplineList splineList = objectJustLoaded.RuntimeObject as SplineList;
if (shouldClone)
{
splineList = splineList.Clone();
elementRuntime.EntireSplineLists.Add(splineList.Name, splineList);
foreach (var spline in splineList)
{
spline.CalculateVelocities();
spline.CalculateAccelerations();
}
splineList.AddToManagers();
splineList[0].UpdateShapes();
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = splineList;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
}
break;
case "Spline":
{
SplineList splineList = objectJustLoaded.RuntimeObject as SplineList;
Spline spline = splineList.FirstOrDefault(item => item.Name == objectName);
if (shouldClone && spline != null)
{
spline = spline.Clone();
(toAddTo as SplineList).Add(spline);
// Eventually support layers?
//ShapeManager.AddToLayer(spline, layerToAddTo);
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = spline;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
}
spline.CalculateVelocities();
spline.CalculateAccelerations();
}
break;
}
if (toReturn == null)
{
foreach (var manager in ReferencedFileRuntimeList.FileManagers)
{
var objectFromFile = manager.TryGetObjectFromFile(elementRuntime.ReferencedFileRuntimeList.LoadedRfses, rfs, objectType, objectName);
if (objectFromFile != null)
{
var runtimeObject = objectFromFile;
var loadedFile = new LoadedFile();
loadedFile.RuntimeObject = runtimeObject;
loadedFile.FilePath = objectJustLoaded.FilePath;
loadedFile.DataModel = objectJustLoaded.DataModel;
loadedFile.ReferencedFileSave = objectJustLoaded.ReferencedFileSave;
toReturn = loadedFile;
break;
}
}
}
if (toReturn != null && objectToLoad.AttachToContainer)
{
if (toReturn.RuntimeObject is PositionedObject)
{
// If the object is already attached to something, that means it
// came from a file, so we don't want to re-attach it.
PositionedObject asPositionedObject = toReturn.RuntimeObject as PositionedObject;
if (asPositionedObject.Parent == null)
{
asPositionedObject.AttachTo(elementRuntime, true);
}
}
else if (toReturn.RuntimeObject is Scene)
{
((Scene)toReturn.RuntimeObject).AttachAllDetachedTo(elementRuntime, true);
}
else if (toReturn.RuntimeObject is ShapeCollection)
{
((ShapeCollection)toReturn.RuntimeObject).AttachAllDetachedTo(elementRuntime, true);
}
}
return(toReturn);
}
