public static bool IsCubeNearby(out ActorCommonData CubeStand)
{
CubeStand = new ActorCommonData();
try
{
List <ACD> AllActors;
lock (A_Collection.Environment.Actors.AllActors) AllActors = A_Collection.Environment.Actors.AllActors;
var acd = AllActors.FirstOrDefault(x => x._ACD.x090_ActorSnoId == KanaiCube_Stand)._ACD;
if (acd != null)
{
CubeStand = acd;
return(true);
}
return(false);
}
catch (Exception)
{
return(false);
}
}
public ModuloActor(int modulo, int offset, Color4 gnomonColor)
{
Modulo = modulo;
Offset = offset;
GnomonColor = gnomonColor;
Slope = 4;
Speed = 1;
IsSorted = true;
Time = 0;
FadeInTime = 1.6;
Brightness = 1;
if (AllActors == null)
{
AllActors = new List <ModuloActor>();
FibonacciNumbers.Add(1);
FibonacciNumbers.Add(2);
for (int i = 2; FibonacciNumbers.Last() < 1024; i++)
{
FibonacciNumbers.Add(FibonacciNumbers[i - 1] + FibonacciNumbers[i - 2]);
}
}
AllActors.Add(this);
}
public static VNActor.Actor scenef_get_actor(string id)
{
if (AllActors.ContainsKey(id))
{
VNActor.Actor obj = AllActors[id];
return(obj);
}
return(null);
}
public void Update(double elapsed)
{
Time += elapsed;
if (Time > Duration)
{
AllActors.Remove(this);
}
}
public static void UpdateAll(double elapsed)
{
if (AllActors == null)
{
return;
}
foreach (FeedbackActor actor in AllActors.ToArray())
{
actor.Update(elapsed);
}
}
private T CreateActor <T>(SubclassOf <Actor> ActorClass, ActorScript actorScript) where T : Actor
{
Actor actor = null;
if (ActorClass != null)
{
actor = Activator.CreateInstance(ActorClass) as Actor;
actor.PostConstruct();
if (actorScript != null)
{
actorScript.ApplyToObject(actor);
}
else
{
actor.PostScriptApplied();
}
}
else if (actorScript != null)
{
actor = actorScript.CreateInstance <Actor>();
}
else
{
throw new ArgumentNullException(nameof(ActorClass), "Both Actor Class and ActorScript cannot be null. Provide one.");
}
if (actor.Name == null)
{
int CompCount = AllActors.Count(x => x.GetType().Name == actor.GetType().Name);
actor.Name = string.Format("{0}_{1}", actor.GetType().Name, CompCount);
}
_AllActors.Add(actor);
List <ResourcePtr> ResourceCollector = new List <ResourcePtr>();
actor.CollectResources(ResourceCollector);
if (ResourceCollector.Count > 0)
{
FileSystem.BulkLoadAssets(ResourceCollector,
() => FinishSpawningActor(actor), null);
}
else
{
FinishSpawningActor(actor);
}
return(actor as T);
}
public FeedbackActor(int index, Color4 color, double duration)
{
Index = index - 1;
Color = color;
Duration = duration;
Time = 0;
if (AllActors == null)
{
AllActors = new List <FeedbackActor>();
}
AllActors.Add(this);
}
public static bool IsUrshiNearby(out ActorCommonData Urshi_Actor)
{
Urshi_Actor = new ActorCommonData();
try
{
List <ACD> AllActors;
lock (A_Collection.Environment.Actors.AllActors) AllActors = A_Collection.Environment.Actors.AllActors;
var acd = AllActors.FirstOrDefault(x => x._ACD.x090_ActorSnoId == Urshi_ActorSNO)._ACD;
if (acd != null)
{
Urshi_Actor = acd;
return(true);
}
return(false);
}
catch (Exception)
{
return(false);
}
}
public static void LoadTrackedActorsAndProps()
{
List <OCIFolder> folders = scene_get_all_folders_raw();
AllActors.Clear();
AllProps.Clear();
foreach (OCIFolder fld in folders)
{
string fldName = fld.name;
if (fldName.StartsWith(actor_folder_prefix))
{
string actorAlias;
string actorColor = "ffffff";
string actorTitle = null;
// analysis actor tag
var tagElements = fldName.Split(':');
if (tagElements.Length == 2)
{
actorAlias = tagElements[1];
}
else if (tagElements.Length == 3)
{
actorAlias = tagElements[1];
actorColor = tagElements[2];
}
else
{
actorAlias = tagElements[1];
actorColor = tagElements[2];
actorTitle = tagElements[3];
}
if (!AllActors.ContainsKey(actorAlias))
{
var hsociChar = NeoOCI.create_from_treenode(fld.treeNodeObject.parent.parent.parent);
if (hsociChar is VNActor.Actor chara)
{
if (actorTitle is null)
{
actorTitle = hsociChar.text_name;
}
AllActors[actorAlias] = chara;
//register_char(actorAlias, actorColor, actorTitle);
StudioController.Instance.GetLogger.LogDebug("Registered actor: '" + actorAlias + "' as " + actorTitle + " (#" + actorColor + ")");
}
}
}
else if (fldName.StartsWith(prop_folder_prefix))
{
// analysis props tag
string propAlias = fldName.Substring(prop_folder_prefix.Length).Trim();
// register props
if (!AllProps.ContainsKey(propAlias))
{
NeoOCI oci = NeoOCI.create_from_treenode(fld.treeNodeObject.parent);
if (oci is Prop propOci)
{
AllProps[propAlias] = propOci;
StudioController.Instance.GetLogger.LogDebug("Registered prop: '" + Utils.to_roman(propAlias) + "' as " + Utils.to_roman(oci.text_name));
}
}
}
else if (fldName.StartsWith(light_folder_prefix))
{
string propAlias = fldName.Substring(light_folder_prefix.Length).Trim();
// register props
if (!AllProps.ContainsKey(propAlias))
{
NeoOCI oci = NeoOCI.create_from_treenode(fld.treeNodeObject.child[0]);
if (oci is VNActor.Light propOci)
{
AllProps[propAlias] = propOci;
StudioController.Instance.GetLogger.LogDebug("Registered light: '" + Utils.to_roman(propAlias) + "' as " + Utils.to_roman(oci.text_name));
}
}
}
}
}
private T CreateActor <T>(SubclassOf <Actor> ActorClass, ActorScript actorScript) where T : Actor
{
Actor actor = null;
if (ActorClass != null)
{
actor = Activator.CreateInstance(ActorClass) as Actor;
actor.PostConstruct();
if (actorScript != null)
{
actorScript.ApplyToObject(actor);
}
else
{
actor.PostScriptApplied();
}
}
else if (actorScript != null)
{
actor = actorScript.CreateInstance <Actor>();
}
else
{
throw new ArgumentNullException(nameof(ActorClass), "Both Actor Class and ActorScript cannot be null. Provide one.");
}
if (actor.Name == null)
{
int CompCount = AllActors.Count(x => x.GetType().Name == actor.GetType().Name);
actor.Name = string.Format("{0}_{1}", actor.GetType().Name, CompCount);
}
_AllActors.Add(actor);
//Init all constructor created actors
foreach (var Property in actor.GetType().GetProperties())
{
if (typeof(ActorComponent).IsAssignableFrom(Property.PropertyType))
{
ActorComponent comp = Property.GetValue(actor) as ActorComponent;
if (comp == null)
{
if (Property.SetMethod != null && Property.GetCustomAttribute <DontConstructComponentAttribute>(true) != null)
{
comp = Activator.CreateInstance(Property.PropertyType) as ActorComponent;
Property.SetValue(actor, comp);
}
else
{
continue;
}
}
if (!comp.Registered)
{
comp.Register();
}
}
}
List <ResourcePtr> ResourceCollector = new List <ResourcePtr>();
actor.CollectResources(ResourceCollector);
if (ResourceCollector.Count > 0)
{
FileSystem.BulkLoadAssets(ResourceCollector,
() => FinishSpawningActor(actor), null);
}
else
{
FinishSpawningActor(actor);
}
return(actor as T);
}
public Actors(string FileName, string PackageName = "")
{
if (FileName.FileExists() == false)
{
throw new System.IO.FileNotFoundException(FileName);
}
BaseDirectory = FileName.GetDirectoryFromFileLocation();
XElement xelement = XElement.Load(FileName);
this.ID = xelement.Element("id").Value;
this.Name = xelement.Element("name").Value;
this.DisplayName = xelement.Element("displayname").Value;
this.Description = xelement.Element("description").Value;
this.AuthorName = xelement.Element("author").Value;
this.UpdateDate = xelement.Element("date").Value;
this.PackageName = PackageName;
IEnumerable <XElement> ActorObjects = xelement.Elements().Where(x => x.Name.ToString() == "actors");
foreach (var ActorObject in ActorObjects.Elements().Where(x => x.Name.ToString() == "actor"))
{
ActorInfo _NewActor = new ActorInfo();
_NewActor.ID = ActorObject.Element("id").Value;
_NewActor.Name = ActorObject.Element("name").Value;
_NewActor.DisplayName = ActorObject.Element("displayname").Value;
_NewActor.Description = ActorObject.Element("description").Value;
_NewActor.AuthorName = ActorObject.Element("author").Value;
_NewActor.UpdateDate = ActorObject.Element("date").Value;
_NewActor.DefaultFrameDelay = ActorObject.Element("defaultframedelay").Value.ToInt(0);
IEnumerable <XElement> ActorAnimationObjects = ActorObject.Elements().Where(x => x.Name.ToString() == "animations");
foreach (var ActorAnimationObject in ActorAnimationObjects.Elements().Where(x => x.Name.ToString() == "animation"))
{
ActorAnimation _NewAnimation = new ActorAnimation();
_NewAnimation.Name = ActorAnimationObject.Element("name").Value;
_NewAnimation.Filename = ActorAnimationObject.Element("filename").Value;
if (System.IO.File.Exists(this.BaseDirectory + _NewAnimation.Filename) == false)
{
this.LoadErrors.Add(_NewActor.ID + "-" + _NewAnimation.Name + "-Error Locating Image File", this.BaseDirectory.EnsureDirectoryFormat() + _NewAnimation.Filename);
continue;
}
if (this.Images.ContainsKey(_NewAnimation.Filename))
{
}
else
{
this.Images.Add(_NewAnimation.Filename, new CompressibleImage(System.Drawing.Image.FromFile(this.BaseDirectory.EnsureDirectoryFormat() + _NewAnimation.Filename), System.Drawing.Imaging.ImageFormat.Png));
}
_NewAnimation.Direction = ActorAnimationObject.Element("direction").Value;
try
{
_NewAnimation.DirectionValue = (Enumerations.RelativePosition)Enum.Parse(typeof(Enumerations.RelativePosition), _NewAnimation.Direction);
}
catch
{
LoadErrors.Add(_NewActor.ID + "-Animation-" + _NewAnimation.Name + "Direction", "Animation: " + _NewAnimation.Name + " - Error Converting Direction");
}
IEnumerable <XElement> ActorAnimationFrameObjects = ActorAnimationObject.Elements().Where(x => x.Name.ToString() == "frames");
foreach (var ActorAnimationFrameObject in ActorAnimationFrameObjects.Elements().Where(x => x.Name.ToString() == "frame"))
{
ActorAnimationFrame _NewFrame = new ActorAnimationFrame();
_NewFrame.ID = ActorAnimationFrameObject.Attribute("id").Value.ToInt(-1);
if (ActorAnimationFrameObject.Attribute("nextid").Value.StartsWith("{"))
{
// TODO Add Split Method
}
else
{
_NewFrame.NextID.Add(ActorAnimationFrameObject.Attribute("nextid").Value.ToInt(-1));
}
var DrawingRec2 = ActorAnimationFrameObject.Attribute("imagerec").Value.ToRectangle();
if (DrawingRec2 == System.Drawing.Rectangle.Empty)
{
_NewFrame.ImageRect = Microsoft.Xna.Framework.Rectangle.Empty;
LoadErrors.Add(_NewActor.ID + "-Animation-" + _NewAnimation.Name + "-Frame-" + _NewFrame.ID.ToString(), "Invalid Source Rect");
}
else
{
_NewFrame.ImageRect = new Microsoft.Xna.Framework.Rectangle(DrawingRec2.X, DrawingRec2.Y, DrawingRec2.Width, DrawingRec2.Height);
}
try
{
var Anchor = ActorAnimationFrameObject.Attribute("anchor").Value;
string[] _Points = Anchor.SplitString(",", StringSplitOptions.RemoveEmptyEntries);
if (_Points.Length == 2)
{
_NewFrame.Anchor = new Vector2(_Points[0].ToInt(0), _Points[1].ToInt(0));
}
else
{
_NewFrame.Anchor = new Vector2(0, 0);
}
}
catch
{
_NewFrame.Anchor = new Vector2(0, 0);
}
try
{
_NewFrame.Delay = ActorAnimationFrameObject.Attribute("delay").Value.ToInt(_NewActor.DefaultFrameDelay);
}
catch
{
_NewFrame.Delay = _NewActor.DefaultFrameDelay;
}
_NewAnimation.Frames.Add(_NewFrame.ID, _NewFrame);
}
if (_NewActor.Animations.ContainsKey(_NewAnimation.Name + _NewAnimation.Direction))
{
LoadErrors.Add(_NewActor.ID + "-Animation-" + _NewAnimation.Name + "-DuplicateAnimationName", "AnimationName: " + _NewAnimation.Name + _NewAnimation.Direction + " - Duplicate Animation Name Found");
}
else
{
_NewActor.Animations.Add(_NewAnimation.Name + _NewAnimation.Direction, _NewAnimation);
}
}
AllActors.Add(_NewActor.Name, _NewActor);
}
}
public VoiceActor GetVoiceActorById(int voiceActorId)
{
return(AllActors.FirstOrDefault(a => a.Id == voiceActorId));
}
