static AddandRemoveObjects()
{
SceneView.onSceneGUIDelegate -= OnSceneGUI;
SceneView.onSceneGUIDelegate += OnSceneGUI;
m_levelObjects = AssetDatabase.LoadAssetAtPath <LevelObjects>("Assets/Scripts/ScriptableObjects/LevelObject/LevelObjects.asset");
}
static LevelEditor()
{
SceneView.duringSceneGui -= OnSceneGUI;
SceneView.duringSceneGui += OnSceneGUI;
levelObjects = AssetDatabase.LoadAssetAtPath <LevelObjects>("Assets/Level Objects.asset");
}
protected void Start()
{
if (this.levelObject != null)
{
return;
}
this.levelObject = new LevelObject(base.inspectablePosition, base.inspectableRotation, base.inspectableScale, 0, null, this.GUID, this.placementOrigin, this.instanceID, this.customMaterialOverride, true);
if (this.levelObject.transform == null)
{
Debug.LogError(string.Concat(new object[]
{
"Failed to create LevelObject - GUID: ",
this.GUID.ToString("N"),
" InstanceID: ",
this.instanceID,
" Position: ",
base.transform.position
}), base.gameObject);
this.levelObject = new LevelObject(base.inspectablePosition, base.inspectableRotation, base.inspectableScale, 0, null, new Guid("62f7de571873436a8c9a203e6304bd8a"), this.placementOrigin, this.instanceID, AssetReference <MaterialPaletteAsset> .invalid, true);
}
base.gameObject.tag = "Large";
base.gameObject.layer = this.levelObject.transform.gameObject.layer;
this.levelObject.transform.parent = base.transform;
this.levelObject.transform.localPosition = Vector3.zero;
this.levelObject.transform.localRotation = Quaternion.identity;
this.levelObject.transform.localScale = Vector3.one;
if (this.levelObject.skybox != null)
{
this.levelObject.skybox.transform.parent = base.transform;
this.levelObject.skybox.transform.localPosition = Vector3.zero;
this.levelObject.skybox.transform.localRotation = Quaternion.identity;
this.levelObject.skybox.transform.localScale = Vector3.one;
}
LevelObjects.registerDevkitObject(this.levelObject, out this.x, out this.y);
}
protected void OnEnable()
{
LevelHierarchy.addItem(this);
if (this.levelObject != null)
{
LevelObjects.registerDevkitObject(this.levelObject, out this.x, out this.y);
}
}
protected void OnDisable()
{
if (this.levelObject != null)
{
LevelObjects.unregisterDevkitObject(this.levelObject, this.x, this.y);
}
LevelHierarchy.removeItem(this);
}
public void SaveObjects(string levelType, int levelNum)
{
var sep = "/";
Debug.Log("Save Objects to " + Statics.folderPath + levelType + sep + "level" + levelNum + ".dat");
levelObjects = new LevelObjects();
string folderPath = Statics.folderPath + levelType + sep;
string filePath = folderPath + "level" + levelNum + ".dat";
var folder = Directory.CreateDirectory(folderPath);
ScreenCapture.CaptureScreenshot(folderPath + "level" + levelNum + ".png");
Debug.Log("Save Dots");
for (int i = 0; i < dots.Count; i++)
{
myVector3 position = dots[i].transform.position;
levelObjects.dotPositions.Add(position);
levelObjects.dotForwards.Add(dots[i].transform.forward);
var color = dots[i].GetComponent <SpriteRenderer> ().color;
levelObjects.dotColors.Add("#" + ColorUtility.ToHtmlStringRGB(color));
}
Debug.Log("Save Paths");
for (int i = 0; i < paths.Count; i++)
{
Debug.Log("Save Path " + i);
levelObjects.paths.Add(new List <myVector3> ());
levelObjects.normals.Add(new List <myVector3> ());
var path = paths[i];
for (int k = 0; k < path.Count; k++)
{
levelObjects.paths[i].Add(path.GetPosition(k));
}
for (int k = 0; k < path.GetNormals().Count; k++)
{
levelObjects.normals[i].Add(path.GetNormal(k));
}
var color = paths[i].GetColor();
levelObjects.pathColors.Add("#" + ColorUtility.ToHtmlStringRGB(color));
Debug.Log("Save From: " + path.dotFrom + " at " + dots.IndexOf(path.dotFrom));
levelObjects.dotsFrom.Add(dots.IndexOf(path.dotFrom));
Debug.Log("Save To: " + path.dotTo + " at " + dots.IndexOf(path.dotTo));
levelObjects.dotsTo.Add(dots.IndexOf(path.dotTo));
}
// Debug.Log ("Save Homotopies");
Debug.Log("Save Statics");
for (int i = 0; i < statics.Count; i++)
{
Debug.Log("Save Static " + i);
levelObjects.statics.Add(new myStatic(statics[i]));
}
FileStream fs = new FileStream(filePath, FileMode.Create);
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(fs, levelObjects);
fs.Close();
}
static void build_level(string path)
{
Debug.Log("Decode level");
LevelObjects lvlo = JsonUtility.FromJson <LevelObjects> (File.ReadAllText(path));
foreach (Object b in lvlo.Objects)
{
make(b.Box.X, b.Box.Y, b.Type);
}
}
protected override void addFoliage(Vector3 position, Quaternion rotation, Vector3 scale, bool clearWhenBaked)
{
ObjectAsset objectAsset = Assets.find <ObjectAsset>(this.obj);
if (objectAsset == null)
{
return;
}
LevelObjects.addDevkitObject(objectAsset.GUID, position, rotation, scale, (!clearWhenBaked) ? ELevelObjectPlacementOrigin.PAINTED : ELevelObjectPlacementOrigin.GENERATED);
}
public void transformSelection()
{
byte b;
byte b2;
if (Regions.tryGetCoordinate(base.transform.position, out b, out b2) && (this.x != b || this.y != b2))
{
LevelObjects.moveDevkitObject(this.levelObject, this.x, this.y, b, b2);
this.x = b;
this.y = b2;
}
}
public void Selectlevel(int lvlno)
{
LevelObjects levelObjects = GameObject.Find("AllLevelObjects").GetComponent <LevelObjects>();
levelObjects.m_player.SetActive(true);
levelObjects.m_levelScreenPage.SetActive(false);
if (!levelObjects.m_gameView.activeSelf)
{
levelObjects.m_gameView.SetActive(true);
}
level = null;
GameObject.Find("GameView").transform.position = new Vector3(0, 0, 0);
switch (lvlno)
{
case 1:
levelObjects.m_levelsObjArr[0].SetActive(true);
level = levelObjects.m_levelsObjArr[0].GetComponent <Level1Script>();
break;
case 2:
levelObjects.m_levelsObjArr[1].SetActive(true);
level = levelObjects.m_levelsObjArr[1].GetComponent <Level2Script>();
break;
case 3:
levelObjects.m_levelsObjArr[2].SetActive(true);
level = levelObjects.m_levelsObjArr[2].GetComponent <Level3Scipt>();
break;
case 4:
levelObjects.m_levelsObjArr[3].SetActive(true);
level = levelObjects.m_levelsObjArr[3].GetComponent <Level4Script>();
break;
case 5:
levelObjects.m_levelsObjArr[4].SetActive(true);
level = levelObjects.m_levelsObjArr[4].GetComponent <Level5Script>();
break;
}
Globals.m_currentLvl = level;
// level.Start();
// GameObject.Find("LevelController").GetComponent<SelectLevelScript>().enabled = true;
}
public static void level1Objects()
{
string path = @"Assets/Resources/Level1/Level1Objects.asset";
string folder = Path.GetDirectoryName(path);
if (!File.Exists(path))
{
if (Directory.Exists(folder) == false)
{
Directory.CreateDirectory(folder);
}
LevelObjects A = (LevelObjects)ScriptableObject.CreateInstance <LevelObjects> ();
AssetDatabase.CreateAsset(A, path);
}
}
protected virtual void handleUpgradeButtonClicked(Sleek2ImageButton button)
{
for (byte b = 0; b < Regions.WORLD_SIZE; b += 1)
{
for (byte b2 = 0; b2 < Regions.WORLD_SIZE; b2 += 1)
{
foreach (LevelObject levelObject in LevelObjects.objects[(int)b, (int)b2])
{
if (levelObject.placementOrigin == ELevelObjectPlacementOrigin.MANUAL)
{
LevelObjects.addDevkitObject(levelObject.GUID, levelObject.transform.position, levelObject.transform.rotation, levelObject.transform.localScale, levelObject.placementOrigin);
}
}
}
}
}
public static void Level1Triggers()
{
string Objectspath = @"Assets/Resources/Level1/Level1Objects.asset";
string Eventpath = @"Assets/Resources/Level1/Level1CollideEventList.asset";
LevelObjects A = (LevelObjects)AssetDatabase.LoadAssetAtPath(Objectspath, typeof(LevelObjects));
CollideEventList D = (CollideEventList)ScriptableObject.CreateInstance <CollideEventList> ();
foreach (string drag in A.drag)
{
foreach (string hit in A.hit)
{
string e = drag + "," + hit;
D.CollideName.Add(new CollideEvent(e));
}
}
AssetDatabase.CreateAsset(D, Eventpath);
}
protected override bool isPositionValid(Vector3 position)
{
if (!FoliageVolumeUtility.isPointValid(position, false, true, false))
{
return(false);
}
int num = Physics.OverlapSphereNonAlloc(position, this.obstructionRadius, FoliageResourceInfoAsset.OBSTRUCTION_COLLIDERS, RayMasks.BLOCK_RESOURCE);
for (int i = 0; i < num; i++)
{
ObjectAsset asset = LevelObjects.getAsset(FoliageResourceInfoAsset.OBSTRUCTION_COLLIDERS[i].transform);
if (asset != null && !asset.isSnowshoe)
{
return(false);
}
}
return(true);
}
public static void instantiate(ObjectAsset asset, Vector3 position, Quaternion rotation, Vector3 scale)
{
if (asset == null)
{
return;
}
if (!Level.isEditor)
{
return;
}
TranslationReference newReference = new TranslationReference("#SDG::Devkit.Transactions.Spawn");
TranslatedText translatedText = new TranslatedText(newReference);
translatedText.format(asset.objectName);
DevkitTransactionManager.beginTransaction(translatedText);
DevkitHierarchyWorldObject devkitHierarchyWorldObject = LevelObjects.addDevkitObject(asset.GUID, position, rotation, scale, ELevelObjectPlacementOrigin.MANUAL);
DevkitTransactionUtility.recordInstantiation(devkitHierarchyWorldObject.gameObject);
DevkitTransactionManager.endTransaction();
}
private bool LoadObjects(int levelNum)
{
Debug.Log("Load Objects for level " + levelNum + " for leveltype " + Statics.levelType);
var sep = "/";
string folderPath = Statics.folderPath + Statics.levelType + sep;
string filePath = folderPath + "level" + levelNum + ".dat";
Debug.Log("Load from " + filePath);
if (File.Exists(filePath))
{
using (Stream stream = File.Open(filePath, FileMode.Open)) {
var bformatter = new BinaryFormatter();
levelObjects = (LevelObjects)bformatter.Deserialize(stream);
var numDots = levelObjects.dotColors.Count;
Debug.Log("Load Dots: " + numDots);
for (int i = 0; i < numDots; i++)
{
Color color;
ColorUtility.TryParseHtmlString(levelObjects.dotColors[i], out color);
myColors.Remove(color);
var dot = Instantiate(dotPrefab);
dot.transform.position = levelObjects.dotPositions[i];
dot.transform.forward = levelObjects.dotForwards[i];
dot.GetComponent <SpriteRenderer> ().color = color;
dot.GetComponentInChildren <TrailRenderer> ().Clear();
dot.GetComponent <SpriteRenderer> ().sortingOrder = 10;
addDot(dot);
}
Debug.Log("Load Paths: " + levelObjects.paths.Count);
for (int i = 0; i < levelObjects.paths.Count; i++)
{
Debug.Log("Load Path " + i);
Color color;
ColorUtility.TryParseHtmlString(levelObjects.pathColors[i], out color);
myColors.Remove(color);
var dotNumber1 = levelObjects.dotsFrom[i];
var dotNumber2 = levelObjects.dotsTo[i];
var path = NewPath(dots[dotNumber1], dots[dotNumber2]);
var loadedPath = levelObjects.paths[i];
for (int j = 0; j < loadedPath.Count; j++)
{
path.SetPosition(j, loadedPath[j]);
}
List <Vector3> list = new List <Vector3> ();
for (int i1 = 0; i1 < levelObjects.normals[i].Count; i1++)
{
myVector3 normal = levelObjects.normals[i][i1];
list.Add(normal);
// Debug.DrawLine (path.GetPosition (i1), path.GetPosition (i1) + normal, Color.red, 1000f);
}
path.SetNormals(list);
path.SetMesh();
addPath(path);
}
Debug.Log("Load Statics: " + levelObjects.statics.Count);
for (int i = 0; i < levelObjects.statics.Count; i++)
{
Debug.Log("Load Static " + i);
var myStatic = levelObjects.statics[i];
GameObject gameObject;
if (myStatic.type == 0)
{
gameObject = GameObject.Instantiate(staticRectPrefab);
}
else if (myStatic.type == 1)
{
gameObject = GameObject.Instantiate(staticCirclePrefab);
}
else
{
gameObject = GameObject.Instantiate(staticRectPrefab);
}
gameObject.transform.position = myStatic.position;
gameObject.transform.localScale = myStatic.size;
statics.Add(gameObject);
if (Statics.showingAlgebra)
{
AddStaticAlgebra(i, gameObject);
}
}
for (int i = 0; i < paths.Count; i++)
{
for (int j = i + 1; j < paths.Count; j++)
{
CheckIfHomotopic(i, j);
}
}
}
}
return(true);
}
private bool LoadObjects(int levelNum)
{
Debug.Log("Load Objects for level " + levelNum);
string filePath = Statics.folderPath + Statics.levelType + "/" + "level" + levelNum + ".dat";
if (File.Exists(filePath))
{
using (Stream stream = File.Open(filePath, FileMode.Open)) {
var bformatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
levelObjects = (LevelObjects)bformatter.Deserialize(stream);
Debug.Log("Load Dots");
var numDots = levelObjects.dotColors.Count;
for (int i = 0; i < numDots; i++)
{
Color color;
ColorUtility.TryParseHtmlString(levelObjects.dotColors [i], out color);
myColors.Remove(color);
var dot = Instantiate(dotPrefab);
dot.transform.position = levelObjects.dotPositions [i];
dot.GetComponent <SpriteRenderer> ().color = color;
dot.GetComponentInChildren <TrailRenderer> ().Clear();
dot.GetComponent <SpriteRenderer> ().sortingOrder = 10;
addDot(dot);
}
Debug.Log("Load Paths");
for (int i = 0; i < levelObjects.paths.Count; i++)
{
Debug.Log("Load Path " + i);
Color color;
ColorUtility.TryParseHtmlString(levelObjects.pathColors [i], out color);
myColors.Remove(color);
var dotNumber1 = levelObjects.dotsFrom [i];
var dotNumber2 = levelObjects.dotsTo [i];
var path = NewPath(color, dots [dotNumber1], dots [dotNumber2]);
var loadedPath = levelObjects.paths [i];
for (int j = 0; j < loadedPath.Count; j++)
{
path.line.SetPosition(j, loadedPath [j]);
}
addPath(path);
}
Debug.Log("Load Statics");
for (int i = 0; i < levelObjects.statics.Count; i++)
{
Debug.Log("Load Static " + i);
var myStatic = levelObjects.statics [i];
GameObject gameObject;
if (myStatic.type == 0)
{
gameObject = GameObject.Instantiate(staticRectPrefab);
}
else if (myStatic.type == 1)
{
gameObject = GameObject.Instantiate(staticCirclePrefab);
}
else
{
gameObject = GameObject.Instantiate(staticRectPrefab);
}
gameObject.transform.position = myStatic.position;
gameObject.transform.localScale = myStatic.size;
statics.Add(gameObject);
if (Statics.showingAlgebra)
{
AddStaticAlgebra(i, gameObject);
}
}
for (int i = 0; i < paths.Count; i++)
{
for (int j = i + 1; j < paths.Count; j++)
{
CheckIfHomotopic(i, j);
}
}
}
}
return(true);
}
private void Start()
{
tileMap = GetComponent <Tilemap>();
levelObjects = FindObjectOfType <LevelObjects>();
}
public override void Execute(FreneticScript.CommandSystem.CommandQueue queue, CommandEntry entry)
{
try
{
TemplateObject spawned = null;
LocationTag loc = LocationTag.For(entry.GetArgument(queue, 1));
if (loc == null)
{
queue.HandleError(entry, "Invalid location!");
return;
}
string targetAssetType = entry.GetArgument(queue, 0).ToLowerFast();
EntityType etype = EntityType.ValueOf(targetAssetType);
if (etype == null)
{
queue.HandleError(entry, "Invalid entity type!");
return;
}
if (etype.Type == EntityAssetType.ZOMBIE)
{
Vector3 vec3 = loc.ToVector3();
byte reg = 0; // TODO: Optionally specifiable
float closest = float.MaxValue;
for (int r = 0; r < LevelZombies.zombies.Length; r++)
{
for (int i = 0; i < LevelZombies.zombies[r].Count; i++)
{
float dist = (LevelZombies.zombies[r][i].point - vec3).sqrMagnitude;
if (dist < closest)
{
closest = dist;
reg = (byte)r;
}
}
}
ZombieManager.manager.addZombie(reg, 0, 0, 0, 0, 0, 0, 0, 0, vec3, 0, false);
Zombie zombie = ZombieManager.regions[reg].zombies[ZombieManager.regions[reg].zombies.Count - 1];
// TODO: Make this actually work! (See complaints file!)
/*
* foreach (SteamPlayer player in PlayerTool.getSteamPlayers())
* {
* ZombieManager.manager.channel.openWrite();
* ZombieManager.manager.channel.write(reg);
* ZombieManager.manager.channel.write((ushort)1);
* ZombieManager.manager.channel.write(new object[]
* {
* zombie.type,
* (byte)zombie.speciality,
* zombie.shirt,
* zombie.pants,
* zombie.hat,
* zombie.gear,
* zombie.move,
* zombie.idle,
* zombie.transform.position,
* MeasurementTool.angleToByte(zombie.transform.rotation.eulerAngles.y),
* zombie.isDead
* });
* ZombieManager.manager.channel.closeWrite("tellZombies", player.playerID.steamID, ESteamPacket.UPDATE_RELIABLE_CHUNK_BUFFER);
* }
*/
if (entry.ShouldShowGood(queue))
{
entry.Good(queue, "Successfully spawned a zombie at " + TagParser.Escape(loc.ToString()) + "! (WARNING: IT WILL BE INVISIBLE CURRENTLY - SEE THE COMPLAINTS FILE)");
}
spawned = new ZombieTag(zombie);
}
else if (etype.Type == EntityAssetType.ANIMAL)
{
AnimalAssetTag asset = AnimalAssetTag.For(targetAssetType);
if (asset == null)
{
queue.HandleError(entry, "Invalid animal type!");
return;
}
// TODO: Make this bit optional!
RaycastHit rch;
while (Physics.Raycast(loc.ToVector3(), new Vector3(0, 1, 0), out rch, 5))
{
loc.Y += 3;
}
// END TODO
AnimalManager.manager.addAnimal(asset.Internal.id, loc.ToVector3(), 0, false);
Animal animal = AnimalManager.animals[AnimalManager.animals.Count - 1];
foreach (SteamPlayer player in PlayerTool.getSteamPlayers())
{
AnimalManager.manager.channel.openWrite();
AnimalManager.manager.channel.write((ushort)1);
AnimalManager.manager.channel.write(new object[]
{
animal.id,
animal.transform.position,
MeasurementTool.angleToByte(animal.transform.rotation.eulerAngles.y),
animal.isDead
});
AnimalManager.manager.channel.closeWrite("tellAnimals", player.playerID.steamID, ESteamPacket.UPDATE_RELIABLE_CHUNK_BUFFER);
}
if (entry.ShouldShowGood(queue))
{
entry.Good(queue, "Successfully spawned a " + TagParser.Escape(asset.ToString()) + " at " + TagParser.Escape(loc.ToString()) + "! (" + animal.gameObject.GetInstanceID() + ")");
}
spawned = new AnimalTag(animal);
}
else if (etype.Type == EntityAssetType.VEHICLE)
{
VehicleAssetTag asset = VehicleAssetTag.For(targetAssetType);
if (asset == null)
{
queue.HandleError(entry, "Invalid vehicle type!");
return;
}
// TODO: Make this bit optional!
RaycastHit rch;
while (Physics.Raycast(loc.ToVector3(), new Vector3(0, 1, 0), out rch, 5))
{
loc.Y += 3;
}
// END TODO
VehicleManager.spawnVehicle(asset.Internal.id, loc.ToVector3(), Quaternion.identity);
if (entry.ShouldShowGood(queue))
{
entry.Good(queue, "Successfully spawned a " + TagParser.Escape(asset.ToString()) + " at " + TagParser.Escape(loc.ToString()) + "!");
}
// TODO: Get the vehicle entity!
}
else if (etype.Type == EntityAssetType.WORLD_OBJECT)
{
WorldObjectAssetTag asset = WorldObjectAssetTag.For(targetAssetType);
if (asset == null)
{
queue.HandleError(entry, "Invalid world object type!");
return;
}
LevelObjects.addObject(loc.ToVector3(), Quaternion.identity, Vector3.one, asset.Internal.id, asset.Internal.name, asset.Internal.GUID, ELevelObjectPlacementOrigin.MANUAL);
// TODO: Network!
entry.Good(queue, "Successfully spawned a " + TagParser.Escape(asset.ToString()) + " at " + TagParser.Escape(loc.ToString()) + "! (WARNING: IT WILL BE INVISIBLE CURRENTLY - SEE THE COMPLAINTS FILE)");
// TODO: Get the world entity!
}
else if (etype.Type == EntityAssetType.ITEM)
{
ItemAssetTag asset = ItemAssetTag.For(targetAssetType);
if (asset == null)
{
queue.HandleError(entry, "Invalid item type!");
return;
}
byte x;
byte y;
if (Regions.tryGetCoordinate(loc.ToVector3(), out x, out y))
{
Item item = new Item(asset.Internal.id, 1, asset.Internal.quality);
ItemData data = new ItemData(item, ++ItemManager.instanceCount, loc.ToVector3(), Dedicator.isDedicated);
ItemManager.regions[x, y].items.Add(data);
ItemModelTracker.Track(data, loc.ToVector3());
ItemManager.manager.channel.send("tellItem", ESteamCall.CLIENTS, x, y, ItemManager.ITEM_REGIONS, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
{
x,
y,
item.id,
item.amount,
item.quality,
item.state,
loc.ToVector3()
});
if (entry.ShouldShowGood(queue))
{
entry.Good(queue, "Successfully spawned a " + TagParser.Escape(asset.ToString()) + " at " + TagParser.Escape(loc.ToString()) + "!");
}
// TODO: Get the item entity!
}
else
{
queue.HandleError(entry, "Trying to spawn item outside any valid item regions!");
}
}
else if (etype.Type == EntityAssetType.BARRICADE)
{
ItemAssetTag asset = ItemAssetTag.For(targetAssetType.Substring("barricade_".Length));
if (asset == null || !(asset.Internal is ItemBarricadeAsset))
{
queue.HandleError(entry, "Invalid item barricade type!");
return;
}
Barricade barric = new Barricade(asset.Internal.id);
BarricadeManager.dropBarricade(barric, null, loc.ToVector3(), 0f, 0f, 0f, CSteamID.Nil.m_SteamID, CSteamID.Nil.m_SteamID);
if (entry.ShouldShowGood(queue))
{
entry.Good(queue, "Successfully spawned a " + TagParser.Escape(asset.ToString()) + " at " + TagParser.Escape(loc.ToString()) + "!");
}
// TODO: Get the game object!
}
else if (etype.Type == EntityAssetType.STRUCTURE)
{
ItemAssetTag asset = ItemAssetTag.For(targetAssetType.Substring("structure_".Length));
if (asset == null || !(asset.Internal is ItemStructureAsset))
{
queue.HandleError(entry, "Invalid item structure type!");
return;
}
StructureManager.dropStructure(new Structure(asset.Internal.id), loc.ToVector3(), 0f, 0f, 0f, CSteamID.Nil.m_SteamID, CSteamID.Nil.m_SteamID);
if (entry.ShouldShowGood(queue))
{
entry.Good(queue, "Successfully spawned a " + TagParser.Escape(asset.ToString()) + " at " + TagParser.Escape(loc.ToString()) + "!");
}
// TODO: Get the game object!
}
else
{
queue.HandleError(entry, "Invalid or unspawnable entity type!");
return;
}
if (spawned != null)
{
queue.SetVariable("spawned", spawned);
}
}
catch (Exception ex) // TODO: Necessity?
{
queue.HandleError(entry, "Failed to spawn entity: " + ex.ToString());
}
}
public void DeleteBlocks()
{
LevelObjects.Clear();
}
public void AnimationEvent(AnimationState state, int trackIndex, Event e)
{
float Amount = e.Float;
if (Amount == 0) // so it can be the float or the int
{
Amount = (float)e.Int;
}
if (((Engine.instance.DebugView.Flags & Physics.DebugViewFlags.Game) == Physics.DebugViewFlags.Game))
{
Engine.instance.AddDebugText(e.Data.Name, Position, Color.White);
}
if (e.Data.Name.Contains("particle_"))
{
string ParticleName = e.Data.Name.Replace("particle_", "");
Vector2 Pos = Position;
if (!string.IsNullOrEmpty(e.String))
{
Pos = SpineFunc.GetBonePosition(this, e.String.Replace("\n", ""));
}
Particles.GameParticles[ParticleName].Trigger(Pos, -1);
if (ParticleName == "spark")
{
Engine.instance.PlaySound("FX_M_Systems_Spark", this, Pos);
}
else if (ParticleName == "_new_explosion_rock")
{
Engine.instance.PlaySound("FX_Hazard_Crusher_Impact", this, Pos);
}
}
else if (e.Data.Name == "shake_fluid")
{
if (Engine.instance.FluidSimulation != null)
{
Engine.instance.FluidSimulation.ShakeParticles(this, e.Int, e.Float);
}
}
else if (e.Data.Name == "lunge")
{
Character.IsLunging = e.Int == 1;
}
else if (e.Data.Name == "push")
{
if (Character != null && !Character.Player && NoAirControlTime > Engine.instance.Time)
{
return;
}
bool WasIgnore = Body.IgnoreForces;
float multiplier = Amount > 0 ? ForwardPushForceMult : BackwardPushForceMult;
Vector2 dir = FocusDistance;
if (CustomPushDirection != Vector2.Zero)
{
dir = CustomPushDirection;
}
Body.IgnoreForces = false;
if (FocusDistance != Vector2.Zero)
{
Body.ApplyForce(Amount * Body.Mass * 400 * Vector2.Normalize(dir) * multiplier);
}
Body.IgnoreForces = WasIgnore;
CustomPushDirection = Vector2.Zero;
}
else if (e.Data.Name == "melee")
{
if (ActiveMeleeWeapon != null)
{
if (Amount > 0)
{
if (!ActiveMeleeWeapon.MeleeStrike)
{
if (!string.IsNullOrEmpty(ActiveMeleeWeapon.GameObjectClass.AttackSound))
{
Engine.instance.PlaySound(ActiveMeleeWeapon.GameObjectClass.AttackSound, this);
}
}
if (ActiveMeleeWeapon.MeleeHits != null)
{
ActiveMeleeWeapon.MeleeHits.Clear();
}
ActiveMeleeWeapon.MeleeStrike = true;
Body.IgnoreForces = true;
}
else if (Amount < 0)
{
ActiveMeleeWeapon.MeleeStrike = false;
ActiveMeleeWeapon = null;
Body.IgnoreForces = false;
}
}
else
{
Engine.instance.AddDevConsoleText("No active melee weapon for melee attack");
}
/*
* if (Amount > 0)
* {
* ActiveMeleeWeapon.MeleeHits.Clear();
* ActiveMeleeWeapon.MeleeStrike = true;
* Body.IgnoreForces = true;
* }
* else
* {
* ActiveMeleeWeapon.MeleeStrike = false;
* ActiveMeleeWeapon = null;
* Body.IgnoreForces = false;
* }*/
}
else if (e.Data.Name == "blow_left_door" && Amount > 0)
{
Vector2 force = new Vector2((float)Math.Cos(Rotation), (float)Math.Sin(Rotation)) * -30000f;
GameObject gib = LevelObjects.CreateGib(this, skeleton.FindSlot("door_l_box"), force, MiscFunc.RandomBetween(-0.5f, 0.5f), "Gibs\\gib", 3f);
gib.Body.LinearDamping = 4f;
gib.Body.AngularDamping = 2f;
}
else if (e.Data.Name == "blow_right_door" && Amount > 0)
{
Vector2 force = new Vector2((float)Math.Cos(Rotation), (float)Math.Sin(Rotation)) * 30000f;
GameObject gib = LevelObjects.CreateGib(this, skeleton.FindSlot("door_r_box"), force, MiscFunc.RandomBetween(-0.5f, 0.5f), "Gibs\\gib", 3f);
gib.Body.LinearDamping = 4f;
gib.Body.AngularDamping = 2f;
//Stations.GetSupplyPodContents(LastInteractBy, GameObject);
}
else if (e.Data.Name == "getkey")
{
//Stations.GetTerminalContents(LastInteractBy, GameObject);
}
else if (skeleton.Data.Name == "core" && e.Data.Name == "fire")
{
Engine.instance.PlaySound("FX_M_Core_Shot", this);
if (GameObject.CoreCanFire && SystemsFunc.SystemHasHealth(GameObject))
{
foreach (string muzzleName in GameObject.CoreMuzzleNames)
{
if (GameObject.Class.SystemLevel == 1)
{
if (GameObject.CoreLevel1FireSwitch && (muzzleName == "muzzle01" || muzzleName == "muzzle03"))
{
continue;
}
if (!GameObject.CoreLevel1FireSwitch && (muzzleName == "muzzle02" || muzzleName == "muzzle04"))
{
continue;
}
}
Vector2 position = SpineFunc.GetBonePosition(GameObject, muzzleName);
float rotation = SpineFunc.GetBoneRotation(GameObject, muzzleName);
Vector2 direction = new Vector2((float)Math.Cos(rotation), (float)Math.Sin(rotation));
GameObject projectile = WeaponsFunc.CreateProjectile(this, position, "EnemyWeapons\\core_p", direction);
projectile.Class.IgnoreSystemCollision = true;
projectile.Class.IgnoreSystemHealthProxyCollision = true;
}
GameObject.CoreLevel1FireSwitch = !GameObject.CoreLevel1FireSwitch;
}
}
else if (skeleton.Data.Name == "alarm")
{
if (e.Data.Name == "fire")
{
GameObject.AlarmCanFire = true;
}
else if (e.Data.Name == "fire_stop")
{
GameObject.AlarmCanFire = false;
}
else if (e.Data.Name == "vulnerable")
{
foreach (GameObject child in GameObject.Children)
{
child.ImmuneToExplosions = false;
child.ImmuneToProjectiles = false;
}
}
else if (e.Data.Name == "invulnerable")
{
foreach (GameObject child in GameObject.Children)
{
child.ImmuneToExplosions = true;
child.ImmuneToProjectiles = true;
}
}
}
else if (skeleton.Data.Name == "sentry_new" || skeleton.Data.Name == "sentry_flakk")
{
if (e.Data.Name == "start_tracking")
{
GameObject.SentryTrackingAllowed = true;
GameObject.SentryStartChargingAt = (float)Engine.instance.Time + 1f;
}
else if (e.Data.Name == "stop_tracking")
{
GameObject.SentryTrackingAllowed = false;
}
else if (e.Data.Name == "fire")
{
GameObject.SentryIsCharging = false;
GameObject.SentryIsFiring = true;
GameObject.SentryStopFiringAt = (float)Engine.instance.Time + 2f;
}
else if (e.Data.Name == "invulnerable")
{
foreach (GameObject child in GameObject.Children)
{
child.ImmuneToExplosions = true;
child.ImmuneToProjectiles = true;
}
}
else if (e.Data.Name == "vulnerable")
{
foreach (GameObject child in GameObject.Children)
{
child.ImmuneToExplosions = false;
child.ImmuneToProjectiles = false;
}
}
}
else if (skeleton.Data.Name == "factory" || skeleton.Data.Name == "factory_advanced")
{
if (e.Data.Name == "invulnerable")
{
if (!OffScreen)
{
Engine.instance.PlaySound("FX_M_DroneFactory_Close", this);
}
foreach (GameObject child in GameObject.Children)
{
child.ImmuneToExplosions = true;
child.ImmuneToProjectiles = true;
}
}
else if (e.Data.Name == "vulnerable")
{
if (!OffScreen)
{
Engine.instance.PlaySound("FX_M_DroneFactory_Open", this);
}
foreach (GameObject child in GameObject.Children)
{
child.ImmuneToExplosions = false;
child.ImmuneToProjectiles = false;
}
}
else if (e.Data.Name == "fire")
{
GameObject.FactoryCanFire = true;
}
}
else if (skeleton.Data.Name == "repair_system")
{
if (e.Data.Name == "fire_01")
{
GameObject.RepairCurrentMuzzleIndex = 0;
GameObject.RepairFireDrone = true;
}
else if (e.Data.Name == "fire_02")
{
GameObject.RepairCurrentMuzzleIndex = 1;
GameObject.RepairFireDrone = true;
}
else if (e.Data.Name == "fire_03")
{
GameObject.RepairCurrentMuzzleIndex = 2;
GameObject.RepairFireDrone = true;
}
else if (e.Data.Name == "fire_04")
{
GameObject.RepairCurrentMuzzleIndex = 3;
GameObject.RepairFireDrone = true;
}
else if (e.Data.Name == "fire_05")
{
GameObject.RepairCurrentMuzzleIndex = 4;
GameObject.RepairFireDrone = true;
}
else if (e.Data.Name == "stop_regen")
{
GameObject.Children[0].HealthRegenEnabled = false;
}
else if (e.Data.Name == "start_regen")
{
if (GameObject.Class.SystemLevel >= 2 && GameObject.Class.Type != GameObjectType.SYSTEM_REPAIR)
{
GameObject.Children[0].HealthRegenEnabled = true;
}
}
}
else if (skeleton.Data.Name == "flak_turret")
{
if (e.Data.Name == "fire_left")
{
Character.FlakCurrentMuzzle = "left_muzzle";
WeaponsFunc.Fire(this, Inventory.Items[InventorySlot.WEAPON_1]);
}
else if (e.Data.Name == "fire_right")
{
Character.FlakCurrentMuzzle = "right_muzzle";
WeaponsFunc.Fire(this, Inventory.Items[InventorySlot.WEAPON_1]);
}
}
/*else if (skeleton.Data.Name == "tanker")
* {
* if (e.Data.Name == "enable_fire")
* {
* if (Character.AIState == AIState.PATROL)
* {
* if (Character.Class.HazardType == HazardType.MINES)
* {
* GameObject mine = new GameObject();
*
* mine.Classfile = "Hazards\\mine";
* mine.Position = SpineFunc.GetBonePosition(this, "muzzle");
* Engine.instance.AddEntity(mine);
* mine.Team = 1;
* }
* }
* }
* }*/
else if (skeleton.Data.Name == "heavy_sentinel")
{
if (e.Data.Name == "fire")
{
WeaponsFunc.Fire(this, Inventory.Items[InventorySlot.WEAPON_1]);
}
else if (e.Data.Name == "activate_shield")
{
WeaponsFunc.ActivateShield(Character, Inventory.Items[InventorySlot.WEAPON_2]);
}
else if (e.Data.Name == "deactivate_shield")
{
WeaponsFunc.DeactivateShield(Inventory.Items[InventorySlot.WEAPON_2].ShieldObject);
}
}
else if (skeleton.Data.Name == "tattletale")
{
//if (Character.CanAlarm && e.Data.Name == "alarm")
// CFunc.CharacterAlarm(Character, Character.FindCharacter, Position);
}
else if (skeleton.Data.Name == "seeker_launcher")
{
if (e.Data.Name == "close")
{
Engine.instance.PlaySound("Combat_M_SeekerLauncher_Close", this);
}
else if (e.Data.Name == "open")
{
Engine.instance.PlaySound("Combat_M_SeekerLauncher_Open", this);
}
else
{
SwarmManager manager = SwarmManager.Instance;
string muzzleName = null;
Vector2 spawnPos;
Character spawn;
if (e.Data.Name == "fire01")
{
muzzleName = "muzzle01";
}
else if (e.Data.Name == "fire02")
{
muzzleName = "muzzle02";
}
else if (e.Data.Name == "fire03")
{
muzzleName = "muzzle03";
}
else if (e.Data.Name == "fire04")
{
muzzleName = "muzzle04";
}
if (Character.OwnerSwarmGroup == null)
{
Character.OwnerSwarmGroup = manager.CreateGroup(50);
}
spawnPos = SpineFunc.GetBonePosition(this, muzzleName);
spawn = new Character();
spawn.Position = spawnPos;
spawn.Classname = "Bee";
Engine.instance.AddEntity(spawn);
manager.AddEntityToGroup(Character.OwnerSwarmGroup, spawn);
Particles.GameParticles["_new_muzzle_enemyblaster"].Trigger(spawnPos);
Engine.instance.PlaySound("FX_M_RepairSystem_Drones_Eject", spawn, spawnPos);
}
}
else if (skeleton.Data.Name == "bully")
{
if (e.Data.Name == "fire")
{
WeaponsFunc.Fire(this, Inventory.Items[InventorySlot.WEAPON_1]);
}
}
else if (skeleton.Data.Name == "stasis_gel_arm")
{
if (e.Data.Name == "start_fire")
{
GameObject.IsSpraying = true;
}
else if (e.Data.Name == "stop_fire")
{
GameObject.IsSpraying = false;
}
}
else if (skeleton.Data.Name == "cage_generator")
{
if (e.Data.Name == "activate")
{
GameObject.CageActive = true;
}
else if (e.Data.Name == "deactivate")
{
GameObject.CageActive = false;
}
}
else if (Type == EntityType.CHARACTER)
{
if (Character.Class.Type == CharacterType.Leviathan)
{
int OnscreenSpawned = 0;
foreach (Character Spawned in Character.CharsSpawned)
{
if (!Spawned.OffScreen)
{
OnscreenSpawned++;
}
}
if (e.Data.Name == "enable_fire" && OnscreenSpawned < 3)
{
Character spawn = new Character();
spawn.Classname = Character.Class.CharToSpawn;
spawn.Position = SpineFunc.GetBonePosition(this, "muzzle");
Engine.instance.AddEntity(spawn);
Character.CharsSpawned.Add(spawn);
}
}
else if (Character.Class.Type == CharacterType.Blacksuit)
{
if (e.Data.Name == "start_fire")
{
Character.IsFiring = true;
}
else if (e.Data.Name == "stop_fire")
{
Character.IsFiring = false;
}
else if (e.Data.Name == "activate_shield" && Character.State != CharacterState.DEATH_ANIM)
{
ItemsFunc.Use(this, Inventory.Items[InventorySlot.ABILITY]);
Character.CurrentShield.ShieldObject.NextAbility = float.MaxValue;
Character.IsSecondaryFiring = true;
}
else if (e.Data.Name == "deactivate_shield" && Character.CurrentShield != null)
{
Character.CurrentShield.ShieldObject.NextAbility = 0.1f;
Character.IsSecondaryFiring = false;
}
}
else if (Character.Class.Type == CharacterType.Viper)
{
if (e.Data.Name == "fire")
{
WeaponsFunc.Fire(this, Inventory.Items[InventorySlot.WEAPON_1]);
}
}
}
else if (Type == EntityType.OBJECT)
{
if (GameObject.Class.Type == GameObjectType.CRUSHER_SINGLE)
{
GameObject child = GameObject.Children[0];
if (e.Data.Name == "enable")
{
child.CrusherPistonEnabled = true;
}
else
{
child.CrusherPistonEnabled = false;
}
}
else if (GameObject.Class.Type == GameObjectType.CRUSHER_TRIPLE)
{
GameObject child = GameObject.Children[1 + e.Int];
if (e.Data.Name == "enable")
{
child.CrusherPistonEnabled = true;
}
else
{
child.CrusherPistonEnabled = false;
}
}
else if (GameObject.Class.Type == GameObjectType.INCINERATOR_STATIONARY)
{
if (e.Data.Name == "is_open")
{
GameObject.IsOpen = true;
}
else if (e.Data.Name == "is_closing")
{
GameObject.IsOpen = false;
}
}
else if (GameObject.Class.Type == GameObjectType.INCINERATOR_FORK ||
GameObject.Class.Type == GameObjectType.INCINERATOR_WHEEL)
{
if (e.Data.Name == "fireSound")
{
Engine.instance.PlaySound("FX_Hazard_Incinerator_Fire", GameObject);
}
else if (e.Data.Name == "fire")
{
GameObject.IsSpraying = true;
}
else if (e.Data.Name == "fire_stop")
{
GameObject.IsSpraying = false;
}
}
else if (GameObject.Class.Type == GameObjectType.SAWBLADE_WALLARM)
{
if (e.Data.Name == "fire")
{
Vector2 debrisPos = SpineFunc.GetBonePosition(this, "muzzle");
float debrisAngle = SpineFunc.GetBoneRotation(this, "muzzle");
GameObject debris;
float debrisSpeed = MiscFunc.RandomBetween(6f, 9f);
debrisAngle += MiscFunc.RandomBetween(-0.4f, 0.4f);
//if (GameObject.FlippedHorizontal)
// debrisAngle = -debrisAngle + MathHelper.Pi;
//if (GameObject.FlipVertical)
// debrisAngle = -debrisAngle;
debris = SpineFunc.CreateDebris(this, skeleton.FindBone("muzzle"), MiscFunc.mRandom.Next(99999999), Vector2.Zero, 1f, 1f, false, "Hazards\\sawblade_debris");
debris.Body.LinearVelocity = new Vector2((float)Math.Cos(debrisAngle), (float)Math.Sin(debrisAngle)) * debrisSpeed;
}
}
else if (GameObject.Class.Type == GameObjectType.SYSTEM_SHUFFLE)
{
if (e.Data.Name == "vulnerable")
{
GameObject weakObj = Children[0];
weakObj.ImmuneToExplosions = false;
weakObj.ImmuneToFluid = false;
weakObj.ImmuneToProjectiles = false;
weakObj.ImmuneToSlowExplosions = false;
}
else if (e.Data.Name == "invulnerable")
{
GameObject weakObj = Children[0];
weakObj.ImmuneToExplosions = true;
weakObj.ImmuneToFluid = true;
weakObj.ImmuneToProjectiles = true;
weakObj.ImmuneToSlowExplosions = true;
}
}
else if (GameObject.Class.Type == GameObjectType.PLAYERSHIP_PLAYER)
{
if (e.Data.Name == "teleport_effect")
{
GameObject refraction = new GameObject();
GameObject light = new GameObject();
refraction.Classfile = "Refractions\\shockwave_2";
refraction.Position = Position;
Engine.instance.AddEntity(refraction);
light.Classfile = "Lights\\death_teleport_light";
light.Position = Position;
Engine.instance.AddEntity(light);
}
}
else if (GameObject.Class.Type == GameObjectType.BEE_HIVE)
{
if (e.Data.Name == "fire")
{
Vector2 basePos = SpineFunc.GetBonePosition(this, "spawn");
Vector2 spawnPos = basePos + MiscFunc.RandomInUnitCircle() * 10f;
Character bee = new Character();
if (GameObject.HiveCurrentGroup == null)
{
GameObject.HiveCurrentGroup = SwarmManager.Instance.CreateGroup(5);
}
bee.Classname = "Bee";
bee.Position = spawnPos;
Engine.instance.AddEntity(bee);
SwarmManager.Instance.AddEntityToGroup(GameObject.HiveCurrentGroup, bee);
}
}
}
}
