public virtual void Init(StageEntry entry, ConfigWeatherData fromWeatherData, string toWeatherName, float renderingTimer, float weatherTimer)
{
this._currentBaseWeatherName = toWeatherName;
ConfigWeatherData weatherDataByName = this.GetWeatherDataByName(toWeatherName);
this._currentRendertingData = (ConfigStageRenderingData)fromWeatherData.configRenderingData.Clone();
this._currentRendertingData.ApplyGlobally();
this._initBaseRenderingData = weatherDataByName.configRenderingData as ConfigStageRenderingData;
this._renderingDataStack.Push(0, new RenderingDataTransition(this._initBaseRenderingData), true);
if (renderingTimer > 0f)
{
this.TransitRenderingData(this._initBaseRenderingData, renderingTimer);
}
else
{
this.SetRenderingDataImmediately(this._initBaseRenderingData);
}
this.SetSubWeathersImmediately(fromWeatherData.configSubWeathers);
this._initBaseSubWeather = weatherDataByName.configSubWeathers;
this._subWeatherStack.Push(0, new SubWeatherTransition(this._initBaseSubWeather, 0), true);
if (weatherTimer > 0f)
{
this.TransitSubWeather(this._initBaseSubWeather, weatherTimer);
}
else
{
this.SetSubWeathersImmediately(this._initBaseSubWeather);
}
this.CommonInit(entry);
}
private void PostAwakeTryLoadFromFile()
{
if (DevLevelConfigData.configFromScene)
{
this.TryDestroyTypeAll <BaseMonoAvatar>();
this.TryDestroyTypeAll <BaseMonoMonster>();
this.TryDestroyTypeAll <MonoBasePerpStage>();
this.TryDestroyTypeAll <MonoStageEnv>();
Resources.UnloadUnusedAssets();
GC.Collect();
GC.WaitForPendingFinalizers();
StageEntry stageEntryByName = StageData.GetStageEntryByName(this.stageDevData.stageName);
GameObject obj2 = UnityEngine.Object.Instantiate <GameObject>(Miscs.LoadResource <GameObject>(stageEntryByName.GetPerpStagePrefabPath(), BundleType.RESOURCE_FILE));
obj2.transform.position = Vector3.zero;
Transform transform = obj2.transform;
transform.position -= obj2.transform.Find(stageEntryByName.LocationPointName).position;
StageManager.SetPerpstageNodeVisibility(obj2.GetComponent <MonoBasePerpStage>(), stageEntryByName, false, false);
StageManager.SetPerpstageNodeVisibility(obj2.GetComponent <MonoBasePerpStage>(), stageEntryByName, true, true);
UnityEngine.Object.Instantiate <GameObject>(Miscs.LoadResource <GameObject>(stageEntryByName.GetEnvPrefabPath(), BundleType.RESOURCE_FILE));
DevAvatarData data = this.avatarDevDatas[0];
UnityEngine.Object.Instantiate <GameObject>(Miscs.LoadResource <GameObject>(AvatarData.GetPrefabResPath(data.avatarType, false), BundleType.RESOURCE_FILE));
this.monsterInstanceIds = new List <int>();
foreach (DevMonsterData data2 in this.monsterDevDatas)
{
this.monsterInstanceIds.Add(UnityEngine.Object.Instantiate <GameObject>(Miscs.LoadResource <GameObject>(MonsterData.GetPrefabResPath(data2.monsterName, data2.typeName, false), BundleType.RESOURCE_FILE)).GetInstanceID());
}
}
}
public static void SetPerpstageNodeVisibility(MonoBasePerpStage perpStage, StageEntry stageEntry, bool useShowNodes, bool visible)
{
if (!useShowNodes)
{
if (!string.IsNullOrEmpty(stageEntry.HideNodeNames))
{
SetPerpstageNodeVisibilityByNode(perpStage, stageEntry.HideNodeNames, visible);
}
if (!string.IsNullOrEmpty(stageEntry.HideNodePrefabPaths))
{
SetPerpstageNodeVisibilityByPrefab(perpStage, stageEntry.HideNodePrefabPaths, visible);
}
}
else
{
if (!string.IsNullOrEmpty(stageEntry.ShowNodeNames))
{
SetPerpstageNodeVisibilityByNode(perpStage, stageEntry.ShowNodeNames, visible);
}
if (!string.IsNullOrEmpty(stageEntry.ShowNodePrefabPaths))
{
SetPerpstageNodeVisibilityByPrefab(perpStage, stageEntry.ShowNodePrefabPaths, visible);
}
}
}
public void LoadNavMeshRelatedLevel(string stageTypeName)
{
StageEntry stageEntryByName = StageData.GetStageEntryByName(stageTypeName);
char[] separator = new char[] { '/' };
string str = stageEntryByName.GetPerpStagePrefabPath().Split(separator)[1];
if (!string.IsNullOrEmpty(this._currentLocatorName))
{
SceneManager.UnloadScene(this._currentLocatorName);
this._currentLocatorName = string.Empty;
}
string locatorName = this.GetLocatorName(stageEntryByName);
foreach (ConfigNavMeshScenePath path in GlobalDataManager.metaConfig.scenePaths)
{
if ((path.MainSceneName == str) && (path.UnitySceneName == locatorName))
{
SceneManager.LoadScene(path.UnitySceneName, LoadSceneMode.Additive);
this._currentLocatorName = locatorName;
this.ResetStageAreaMask(stageEntryByName);
break;
}
}
}
public virtual void Reset(StageEntry entry, ConfigWeatherData weatherData)
{
this._initBaseRenderingData = weatherData.configRenderingData as ConfigStageRenderingData;
this._renderingDataStack.Set(0, new RenderingDataTransition(this._initBaseRenderingData), true);
this.SetRenderingDataImmediately(this._initBaseRenderingData);
this._currentRendertingData.ApplyGlobally();
this._initBaseSubWeather = weatherData.configSubWeathers;
this._subWeatherStack.Set(0, new SubWeatherTransition(this._initBaseSubWeather, 0), true);
this.SetSubWeathersImmediately(this._initBaseSubWeather);
this.CommonInit(entry);
}
private void CommonInit(StageEntry stageEntry)
{
this.InitWindZone();
this.InitLightProb();
this.InitLightMapCorrection();
Singleton <StageManager> .Instance.SetBaseStageEffectSetting(stageEntry.StageEffectSetting);
Singleton <StageManager> .Instance.SetBaseStageEffectSetting(this._subWeatherStack.value.weather.stageEffectSetting);
FixedStack <float> auxTimeScaleStack = Singleton <LevelManager> .Instance.levelEntity.auxTimeScaleStack;
auxTimeScaleStack.onChanged = (Action <float, int, float, int>)Delegate.Combine(auxTimeScaleStack.onChanged, new Action <float, int, float, int>(this.AuxTimeScaleCallback));
}
public virtual void Init(StageEntry entry, string weatherName)
{
this._currentBaseWeatherName = weatherName;
ConfigWeatherData weatherDataByName = this.GetWeatherDataByName(weatherName);
this._initBaseRenderingData = weatherDataByName.configRenderingData as ConfigStageRenderingData;
this._renderingDataStack.Push(0, new RenderingDataTransition(this._initBaseRenderingData), true);
this._currentRendertingData = (ConfigStageRenderingData)this._initBaseRenderingData.Clone();
this._currentRendertingData.ApplyGlobally();
this._initBaseSubWeather = weatherDataByName.configSubWeathers;
this._subWeatherStack.Push(0, new SubWeatherTransition(this._initBaseSubWeather, 0), true);
this.SetSubWeathersImmediately(this._initBaseSubWeather);
this.CommonInit(entry);
}
public static void ReloadFromFile()
{
_stageEntryDict = new Dictionary <string, StageEntry>();
string[] stageEntryPathes = GlobalDataManager.metaConfig.stageEntryPathes;
for (int i = 0; i < stageEntryPathes.Length; i++)
{
ConfigStageRegistry registry = ConfigUtil.LoadConfig <ConfigStageRegistry>(stageEntryPathes[i]);
if (registry.entries != null)
{
for (int j = 0; j < registry.entries.Length; j++)
{
StageEntry entry = registry.entries[j];
_stageEntryDict.Add(entry.TypeName, entry);
}
}
}
}
public void ResetStageAreaMask(StageEntry newStage)
{
uint num;
string locatorName = this.GetLocatorName(newStage);
bool flag = uint.TryParse(locatorName.Substring(locatorName.Length - 2), out num);
if (!flag)
{
flag = uint.TryParse(locatorName.Substring(locatorName.Length - 1), out num);
}
int areaFromName = NavMesh.GetAreaFromName("Walkable");
if (flag)
{
areaFromName = NavMesh.GetAreaFromName("StageMask" + num.ToString());
}
this._stageAreaWalkMask = (((int)1) << areaFromName) | (((int)1) << NavMesh.GetAreaFromName("Walkable"));
}
private void EnqueueForStage(TaskEntry entry, int readyForStage)
{
entry.ReadForStage = readyForStage;
if (!_orderedStage[readyForStage] && (entry.PreviousByCorrelation == null))
{
var stageEntry = new StageEntry {
Entry = entry, Next = null
};
if (_byUnorderedStageFirst[readyForStage] != null)
{
_byUnorderedStageLast[readyForStage].Next = stageEntry;
_byUnorderedStageLast[readyForStage] = stageEntry;
}
else
{
_byUnorderedStageFirst[readyForStage] = stageEntry;
_byUnorderedStageLast[readyForStage] = stageEntry;
}
}
}
public void CreateStage(string typeName, List <string> avatarSpawnNameList, string baseWeatherName, bool isContinued = false)
{
MonoBasePerpStage component;
StageEntry stageEntryByName = StageData.GetStageEntryByName(typeName);
bool isBorn = this._activeStageEntry == null;
Vector3 zero = Vector3.zero;
MonoBasePerpStage.ContinueWeatherDataSettings continueData = null;
if (this._activeStageEntry == null)
{
component = ((GameObject)UnityEngine.Object.Instantiate(Miscs.LoadResource(stageEntryByName.GetPerpStagePrefabPath(), BundleType.RESOURCE_FILE))).GetComponent <MonoBasePerpStage>();
SetPerpstageNodeVisibility(component, stageEntryByName, false, false);
SetPerpstageNodeVisibility(component, stageEntryByName, true, true);
}
else if (this._activeStageEntry.PerpStagePrefabPath != stageEntryByName.PerpStagePrefabPath)
{
zero = this._perpStage.transform.position;
continueData = this._perpStage.GetContinueWeatherDataSetup();
UnityEngine.Object.DestroyImmediate(this._perpStage.gameObject);
Resources.UnloadUnusedAssets();
component = ((GameObject)UnityEngine.Object.Instantiate(Miscs.LoadResource(stageEntryByName.GetPerpStagePrefabPath(), BundleType.RESOURCE_FILE))).GetComponent <MonoBasePerpStage>();
SetPerpstageNodeVisibility(component, stageEntryByName, false, false);
SetPerpstageNodeVisibility(component, stageEntryByName, true, true);
}
else
{
SetPerpstageNodeVisibility(this._perpStage, this._activeStageEntry, false, true);
zero = -this._perpStage.transform.Find(this._activeStageEntry.LocationPointName).localPosition;
continueData = this._perpStage.GetContinueWeatherDataSetup();
component = this._perpStage;
SetPerpstageNodeVisibility(component, stageEntryByName, false, false);
SetPerpstageNodeVisibility(component, stageEntryByName, true, true);
}
Vector3 offset = this.InitAfterCreateStage(stageEntryByName, component, zero, isBorn, baseWeatherName, continueData, isContinued);
Singleton <AvatarManager> .Instance.PreloadTeamAvatars();
Singleton <EventManager> .Instance.FireEvent(new EvtStageCreated(avatarSpawnNameList, isBorn, offset), MPEventDispatchMode.Normal);
}
private Vector3 InitAfterCreateStage(StageEntry stageEntry, MonoBasePerpStage perpStage, Vector3 preStagePos, bool isBorn, string baseWeatherName, MonoBasePerpStage.ContinueWeatherDataSettings continueData, bool isContinued)
{
Vector3 zero = Vector3.zero;
Vector3 vector2 = Vector3.zero;
if (!string.IsNullOrEmpty(stageEntry.LocationPointName))
{
perpStage.transform.position = Vector3.zero;
perpStage.transform.position = -perpStage.transform.Find(stageEntry.LocationPointName).localPosition;
vector2 = perpStage.transform.position - preStagePos;
}
if (this._activeStageEntry == null)
{
perpStage.Init(stageEntry, baseWeatherName);
}
else
{
float renderingTimer = 0f;
float weatherTimer = 0f;
ConfigWeatherData fromWeatherData = null;
ConfigWeatherData toWeatherData = null;
string toWeatherName = null;
if (continueData != null)
{
renderingTimer = continueData.renderingDataContinueTimer;
weatherTimer = continueData.weatherContinueTimer;
fromWeatherData = continueData.currentWeatherData;
toWeatherData = continueData.continueWeatherData;
toWeatherName = continueData.continueWeatherName;
}
if (this._activeStageEntry.PerpStagePrefabPath != stageEntry.PerpStagePrefabPath)
{
if (isContinued)
{
if (renderingTimer > 0f)
{
if (toWeatherName != null)
{
perpStage.Init(stageEntry, fromWeatherData, toWeatherName, renderingTimer, weatherTimer);
}
else
{
perpStage.Init(stageEntry, fromWeatherData, toWeatherData, renderingTimer, weatherTimer);
}
}
else if (toWeatherName != null)
{
perpStage.Init(stageEntry, toWeatherName);
}
else
{
perpStage.Init(stageEntry, toWeatherData);
}
}
else
{
perpStage.Init(stageEntry, baseWeatherName);
}
}
else if (isContinued)
{
if (renderingTimer > 0f)
{
perpStage.TransitWeatherData(toWeatherData, renderingTimer, weatherTimer);
}
else
{
perpStage.Reset(stageEntry, toWeatherData);
}
}
else
{
perpStage.Reset(stageEntry, WeatherData.GetWeatherDataConfig(baseWeatherName));
}
this.CleanForStageTransit();
}
GameObject obj2 = (GameObject)UnityEngine.Object.Instantiate(Miscs.LoadResource(stageEntry.GetEnvPrefabPath(), BundleType.RESOURCE_FILE));
obj2.transform.position = Vector3.zero;
obj2.transform.rotation = Quaternion.identity;
MonoStageEnv component = obj2.GetComponent <MonoStageEnv>();
Vector3 vector3 = new Vector3(0f, -0.05f, 0f);
Transform transform = Miscs.FindFirstChildGivenLayerAndCollider(obj2.transform, LayerMask.NameToLayer("StageCollider"));
if (transform != null)
{
transform.position += vector3;
}
this.RegisterStage(stageEntry, perpStage, component);
return(vector2);
}
private void EnqueueForStage(TaskEntry entry, int readyForStage)
{
entry.ReadForStage = readyForStage;
if (!_orderedStage[readyForStage] && (entry.PreviousByCorrelation == null))
{
var stageEntry = new StageEntry {Entry = entry, Next = null};
if (_byUnorderedStageFirst[readyForStage] != null)
{
_byUnorderedStageLast[readyForStage].Next = stageEntry;
_byUnorderedStageLast[readyForStage] = stageEntry;
}
else
{
_byUnorderedStageFirst[readyForStage] = stageEntry;
_byUnorderedStageLast[readyForStage] = stageEntry;
}
}
}
private string GetLocatorName(StageEntry newStage)
{
char[] separator = new char[] { '/' };
string[] strArray = newStage.LocationPointName.Split(separator);
return(strArray[strArray.Length - 1]);
}
public void RegisterStage(StageEntry stageEntry, MonoBasePerpStage perpStage, MonoStageEnv stageEnv)
{
this._activeStageEntry = stageEntry;
this._perpStage = perpStage;
this._stageEnv = stageEnv;
}
public void GenerateObjSet(string filePath, Model stgpv, ObjectDatabase objdb, TextureDatabase texturedb, StageDatabase staged, string acpath, divamodgen divamods, bool doProcess = true, bool debug = false)
{
/*
* var stgpv = new Model();
* var textures = new MikuMikuLibrary.Textures.TextureSet();
* var texdb = new TextureDatabase();
*
* using (var farcArchive = BinaryFile.Load<FarcArchive>(filePath))
* using (var entryStream = farcArchive.Open(farcArchive.Entries.Where(c => c.Contains("txi")).First(), EntryStreamMode.MemoryStream))
* texdb.Load(entryStream);
*
* if (debug)
* {
* string farcpath = acpath + "\\rom\\objset\\" + Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8") + ".farc";
*
* using (var farcArchive = BinaryFile.Load<FarcArchive>(farcpath))
* using (var entryStream = farcArchive.Open(farcArchive.Entries.Where(c => c.Contains("tex")).First(), EntryStreamMode.MemoryStream))
* textures.Load(entryStream);
*
* }
* else
* {
* using (var farcArchive = BinaryFile.Load<FarcArchive>(filePath))
* using (var entryStream = farcArchive.Open(farcArchive.Entries.Where(c => c.Contains("txd")).First(), EntryStreamMode.MemoryStream))
* textures.Load(entryStream);
*
* using (var farcArchive = BinaryFile.Load<FarcArchive>(filePath))
* using (var entryStream = farcArchive.Open(farcArchive.Entries.First(), EntryStreamMode.MemoryStream))
* stgpv.Load(entryStream, textures, texdb);
* }
*
*/
if (Path.GetFileNameWithoutExtension(filePath).Contains("effpv"))
{
filePath = Path.GetDirectoryName(filePath) + "\\" + Path.GetFileNameWithoutExtension(filePath).Replace("effpv", "stgpv") + "hrc2.farc";
}
var texdb = new TextureDatabase();
//using (var farcArchive = BinaryFile.Load<FarcArchive>(filePath))
//using (var entryStream = farcArchive.Open(farcArchive.Entries.Where(c => c.Contains("txi")).First(), EntryStreamMode.MemoryStream))
// texdb.Load(entryStream);
var objentry = new ObjectEntry();
objentry.ArchiveFileName = Path.GetFileName(filePath).Replace("stgpv0", "stgpv8");
objentry.FileName = Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8") + "_obj.bin";
objentry.Id = FindUnusedID(objdb);
objentry.Name = Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8").ToUpper();
objentry.TextureFileName = Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8") + "_tex.bin";
int ground_id = -1;
ushort counter = 1;
foreach (var meshes in stgpv.Meshes)
{
meshes.SubMeshes.RemoveAll(x => x.Vertices == null || x.Vertices.Length == 0);
meshes.Name = meshes.Name.Replace("STGPV0", "STGPV8");
meshes.Name = meshes.Name.Replace("EFFPV", "STGPV");
if (Path.GetFileName(filePath).Contains("hrc"))
{
int pvid = int.Parse(Path.GetFileName(filePath).Substring(5, 3));
if (pvid < 200)
{
pvid = pvid + 800;
}
{
var check2 = divamods.Divamods.Where(c => c.pvid == pvid).FirstOrDefault();
if (check2 == null)
{
divamods.Divamods.Add(new pdaconversion.divamods(pvid));
Logs.WriteLine("objset: Created new PV at id " + pvid);
check2 = divamods.Divamods.Where(c => c.pvid == pvid).First();
}
check2.item_pv.Add(meshes.Name);
Logs.WriteLine("objset: Added item_pv for PV at id " + pvid + "," + meshes.Name);
}
if (pvid >= 800)
{
var check2 = divamods.Divamods.Where(c => c.pvid == (pvid - 100)).FirstOrDefault();
if (check2 == null)
{
divamods.Divamods.Add(new pdaconversion.divamods(pvid - 100));
Logs.WriteLine("objset: Created new PV at id " + (pvid - 100));
check2 = divamods.Divamods.Where(c => c.pvid == (pvid - 100)).First();
}
check2.item_pv.Add(meshes.Name);
Logs.WriteLine("objset: Added item_pv for PV at id " + (pvid - 100) + "," + meshes.Name);
}
}
var meshentry = new MeshEntry();
meshes.Id = counter;
meshentry.Id = (ushort)meshes.Id;
meshentry.Name = meshes.Name;
if (meshes.Name.Contains("GND"))
{
ground_id = meshes.Id;
}
objentry.Meshes.Add(meshentry);
if (doProcess)
{
if (!debug)
{
/*
* foreach (var submeshes in meshes.SubMeshes)
* {
* foreach (var indexTable in submeshes.IndexTables)
* {
* ushort[] triangleStrip = Stripifier.Stripify(indexTable.Indices);
* if (triangleStrip != null)
* {
* indexTable.PrimitiveType = PrimitiveType.TriangleStrip;
* indexTable.Indices = triangleStrip;
* }
* }
* }
*/
}
//foreach (var textures in M)
foreach (var material in meshes.Materials)
{
if ((Path.GetFileName(filePath).Contains("hrc2")) || (Path.GetFileName(filePath).Contains("hrc")))
{
material.Shader = "ITEM";
material.IsAlphaEnabled = false;
//material.Field00 = 0x00000001;
//material.Field02 = 0x00000A80;
//material.Diffuse.Field00 = 0x00000000;
//material.Diffuse.Field01 = 0x016400E1;
//material.Diffuse.Field02 = 0x000000F1;
MikuMikuLibrary.Misc.Color asdf = new MikuMikuLibrary.Misc.Color(0, 0, 0, 0);
material.SpecularColor = asdf;
//material.AmbientColor = asdf;
//material.EmissionColor = asdf;
//material.SpecularColor = asdf;
//material.Shininess = 1;
//material.Diffuse.Field00 = 0x00000000;
//material.Diffuse.Field01 = 0x002400E0;
//material.Diffuse.Field02 = 0x000000F1;
if (material.Ambient.TextureId == 1509989155)
{
material.Ambient.TextureId = -1;
}
if (material.Normal.TextureId == 1509989155)
{
material.Normal.TextureId = -1;
}
if (material.Specular.TextureId == 1509989155)
{
material.Specular.TextureId = -1;
material.SpecularColor = asdf;
}
//else { material.Field00 = 0x0000002D; }
/*
*
* // this blacken the screen on STAGE SHADER
* material.Specular.Field01 = 0x002418C3;
* material.Specular.Field02 = 0x000000F3;
* material.Specular.Field05 = 1;
* material.Specular.Field06 = 1;
* material.Specular.Field11 = 1;
* material.Specular.Field16 = 1;
* material.Specular.Field21 = 1;
*
*
* material.Specular.TextureId = -1;
* material.Specular.Field01 = 0x00000000;
* material.Specular.Field02 = 0x000000F0;
* material.Specular.Field05 = 1;
* material.Specular.Field06 = 0;
* material.Specular.Field11 = 0;
* material.Specular.Field16 = 0;
* material.Specular.Field21 = 0;
*
* material.Reflection.TextureId = -1;
* material.Reflection.Field01 = 0x00000000;
* material.Reflection.Field02 = 0x000000F0;
* material.Reflection.Field05 = 1;
* material.Reflection.Field06 = 0;
* material.Reflection.Field11 = 0;
* material.Reflection.Field16 = 0;
* material.Reflection.Field21 = 0;
*/
if (material.Reflection.TextureId == 1509989155)
{
material.Reflection.TextureId = -1;
}
if (material.ToonCurve.TextureId == 1509989155)
{
material.ToonCurve.TextureId = -1;
}
if (material.SpecularPower.TextureId == 1509989155)
{
material.SpecularPower.TextureId = -1;
}
if (material.Texture08.TextureId == 1509989155)
{
material.Texture08.TextureId = -1;
}
}
else
{
material.Shader = "BLINN";
//material.Field00 = 0x0000000D;
//material.Field02 = 0x00000A80;
MikuMikuLibrary.Misc.Color asdf = new MikuMikuLibrary.Misc.Color(0, 0, 0, 0);
//material.AmbientColor = asdf;
//material.EmissionColor = asdf;
//material.Shininess = 1;
//material.Diffuse.Field00 = 0x00000230;
//material.Diffuse.Field02 = 0x002418C3;
if (material.Ambient.TextureId == 1509989155)
{
material.Ambient.TextureId = -1;
}
if (material.Normal.TextureId == 1509989155)
{
material.Normal.TextureId = -1;
}
if (material.Specular.TextureId == 1509989155)
{
material.Specular.TextureId = -1;
material.SpecularColor = asdf;
}
//else { material.Field00 = 0x0000002D; }
/*
*
* // this blacken the screen on STAGE SHADER
* material.Specular.Field01 = 0x002418C3;
* material.Specular.Field02 = 0x000000F3;
* material.Specular.Field05 = 1;
* material.Specular.Field06 = 1;
* material.Specular.Field11 = 1;
* material.Specular.Field16 = 1;
* material.Specular.Field21 = 1;
*
*/
/*
* material.Specular.TextureId = -1;
* material.Specular.Field01 = 0x00000000;
* material.Specular.Field02 = 0x000000F0;
* material.Specular.Field05 = 5;
* material.Specular.Field06 = 0;
* material.Specular.Field11 = 0;
* material.Specular.Field16 = 0;
* material.Specular.Field21 = 0;
*
*
* material.Normal.Field01 = 0x00000000;
* material.Normal.Field02 = 0x000000F0;
* material.Normal.Field05 = 5;
* material.Normal.Field06 = 0;
* material.Normal.Field11 = 0;
* material.Normal.Field16 = 0;
* material.Normal.Field21 = 0;
*
*
* material.ToonCurve.TextureId = -1;
* material.ToonCurve.Field01 = 0x00000000;
* material.ToonCurve.Field02 = 0x000000F0;
* material.ToonCurve.Field05 = 5;
* material.ToonCurve.Field06 = 0;
* material.ToonCurve.Field11 = 0;
* material.ToonCurve.Field16 = 0;
* material.ToonCurve.Field21 = 0;
*/
if (material.Reflection.TextureId == 1509989155)
{
material.Reflection.TextureId = -1;
}
if (material.ToonCurve.TextureId == 1509989155)
{
material.ToonCurve.TextureId = -1;
}
if (material.SpecularPower.TextureId == 1509989155)
{
material.SpecularPower.TextureId = -1;
}
if (material.Texture08.TextureId == 1509989155)
{
material.Texture08.TextureId = -1;
}
}
}
}
counter++;
}
stgpv.TextureSet.Format = BinaryFormat.DT;
stgpv.Format = BinaryFormat.DT;
if (doProcess)
{
stgpv.Save("temp\\" + Path.GetFileNameWithoutExtension(filePath) + "_obj.bin", null, texturedb, null);
}
objdb.Objects.Add(objentry);
if (Path.GetFileNameWithoutExtension(filePath).Count() == 8)
{
StageEntry stage = new StageEntry();
stage.Id = FindUnusedID(staged);
stage.Name = Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8").ToUpper();
stage.ObjectGroundId = (short)ground_id;
stage.ObjectGroundIdFlag = (short)objentry.Id;
stage.ObjectId3 = -1;
stage.ObjectIdFlag3 = -1;
stage.ObjectId5 = -1;
stage.ObjectIdFlag5 = -1;
stage.ObjectId7 = -1;
stage.ObjectIdFlag7 = -1;
stage.RingRectangleX = -8;
stage.RingRectangleY = -8;
stage.RingRectangleWidth = 16;
stage.RingRectangleHeight = 16;
stage.RingRingHeight = 0;
stage.RingOutHeight = -1000;
stage.Field00 = 1;
stage.Field11 = -1;
stage.Field02 = -1;
stage.LensFlareScaleX = -1;
stage.LensFlareScaleY = -1;
stage.LensFlareScaleZ = -1;
stage.ObjectSkyId = -1;
stage.ObjectSkyIdFlag = -1;
stage.ObjectReflectId = -1;
stage.ObjectReflectIdFlag = -1;
stage.CollisionFilePath = @"rom/STGTST_COLI.000.bin";
stage.ObjectId1 = (short)objentry.Id;
stage.StageEffect1 = StageEntry.StageEffect.Empty;
stage.Auth3dName = "EFF" + stage.Name;
staged.Stages.Add(stage);
}
if (doProcess)
{
var newfarc = new FarcArchive();
newfarc.Add(Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8") + "_obj.bin", "temp\\" + Path.GetFileNameWithoutExtension(filePath) + "_obj.bin");
newfarc.Add(Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8") + "_tex.bin", "temp\\" + Path.GetFileNameWithoutExtension(filePath) + "_tex.bin");
newfarc.Alignment = 16;
newfarc.IsCompressed = false;
newfarc.Save(acpath + "\\rom\\objset\\" + Path.GetFileNameWithoutExtension(filePath).Replace("stgpv0", "stgpv8") + ".farc");
}
}
private void HandleAlreadyLoadedPrefabs()
{
RuntimeIDManager instance = Singleton <RuntimeIDManager> .Instance;
StageEntry stageEntryByName = StageData.GetStageEntryByName(this.stageDevData.stageName);
MonoBasePerpStage perpStage = UnityEngine.Object.FindObjectOfType <MonoBasePerpStage>();
if (perpStage != null)
{
perpStage.Init(stageEntryByName, (string)null);
}
MonoStageEnv stageEnv = UnityEngine.Object.FindObjectOfType <MonoStageEnv>();
Singleton <StageManager> .Instance.RegisterStage(stageEntryByName, perpStage, stageEnv);
LevelActor actor = (LevelActor)Singleton <EventManager> .Instance.GetActor(0x21800001);
actor.levelMode = this.LEVEL_MODE;
BaseMonoAvatar avatar = UnityEngine.Object.FindObjectOfType <BaseMonoAvatar>();
if (avatar != null)
{
DevAvatarData devAvatarData = this.avatarDevDatas[0];
AvatarDataItem avatarDataItem = Singleton <AvatarModule> .Instance.GetDummyAvatarDataItem(this.avatarTypeNames[0], devAvatarData.avatarLevel, devAvatarData.avatarStar);
this.SetUpAvatarDataItem(avatarDataItem, devAvatarData);
uint nextRuntimeID = instance.GetNextRuntimeID(3);
avatar.Init(true, nextRuntimeID, avatarDataItem.AvatarRegistryKey, avatarDataItem.GetWeapon().ID, avatar.transform.position, avatar.transform.forward, true);
this.LoadAvatarWwiseSoundBank(avatar);
AvatarActor actor2 = Singleton <EventManager> .Instance.CreateActor <AvatarActor>(avatar);
actor2.InitAvatarDataItem(avatarDataItem, true, false, true, true);
actor2.PostInit();
Singleton <AvatarManager> .Instance.RegisterAvatar(avatar, true, true, false);
this.SetUpAvatarSkill(actor2, devAvatarData);
this.CheatForPariticleMode(actor2);
for (int i = 1; i < this.avatarCount; i++)
{
DevAvatarData data2 = this.avatarDevDatas[i];
AvatarDataItem item2 = Singleton <AvatarModule> .Instance.GetDummyAvatarDataItem(this.avatarTypeNames[i], data2.avatarLevel, data2.avatarStar);
this.SetUpAvatarDataItem(item2, data2);
uint runtimeID = instance.GetNextRuntimeID(3);
Singleton <AvatarManager> .Instance.CreateAvatar(item2, false, avatar.XZPosition, avatar.FaceDirection, runtimeID, false, false, false, false);
AvatarActor actor3 = Singleton <EventManager> .Instance.GetActor <AvatarActor>(runtimeID);
this.SetUpAvatarSkill(actor3, data2);
this.CheatForPariticleMode(actor3);
}
if (this.useFakeHelper)
{
this.CreateFakeFriendAvatar();
}
Singleton <CinemaDataManager> .Instance.Preload(avatar);
}
foreach (BaseMonoMonster monster in UnityEngine.Object.FindObjectsOfType <BaseMonoMonster>())
{
DevMonsterData data3 = null;
int instanceID = monster.gameObject.GetInstanceID();
for (int j = 0; j < this.monsterInstanceIds.Count; j++)
{
if (this.monsterInstanceIds[j] == instanceID)
{
data3 = this.monsterDevDatas[j];
break;
}
}
if (data3 == null)
{
UnityEngine.Object.Destroy(monster.gameObject);
}
else
{
string monsterName;
string typeName;
uint num7 = instance.GetNextRuntimeID(4);
if (data3.uniqueMonsterID != 0)
{
UniqueMonsterMetaData uniqueMonsterMetaData = MonsterData.GetUniqueMonsterMetaData(data3.uniqueMonsterID);
monsterName = uniqueMonsterMetaData.monsterName;
typeName = uniqueMonsterMetaData.typeName;
}
else
{
monsterName = data3.monsterName;
typeName = data3.typeName;
}
bool isElite = data3.isElite;
monster.Init(monsterName, typeName, num7, monster.transform.position, data3.uniqueMonsterID, null, true, isElite, true, 0);
for (int k = 0; k < monster.config.CommonArguments.RequestSoundBankNames.Length; k++)
{
Singleton <WwiseAudioManager> .Instance.ManualPrepareBank(monster.config.CommonArguments.RequestSoundBankNames[k]);
}
MonsterActor actor4 = Singleton <EventManager> .Instance.CreateActor <MonsterActor>(monster);
actor4.InitLevelData(data3.level, data3.isElite);
actor4.PostInit();
Singleton <MonsterManager> .Instance.RegisterMonster(monster);
if (data3.abilities.Length > 0)
{
for (int m = 0; m < data3.abilities.Length; m++)
{
string str3 = data3.abilities[m];
if (!string.IsNullOrEmpty(str3))
{
actor4.abilityPlugin.InsertPreInitAbility(AbilityData.GetAbilityConfig(data3.abilities[m]));
}
}
}
if (data3.isStationary)
{
MonsterActor actor5 = Singleton <EventManager> .Instance.GetActor <MonsterActor>(monster.GetRuntimeID());
actor5.baseMaxHP = actor5.HP = actor5.maxHP = 999999f;
monster.GetActiveAIController().SetActive(false);
}
}
}
Singleton <LevelManager> .Instance.levelActor.SuddenLevelStart();
EvtStageReady evt = new EvtStageReady {
isBorn = true
};
Singleton <EventManager> .Instance.FireEvent(evt, MPEventDispatchMode.Normal);
Singleton <DetourManager> .Instance.LoadNavMeshRelatedLevel(this.stageDevData.stageName);
Singleton <MainUIManager> .Instance.GetInLevelUICanvas().FadeInStageTransitPanel(0.18f, false, null, null);
}
