internal override void VExecuteString(string resource, string str, bool runInEditor, Cv_Event runningEvent, Cv_Entity runningEntity)
{
Cv_Debug.Assert((m_iActiveQueue >= 0 && m_iActiveQueue < NUM_QUEUES), "ScriptManager must have an active script queue.");
if (str == null)
{
Cv_Debug.Error("Invalid script in VExecuteString.");
return;
}
Cv_ScriptExecutionRequest request = new Cv_ScriptExecutionRequest();
request.Code = str;
request.Resource = resource;
request.Entity = runningEntity;
request.Event = runningEvent;
request.RunInEditor = runInEditor;
lock (m_QueuedScriptLists[m_iActiveQueue])
{
m_QueuedScriptLists[m_iActiveQueue].AddLast(request);
}
Cv_Debug.Log("LuaScript", "Queued script " + resource + " for entity " + (runningEntity != null ? runningEntity.EntityName : "[null]"));
}
public void OnModifiedRenderComponent(Cv_Event eventData)
{
var castEventData = (Cv_Event_ModifiedRenderComponent)eventData;
Cv_EntityID entityId = castEventData.EntityID;
if (entityId == Cv_EntityID.INVALID_ENTITY)
{
Cv_Debug.Error("OnModifiedRenderComponent - Unknown entity ID!");
return;
}
if (Caravel.Logic.State == Cv_GameState.LoadingScene)
{
return;
}
var sceneNodes = GetEntityNodes(entityId);
if (sceneNodes == null || sceneNodes.Length <= 0)
{
Cv_Debug.Error("Failed to apply changes to scene node for entity " + entityId);
}
else
{
foreach (var n in sceneNodes)
{
if (!n.VOnChanged())
{
Cv_Debug.Error("Error applying changes to scene node for entity " + entityId);
}
}
}
}
public void ModifyEntity(Cv_EntityID entityID, XmlNodeList overrides)
{
Cv_Debug.Assert(m_EntityFactory != null, "Entity factory should not be null.");
if (m_EntityFactory == null)
{
return;
}
Cv_Entity ent = null;
lock (Entities)
{
Entities.TryGetValue(entityID, out ent);
}
if (ent != null)
{
var components = m_EntityFactory.ModifyEntity(ent, overrides);
foreach (var component in components)
{
component.VPostInitialize();
component.VPostLoad();
}
}
}
public bool VLoad(string resourceFile, Stream resourceStream, out int size, Cv_ResourceBundle bundle)
{
if (resourceStream == null)
{
Cv_Debug.Error("Invalid resource stream.");
size = 0;
return(false);
}
resourceStream.Position = 0;
var doc = new XmlDocument();
doc.Load(resourceStream);
var newXmlData = new Cv_XmlData();
newXmlData.Document = doc;
newXmlData.RootNode = (XmlElement)doc.FirstChild;
ResourceData = newXmlData;
size = doc.OuterXml.Length;
resourceStream.Dispose();
return(true);
}
public int Preload <Resource>(string pattern, LoadProgressDelegate progressCallback, string bundle) where Resource : Cv_Resource, new()
{
Cv_ResourceBundle resBundle;
if (!m_ResourceBundles.TryGetValue(bundle, out resBundle))
{
Cv_Debug.Error("Could not find requested resource bundle.");
return(0);
}
var resourceList = GetResourceList(pattern, bundle);
int loaded = 0;
foreach (var r in resourceList)
{
GetResource <Resource>(r, bundle);
loaded++;
bool cancel = false;
progressCallback(loaded * 100 / resourceList.Length, out cancel);
if (cancel)
{
break;
}
}
return(loaded);
}
internal bool Initialize(XmlElement bundleInfo, bool useDevDirectories = false)
{
if (bundleInfo != null)
{
foreach (XmlElement e in bundleInfo.ChildNodes)
{
string bundleName, bundleFile;
if (e.Attributes["name"] == null || e.Attributes["file"] == null)
{
Cv_Debug.Error("Bundle is not correctly defined.");
return(false);
}
bundleName = e.Attributes["name"].Value;
bundleFile = e.Attributes["file"].Value;
if (!useDevDirectories)
{
AddResourceBundle(bundleName, new Cv_ZipResourceBundle(bundleFile));
}
else
{
AddResourceBundle(bundleName, new Cv_DevelopmentResourceBundle(bundleFile, CaravelApp.Instance.Services));
}
}
}
return(true);
}
public bool AbortEvent <EventType>(bool allOfType = false) where EventType : Cv_Event
{
Cv_Debug.Assert((m_iActiveQueue >= 0 && m_iActiveQueue < NUM_QUEUES), "EventManager must have an active event queue.");
Cv_EventType eType = Cv_Event.GetType <EventType>();
var success = false;
Cv_Debug.Log("Events", "Attempting to abort event type " + typeof(EventType).Name);
var queue = m_EventQueues[m_iActiveQueue];
if (allOfType)
{
if (queue.Remove(queue.First(e => e.Type == eType)))
{
success = true;
}
}
else
{
while (queue.Remove(queue.First(e => e.Type == eType)))
{
success = true;
}
}
if (success)
{
Cv_Debug.Log("Events", "Successfully aborted event type " + typeof(EventType).Name);
}
return(success);
}
public bool RemoveListener(Cv_EventListenerHandle listenerHandle)
{
if (listenerHandle.IsScriptListener)
{
return(RemoveListener(listenerHandle.EventName, listenerHandle.ScriptDelegate, listenerHandle.Entity));
}
else
{
Cv_Debug.Log("Events", "Attempting to remove listener from event type " + listenerHandle.EventName);
var success = false;
lock (m_EventListeners)
{
if (m_EventListeners.ContainsKey(listenerHandle.EventType))
{
var listeners = m_EventListeners[listenerHandle.EventType];
success = listeners.Remove(listenerHandle.Delegate);
}
}
if (success)
{
Cv_Debug.Log("Events", "Successfully removed listener from event type " + listenerHandle.EventName);
}
return(success);
}
}
protected override Stream GetStream(string assetName)
{
int entry = m_ZipFile.FindEntry(assetName, true);
Stream zipStream = null;
if (entry != -1)
{
zipStream = m_ZipFile.GetInputStream(entry);
}
else
{
entry = m_ZipFile.FindEntry(assetName + ".xnb", true);
if (entry != -1)
{
zipStream = m_ZipFile.GetInputStream(entry);
}
}
if (zipStream != null)
{
var memoryStream = new MemoryStream();
zipStream.CopyTo(memoryStream);
zipStream.Dispose();
return(memoryStream);
}
Cv_Debug.Error("Unable to open stream.");
return(null);
}
internal override void VExecuteStream(string resource, Stream stream, bool runInEditor, Cv_Event runningEvent)
{
Cv_Debug.Assert((m_iActiveQueue >= 0 && m_iActiveQueue < NUM_QUEUES), "ScriptManager must have an active script queue.");
if (stream == null)
{
Cv_Debug.Error("Invalid stream in VExecuteStream.");
return;
}
string code;
using (StreamReader reader = new StreamReader(stream))
{
stream.Position = 0;
code = reader.ReadToEnd();
}
var entity = CaravelApp.Instance.Logic.GetEntity(runningEvent.EntityID);
Cv_ScriptExecutionRequest request = new Cv_ScriptExecutionRequest();
request.Code = code;
request.Resource = resource;
request.Entity = entity;
request.Event = runningEvent;
request.RunInEditor = runInEditor;
lock (m_QueuedScriptLists[m_iActiveQueue])
{
m_QueuedScriptLists[m_iActiveQueue].AddLast(request);
}
Cv_Debug.Log("LuaScript", "Queued script " + resource + " for entity " + (entity != null ? entity.EntityName : "[null]"));
}
public Cv_SoundInstanceData PlaySound2D(string soundResource, Cv_Entity entity, Vector2 listener, Vector2 emitter,
bool looping = false, float volume = 1f, float pan = 0f, float pitch = 0f)
{
if (soundResource == null || soundResource == "" || entity == null)
{
Cv_Debug.Error("Error - No sound or entity defined when trying to play sound.");
return(null);
}
var playSoundData = GetNewSoundInstance(soundResource, entity, volume, pan, pitch, looping);
AddSoundToManager(playSoundData);
m_Emitter.Position = new Vector3(emitter, 0) * DistanceFallOff;
m_Listener.Forward = new Vector3(0, 0, -1);
m_Listener.Up = new Vector3(0, 1, 0);
m_Listener.Position = new Vector3(listener, 0) * DistanceFallOff;
try
{
playSoundData.Instance.Apply3D(m_Listener, m_Emitter);
playSoundData.Instance.Play();
playSoundData.Instance.Apply3D(m_Listener, m_Emitter); // This is necessary due to a bug in monogame where 3D sounds do
//not work correctly unless Apply3D is called both before and after Play
}
catch (Exception e)
{
Cv_Debug.Error("Unable to play sound: " + soundResource + "\n" + e.ToString());
}
return(playSoundData);
}
public bool VLoad(string resourceFile, Stream resourceStream, out int size, Cv_ResourceBundle bundle)
{
if (resourceStream == null)
{
Cv_Debug.Error("Invalid resource stream.");
size = 0;
return(false);
}
resourceStream.Position = 0;
try {
var sound = SoundEffect.FromStream(resourceStream);
var resData = new Cv_SoundData();
resData.Sound = sound;
ResourceData = resData;
size = 0;
resourceStream.Dispose();
return(true);
}
catch (Exception e)
{
Cv_Debug.Error("Error loading sound stream.\n" + e.ToString());
size = 0;
return(false);
}
}
internal override void OnUpdate(float time, float elapsedTime)
{
var queueToProcess = m_iActiveQueue;
m_iActiveQueue = (m_iActiveQueue + 1) % NUM_QUEUES;
m_QueuedScriptLists[m_iActiveQueue].Clear();
long currentMs = 0;
var stopwatch = new Stopwatch();
stopwatch.Start();
lock (m_QueuedScriptLists[queueToProcess])
{
while (m_QueuedScriptLists[queueToProcess].Count > 0)
{
var script = m_QueuedScriptLists[queueToProcess].First.Value;
m_QueuedScriptLists[queueToProcess].RemoveFirst();
if (!CaravelApp.Instance.EditorRunning || script.RunInEditor)
{
try
{
m_ScriptState["env.currentEntity"] = script.Entity;
m_ScriptState["env.currentEvent"] = script.Event;
m_ScriptState.DoString("run [[" + script.Code + "]]", script.Resource);
}
catch (LuaException e)
{
Cv_Debug.Error("Error executing Lua script:\n" + e.ToString());
}
catch (Exception e)
{
Cv_Debug.Error("Error executing Lua script:\n" + e.ToString());
}
}
currentMs = stopwatch.ElapsedMilliseconds;
if (MaxProcessTimeMillis != long.MaxValue)
{
if (currentMs >= MaxProcessTimeMillis)
{
Cv_Debug.Error("ScriptManager processing time exceeded. Aborting.");
stopwatch.Stop();
break;
}
}
}
while (m_QueuedScriptLists[queueToProcess].Count > 0)
{
m_QueuedScriptLists[m_iActiveQueue].AddBefore(m_QueuedScriptLists[m_iActiveQueue].First, m_QueuedScriptLists[queueToProcess].Last);
m_QueuedScriptLists[queueToProcess].RemoveLast();
}
}
}
public Resource GetResource <Resource>(string resourceFile, string bundle, bool reload = false) where Resource : Cv_Resource, new()
{
var resource = new Resource();
resource.File = resourceFile;
var isOwnedByResManager = resource.VIsManuallyManaged();
Cv_ResourceData resData;
lock (m_ResourceData)
{
if (!reload && isOwnedByResManager && m_ResourceData.TryGetValue(resourceFile, out resData))
{
resource.ResourceData = resData;
}
else
{
var size = 0;
Cv_ResourceBundle resBundle;
if (!m_ResourceBundles.TryGetValue(bundle, out resBundle))
{
Cv_Debug.Error("Could not find requested resource bundle: " + bundle);
return(default(Resource));
}
if (isOwnedByResManager)
{
using (var resStream = resBundle.GetResourceStream(resourceFile))
{
if (!resource.VLoad(resourceFile, resStream, out size, resBundle))
{
Cv_Debug.Error("Unable to load resource: " + resourceFile);
return(default(Resource));
}
}
if (m_ResourceData.ContainsKey(resourceFile))
{
m_ResourceData.Remove(resourceFile);
}
m_ResourceData.Add(resourceFile, resource.ResourceData);
}
else
{
if (!resource.VLoad(resourceFile, null, out size, resBundle))
{
Cv_Debug.Error("Unable to load resource: " + resourceFile);
return(default(Resource));
}
}
}
}
return(resource);
}
private List <Cv_Entity> CreateNestedEntities(XmlNodeList entities, Cv_EntityID parentId,
string resourceBundle = null, Cv_SceneID sceneID = Cv_SceneID.INVALID_SCENE)
{
List <Cv_Entity> entitiesCreated = new List <Cv_Entity>();
if (entities != null)
{
foreach (XmlNode e in entities)
{
var visible = true;
if (e.Attributes["visible"] != null)
{
visible = bool.Parse(e.Attributes["visible"].Value);
}
if (e.Name == "Entity")
{
var entity = InstantiateSceneEntity(false, e, resourceBundle, parentId, sceneID);
entitiesCreated.Add(entity);
var childEntities = e.SelectNodes("./Entity|./Scene");
if (childEntities.Count > 0)
{
entitiesCreated.AddRange(CreateNestedEntities(childEntities, entity.ID, resourceBundle, sceneID));
}
}
else
{
var name = e.Attributes?["name"].Value;
var sceneResource = e.Attributes["resource"].Value;
if (sceneResource == null || sceneResource == "")
{
continue;
}
var sceneOverrides = GetSceneOverrides((XmlElement)e);
var createdEntities = LoadScene(sceneResource, resourceBundle, name, sceneOverrides, null, parentId);
if (createdEntities == null || createdEntities.Length <= 0)
{
Cv_Debug.Warning("Unable to load a sub scene that as part of another scene [" + name + "]");
continue;
}
entitiesCreated.AddRange(createdEntities);
}
}
}
return(entitiesCreated);
}
public void RemoveCategory(int category)
{
if (category >= 32)
{
Cv_Debug.Error("Invalid category. There are only 32 collision categories.");
return;
}
m_Categories.Set(category, false);
}
virtual protected internal Cv_EntityComponent CreateComponent(string componentName)
{
var component = ComponentFactory.Create(Cv_EntityComponent.GetID(componentName));
if (component == null)
{
Cv_Debug.Error("Couldn't find component " + componentName + ". All components must be registered before use.");
}
return(component);
}
public void Pause()
{
if (State == Cv_ProcessState.Running)
{
State = Cv_ProcessState.Paused;
}
else
{
Cv_Debug.Warning("Attempting to pause a process that isn't running");
}
}
virtual protected internal Component CreateComponent <Component>() where Component : Cv_EntityComponent
{
var component = (Component)ComponentFactory.Create(Cv_EntityComponent.GetID(typeof(Component)));
if (component == null)
{
Cv_Debug.Error("Couldn't find component " + typeof(Component).Name + ". All components must be registered before use.");
}
return(component);
}
public void Resume()
{
if (State == Cv_ProcessState.Paused)
{
State = Cv_ProcessState.Running;
}
else
{
Cv_Debug.Warning("Attempting to resume a process that isn't paused");
}
}
public void Unload(string bundle)
{
Cv_ResourceBundle resBundle;
if (!m_ResourceBundles.TryGetValue(bundle, out resBundle))
{
Cv_Debug.Error("Could not find requested resource bundle.");
return;
}
resBundle.Unload();
}
public XmlElement GetEntityXML(Cv_EntityID entityID)
{
var entity = GetEntity(entityID);
if (entity != null)
{
return(entity.ToXML());
}
Cv_Debug.Error("Could not find entity with ID: " + (int)entityID);
return(null);
}
virtual protected internal Cv_Entity CreateEntity(string entityTypeResource, Cv_EntityID parent, Cv_EntityID serverEntityID, string resourceBundle, Cv_SceneID sceneID, string sceneName)
{
Cv_XmlResource resource;
resource = Cv_ResourceManager.Instance.GetResource <Cv_XmlResource>(entityTypeResource, resourceBundle, CaravelApp.Instance.EditorRunning);
XmlElement root = ((Cv_XmlResource.Cv_XmlData)resource.ResourceData).RootNode;
if (root == null)
{
Cv_Debug.Error("Failed to load entity resource file: " + entityTypeResource);
return(null);
}
Cv_EntityID entityId = serverEntityID;
if (entityId == Cv_EntityID.INVALID_ENTITY)
{
lock (m_Mutex)
{
entityId = GetNextEntityID();
}
}
var entity = new Cv_Entity(entityId, resourceBundle, sceneName, sceneID);
if (!entity.Initialize(entityTypeResource, root, parent))
{
Cv_Debug.Error("Failed to initialize entity: " + entityTypeResource);
return(null);
}
foreach (var componentNode in root.ChildNodes)
{
if (componentNode.GetType() != typeof(XmlElement))
{
continue;
}
var component = CreateComponent((XmlElement)componentNode);
if (component != null)
{
entity.AddComponent(component);
}
else
{
return(null);
}
}
return(entity);
}
public bool QueueEvent(Cv_Event newEvent, bool threadSafe = false)
{
if (!threadSafe)
{
Cv_Debug.Assert((m_iActiveQueue >= 0 && m_iActiveQueue < NUM_QUEUES), "EventManager must have an active event queue.");
if (newEvent == null)
{
Cv_Debug.Error("Invalid event in QueueEvent.");
return(false);
}
if (newEvent.WriteToLog)
{
Cv_Debug.Log("Events", "Attempting to queue event " + newEvent.VGetName() + " for entity " + newEvent.EntityID);
}
lock (m_EventListeners)
{
if (m_EventListeners.ContainsKey(newEvent.Type))
{
m_EventQueues[m_iActiveQueue].AddLast(newEvent);
if (newEvent.WriteToLog)
{
Cv_Debug.Log("Events", "Successfully queued event " + newEvent.VGetName());
}
return(true);
}
}
lock (m_ScriptEventListeners)
{
if (m_ScriptEventListeners.ContainsKey(newEvent.Type))
{
m_EventQueues[m_iActiveQueue].AddLast(newEvent);
if (newEvent.WriteToLog)
{
Cv_Debug.Log("Events", "Successfully queued event " + newEvent.VGetName());
}
return(true);
}
}
Cv_Debug.Log("Events", "Skipping event " + newEvent.VGetName() + " since there are no listeners for it.");
return(false);
}
else
{
m_RealTimeEventQueue.Enqueue(newEvent);
return(true);
}
}
public void StopSound(Cv_SoundInstanceData instance, bool immediate = false)
{
if (instance == null)
{
Cv_Debug.Error("Error - No sound defined when trying to stop sound.");
return;
}
if (m_SoundToDataMap.ContainsKey(instance.Instance))
{
StopSound(instance);
}
}
public void FadeOutSound(Cv_SoundInstanceData instance, float interval)
{
if (instance == null)
{
Cv_Debug.Error("Error - No sound defined when trying to stop sound.");
return;
}
if (m_SoundToDataMap.ContainsKey(instance.Instance))
{
FadeSound(instance, 0, interval);
}
}
private void OnPlaySound(Cv_Event eventData)
{
var playEvt = (Cv_Event_PlaySound)eventData;
var entity = CaravelApp.Instance.Logic.GetEntity(playEvt.EntityID);
if (playEvt.Fade && playEvt.Interval > 0)
{
if (playEvt.Volume <= 0)
{
Caravel.SoundManager.FadeOutSound(playEvt.SoundResource, playEvt.Interval);
return;
}
if (entity == null)
{
Cv_Debug.Error("Attempting to play sound without an entity associated.");
return;
}
if (playEvt.Localized)
{
Caravel.SoundManager.FadeInSound2D(playEvt.SoundResource, entity, playEvt.Listener, playEvt.Emitter,
playEvt.Interval, playEvt.Looping, playEvt.Volume, playEvt.Pan, playEvt.Pitch);
}
else
{
Caravel.SoundManager.FadeInSound(playEvt.SoundResource, entity, playEvt.Interval, playEvt.Looping,
playEvt.Volume, playEvt.Pan, playEvt.Pitch);
}
}
else
{
if (entity == null)
{
Cv_Debug.Warning("Attempting to play sound without an entity associated.");
return;
}
if (playEvt.Localized)
{
Caravel.SoundManager.PlaySound2D(playEvt.SoundResource, entity, playEvt.Listener, playEvt.Emitter,
playEvt.Looping, playEvt.Volume, playEvt.Pan, playEvt.Pitch);
}
else
{
Caravel.SoundManager.PlaySound(playEvt.SoundResource, entity, playEvt.Looping,
playEvt.Volume, playEvt.Pan, playEvt.Pitch);
}
}
}
public string GetString(string stringID)
{
string localizedString;
if (m_TextResource.TryGetValue(stringID, out localizedString))
{
return(localizedString);
}
else
{
Cv_Debug.Error("Error - String not found!");
return("");
}
}
private ShapeBoundingBox CalculateAABoundingBox()
{
if (Owner == null)
{
Cv_Debug.Error("Shape not yet associated with an Entity.");
}
var rotation = Owner.GetComponent <Cv_TransformComponent>().Rotation;
var offsetX = AnchorPoint.X;
var offsetY = AnchorPoint.Y;
var rotMatrixZ = Matrix.CreateRotationZ(rotation);
float minX = float.MaxValue;
float minY = float.MaxValue;
float maxX = float.MinValue;
float maxY = float.MinValue;
foreach (var point in Points)
{
var transformedPoint = new Vector2(point.X - offsetX, point.Y - offsetY);
transformedPoint = Vector2.Transform(transformedPoint, rotMatrixZ);
if (transformedPoint.X < minX)
{
minX = transformedPoint.X;
}
if (transformedPoint.Y < minY)
{
minY = transformedPoint.Y;
}
if (transformedPoint.X > maxX)
{
maxX = transformedPoint.X;
}
if (transformedPoint.Y > maxY)
{
maxY = transformedPoint.Y;
}
}
var BoundingBox = new ShapeBoundingBox();
BoundingBox.Start = new Vector2(minX, minY);
BoundingBox.Width = maxX - minX;
BoundingBox.Height = maxY - minY;
return(BoundingBox);
}
public void ResumeSound(Cv_SoundInstanceData instance)
{
if (instance == null)
{
Cv_Debug.Error("Error - No sound defined when trying to resume sound.");
return;
}
if (m_SoundToDataMap.ContainsKey(instance.Instance))
{
instance.Instance.Resume();
instance.Paused = false;
}
}
