/// <summary>
/// Set ParticleSystem shape field value.
/// </summary>
/// <param name="particleSystem"></param>
/// <param name="vgoModule"></param>
/// <param name="textureItemList"></param>
protected virtual void SetModuleValue(ParticleSystem particleSystem, VGO_PS_ShapeModule vgoModule, IList <TextureItem> textureItemList)
{
if (vgoModule == null)
{
return;
}
ShapeModule module = particleSystem.shape;
module.enabled = vgoModule.enabled;
module.shapeType = vgoModule.shapeType;
module.angle = vgoModule.angle;
module.radius = vgoModule.radius;
module.donutRadius = vgoModule.donutRadius;
module.radiusMode = vgoModule.radiusMode;
module.radiusSpread = vgoModule.radiusSpread;
module.radiusSpeed = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.radiusSpeed);
module.radiusSpeedMultiplier = vgoModule.radiusSpeedMultiplier;
module.radiusThickness = vgoModule.radiusThickness;
module.boxThickness = ArrayConverter.ToVector3(vgoModule.boxThickness, reverseZ: true);
module.arc = vgoModule.arc;
module.arcMode = vgoModule.arcMode;
module.arcSpread = vgoModule.arcSpread;
module.arcSpeed = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.arcSpeed);
module.arcSpeedMultiplier = vgoModule.arcSpeedMultiplier;
module.length = vgoModule.length;
module.meshShapeType = vgoModule.meshShapeType;
module.meshSpawnMode = vgoModule.meshSpawnMode;
module.meshSpawnSpread = vgoModule.meshSpawnSpread;
module.meshSpawnSpeed = VgoParticleSystemMinMaxCurveConverter.CreateMinMaxCurve(vgoModule.meshSpawnSpeed);
module.meshSpawnSpeedMultiplier = vgoModule.meshSpawnSpeedMultiplier;
//module.mesh;
//module.meshRenderer;
//module.skinnedMeshRenderer;
module.useMeshMaterialIndex = vgoModule.useMeshMaterialIndex;
module.meshMaterialIndex = vgoModule.meshMaterialIndex;
module.useMeshColors = vgoModule.useMeshColors;
//module.sprite;
//module.spriteRenderer;
module.normalOffset = vgoModule.normalOffset;
if ((textureItemList != null) && (-1 < vgoModule.textureIndex) && (vgoModule.textureIndex < textureItemList.Count))
{
module.texture = textureItemList[vgoModule.textureIndex].Texture;
}
module.textureClipChannel = vgoModule.textureClipChannel;
module.textureClipThreshold = vgoModule.textureClipThreshold;
module.textureColorAffectsParticles = vgoModule.textureColorAffectsParticles;
module.textureAlphaAffectsParticles = vgoModule.textureAlphaAffectsParticles;
module.textureBilinearFiltering = vgoModule.textureBilinearFiltering;
module.textureUVChannel = vgoModule.textureUVChannel;
module.position = ArrayConverter.ToVector3(vgoModule.position, reverseZ: true);
module.rotation = ArrayConverter.ToVector3(vgoModule.rotation, reverseZ: true);
module.scale = ArrayConverter.ToVector3(vgoModule.scale);
module.alignToDirection = vgoModule.alignToDirection;
module.randomPositionAmount = vgoModule.randomPositionAmount;
module.sphericalDirectionAmount = vgoModule.sphericalDirectionAmount;
module.randomDirectionAmount = vgoModule.randomDirectionAmount;
}
/// <summary>
/// Create VGO_PS_ShapeModule from ShapeModule.
/// </summary>
/// <param name="module"></param>
/// <param name="gltf"></param>
/// <returns></returns>
/// <remarks>
/// @notice TextureIO.ExportTexture() may export the same texture multiple times.
/// </remarks>
protected virtual VGO_PS_ShapeModule CreateVgoModule(ShapeModule module, glTF gltf)
{
var vgoShapeModule = new VGO_PS_ShapeModule()
{
enabled = module.enabled,
shapeType = module.shapeType,
angle = module.angle,
radius = module.radius,
donutRadius = module.donutRadius,
radiusMode = module.radiusMode,
radiusSpread = module.radiusSpread,
radiusSpeed = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.radiusSpeed),
radiusSpeedMultiplier = module.radiusSpeedMultiplier,
radiusThickness = module.radiusThickness,
boxThickness = module.boxThickness.ReverseZ().ToArray(),
arc = module.arc,
arcMode = module.arcMode,
arcSpread = module.arcSpread,
arcSpeed = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.arcSpeed),
arcSpeedMultiplier = module.arcSpeedMultiplier,
length = module.length,
meshShapeType = module.meshShapeType,
meshSpawnMode = module.meshSpawnMode,
meshSpawnSpread = module.meshSpawnSpread,
meshSpawnSpeed = VgoParticleSystemMinMaxCurveConverter.CreateFrom(module.meshSpawnSpread),
meshSpawnSpeedMultiplier = module.meshSpawnSpeedMultiplier,
//mesh
//meshRenderer
//skinnedMeshRenderer
useMeshMaterialIndex = module.useMeshMaterialIndex,
meshMaterialIndex = module.meshMaterialIndex,
useMeshColors = module.useMeshColors,
//sprite
//spriteRenderer
normalOffset = module.normalOffset,
textureIndex = -1,
textureClipChannel = module.textureClipChannel,
textureClipThreshold = module.textureClipThreshold,
textureColorAffectsParticles = module.textureColorAffectsParticles,
textureAlphaAffectsParticles = module.textureAlphaAffectsParticles,
textureBilinearFiltering = module.textureBilinearFiltering,
textureUVChannel = module.textureUVChannel,
position = module.position.ReverseZ().ToArray(),
rotation = module.rotation.ReverseZ().ToArray(),
scale = module.scale.ToArray(),
alignToDirection = module.alignToDirection,
randomPositionAmount = module.randomPositionAmount,
sphericalDirectionAmount = module.sphericalDirectionAmount,
randomDirectionAmount = module.randomDirectionAmount,
};
if (module.texture != null)
{
vgoShapeModule.textureIndex = TextureIO.ExportTexture(gltf, gltf.buffers.Count - 1, module.texture, glTFTextureTypes.Unknown);
}
return(vgoShapeModule);
}
private void PlaceModifierParticle(TowerController tower, PropertyModifier[] propertyModifiers)
{
if (propertyModifiers[0] == PropertyModifier.None)
{
return;
}
GameObject temporaryParticle = Instantiate(propertyModifierParticlePrefabs[(int)propertyModifiers[0]], tower.transform);
temporaryParticle.transform.localPosition = Vector3.zero;
temporaryParticles.Add(temporaryParticle);
ParticleSystem ps = temporaryParticle.GetComponent <ParticleSystem>();
ShapeModule shape = ps.shape;
MeshRenderer targetMesh = PropertyModifierHelper.FindCorrectMeshRendererForProperty(tower, propertyModifiers);
shape.meshRenderer = targetMesh;
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
node.Add(LengthInSecName, LengthInSec);
node.Add(SimulationSpeedName, SimulationSpeed);
node.Add(StopActionName, (int)StopAction);
node.Add(LoopingName, Looping);
node.Add(PrewarmName, Prewarm);
node.Add(PlayOnAwakeName, PlayOnAwake);
node.Add(UseUnscaledTimeName, UseUnscaledTime);
node.Add(AutoRandomSeedName, GetAutoRandomSeed(container.Version));
node.Add(UseRigidbodyForVelocityName, GetUseRigidbodyForVelocity(container.Version));
node.Add(StartDelayName, GetStartDelay(container.Version).ExportYAML(container));
node.Add(MoveWithTransformName, (int)MoveWithTransform);
node.Add(MoveWithCustomTransformName, MoveWithCustomTransform.ExportYAML(container));
node.Add(ScalingModeName, (int)GetScalingMode(container.Version));
node.Add(RandomSeedName, RandomSeed);
node.Add(InitialModuleName, InitialModule.ExportYAML(container));
node.Add(ShapeModuleName, ShapeModule.ExportYAML(container));
node.Add(EmissionModuleName, EmissionModule.ExportYAML(container));
node.Add(SizeModuleName, SizeModule.ExportYAML(container));
node.Add(RotationModuleName, RotationModule.ExportYAML(container));
node.Add(ColorModuleName, ColorModule.ExportYAML(container));
node.Add(UVModuleName, UVModule.ExportYAML(container));
node.Add(VelocityModuleName, VelocityModule.ExportYAML(container));
node.Add(InheritVelocityModuleName, GetInheritVelocityModule(container.Version).ExportYAML(container));
node.Add(ForceModuleName, ForceModule.ExportYAML(container));
node.Add(ExternalForcesModuleName, GetExternalForcesModule(container.Version).ExportYAML(container));
node.Add(ClampVelocityModuleName, ClampVelocityModule.ExportYAML(container));
node.Add(NoiseModuleName, GetNoiseModule(container.Version).ExportYAML(container));
node.Add(SizeBySpeedModuleName, SizeBySpeedModule.ExportYAML(container));
node.Add(RotationBySpeedModuleName, RotationBySpeedModule.ExportYAML(container));
node.Add(ColorBySpeedModuleName, ColorBySpeedModule.ExportYAML(container));
node.Add(CollisionModuleName, CollisionModule.ExportYAML(container));
node.Add(TriggerModuleName, GetTriggerModule(container.Version).ExportYAML(container));
node.Add(SubModuleName, SubModule.ExportYAML(container));
node.Add(LightsModuleName, GetLightsModule(container.Version).ExportYAML(container));
node.Add(TrailModuleName, GetTrailModule(container.Version).ExportYAML(container));
node.Add(CustomDataModuleName, GetCustomDataModule(container.Version).ExportYAML(container));
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.Version));
node.Add("lengthInSec", LengthInSec);
node.Add("simulationSpeed", SimulationSpeed);
node.Add("stopAction", StopAction);
node.Add("looping", Looping);
node.Add("prewarm", Prewarm);
node.Add("playOnAwake", PlayOnAwake);
node.Add("useUnscaledTime", UseUnscaledTime);
node.Add("autoRandomSeed", GetAutoRandomSeed(container.Version));
node.Add("useRigidbodyForVelocity", GetUseRigidbodyForVelocity(container.Version));
node.Add("startDelay", GetStartDelay(container.Version).ExportYAML(container));
node.Add("moveWithTransform", (int)MoveWithTransform);
node.Add("moveWithCustomTransform", MoveWithCustomTransform.ExportYAML(container));
node.Add("scalingMode", (int)GetScalingMode(container.Version));
node.Add("randomSeed", RandomSeed);
node.Add("InitialModule", InitialModule.ExportYAML(container));
node.Add("ShapeModule", ShapeModule.ExportYAML(container));
node.Add("EmissionModule", EmissionModule.ExportYAML(container));
node.Add("SizeModule", SizeModule.ExportYAML(container));
node.Add("RotationModule", RotationModule.ExportYAML(container));
node.Add("ColorModule", ColorModule.ExportYAML(container));
node.Add("UVModule", UVModule.ExportYAML(container));
node.Add("VelocityModule", VelocityModule.ExportYAML(container));
node.Add("InheritVelocityModule", GetInheritVelocityModule(container.Version).ExportYAML(container));
node.Add("ForceModule", ForceModule.ExportYAML(container));
node.Add("ExternalForcesModule", GetExternalForcesModule(container.Version).ExportYAML(container));
node.Add("ClampVelocityModule", ClampVelocityModule.ExportYAML(container));
node.Add("NoiseModule", GetNoiseModule(container.Version).ExportYAML(container));
node.Add("SizeBySpeedModule", SizeBySpeedModule.ExportYAML(container));
node.Add("RotationBySpeedModule", RotationBySpeedModule.ExportYAML(container));
node.Add("ColorBySpeedModule", ColorBySpeedModule.ExportYAML(container));
node.Add("CollisionModule", CollisionModule.ExportYAML(container));
node.Add("TriggerModule", GetTriggerModule(container.Version).ExportYAML(container));
node.Add("SubModule", SubModule.ExportYAML(container));
node.Add("LightsModule", GetLightsModule(container.Version).ExportYAML(container));
node.Add("TrailModule", GetTrailModule(container.Version).ExportYAML(container));
node.Add("CustomDataModule", GetCustomDataModule(container.Version).ExportYAML(container));
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IAssetsExporter exporter)
{
#warning TODO: values acording to read version (current 2017.3.0f3)
YAMLMappingNode node = base.ExportYAMLRoot(exporter);
node.AddSerializedVersion(GetSerializedVersion(exporter.Version));
node.Add("lengthInSec", LengthInSec);
node.Add("simulationSpeed", SimulationSpeed);
node.Add("stopAction", StopAction);
node.Add("looping", Looping);
node.Add("prewarm", Prewarm);
node.Add("playOnAwake", PlayOnAwake);
node.Add("useUnscaledTime", UseUnscaledTime);
node.Add("autoRandomSeed", AutoRandomSeed);
node.Add("useRigidbodyForVelocity", UseRigidbodyForVelocity);
node.Add("startDelay", StartDelay.ExportYAML(exporter));
node.Add("moveWithTransform", MoveWithTransform);
node.Add("moveWithCustomTransform", MoveWithCustomTransform.ExportYAML(exporter));
node.Add("scalingMode", ScalingMode);
node.Add("randomSeed", RandomSeed);
node.Add("InitialModule", InitialModule.ExportYAML(exporter));
node.Add("ShapeModule", ShapeModule.ExportYAML(exporter));
node.Add("EmissionModule", EmissionModule.ExportYAML(exporter));
node.Add("SizeModule", SizeModule.ExportYAML(exporter));
node.Add("RotationModule", RotationModule.ExportYAML(exporter));
node.Add("ColorModule", ColorModule.ExportYAML(exporter));
node.Add("UVModule", UVModule.ExportYAML(exporter));
node.Add("VelocityModule", VelocityModule.ExportYAML(exporter));
node.Add("InheritVelocityModule", InheritVelocityModule.ExportYAML(exporter));
node.Add("ForceModule", ForceModule.ExportYAML(exporter));
node.Add("ExternalForcesModule", ExternalForcesModule.ExportYAML(exporter));
node.Add("ClampVelocityModule", ClampVelocityModule.ExportYAML(exporter));
node.Add("NoiseModule", NoiseModule.ExportYAML(exporter));
node.Add("SizeBySpeedModule", SizeBySpeedModule.ExportYAML(exporter));
node.Add("RotationBySpeedModule", RotationBySpeedModule.ExportYAML(exporter));
node.Add("ColorBySpeedModule", ColorBySpeedModule.ExportYAML(exporter));
node.Add("CollisionModule", CollisionModule.ExportYAML(exporter));
node.Add("TriggerModule", TriggerModule.ExportYAML(exporter));
node.Add("SubModule", SubModule.ExportYAML(exporter));
node.Add("LightsModule", LightsModule.ExportYAML(exporter));
node.Add("TrailModule", TrailModule.ExportYAML(exporter));
node.Add("CustomDataModule", CustomDataModule.ExportYAML(exporter));
return(node);
}
private IEnumerator HeldDownCoroutine(TacticFactory tacticFactory)
{
globalOrderCircle.SetActive(true);
bool alreadyPlaying = false;
Color finalColor = new Color(startingParticlesColor.r, startingParticlesColor.g, startingParticlesColor.b, 0f);
float timer = 0f;
ShapeModule shapeModule = globalOrderParticles.shape;
MainModule mainModule = globalOrderParticles.main;
mainModule.startColor = startingParticlesColor;
while (timer < heldDownTime)
{
if (timer > heldDownTime / 3f)
{
if (!alreadyPlaying)
{
globalOrderParticles.Play();
alreadyPlaying = true;
}
shapeModule.radius = Mathf.Lerp(1f, globalOrderParticlesFinalRadius, (timer - (heldDownTime / 3f)) / (heldDownTime - (heldDownTime / 3f)));
mainModule.startSize = Mathf.Lerp(2f, globalOrderParticlesFinalRadius / 2f, (timer - (heldDownTime / 3f)) / (heldDownTime - (heldDownTime / 3f)));
}
if (timer > heldDownTime / 1.5f)
{
mainModule.startColor = Color.Lerp(startingParticlesColor, finalColor, (timer - (heldDownTime / 1.5f)) / (heldDownTime - (heldDownTime / 1.5f)));
}
timer += Time.deltaTime;
yield return(null);
}
AssignGlobalOrder(tacticFactory);
ResetGlobalOrderParticles();
}
public override void Read(AssetReader reader)
{
base.Read(reader);
LengthInSec = reader.ReadSingle();
if (IsStartDelayFirst(reader.Version))
{
if (HasStartDelaySingle(reader.Version))
{
StartDelaySingle = reader.ReadSingle();
}
else
{
StartDelay.Read(reader);
}
}
SimulationSpeed = reader.ReadSingle();
if (HasStopAction(reader.Version))
{
StopAction = (ParticleSystemStopAction)reader.ReadInt32();
}
if (IsRandomSeedFirst(reader.Version))
{
RandomSeed = unchecked ((int)reader.ReadUInt32());
}
if (HasCullingMode(reader.Version))
{
CullingMode = (ParticleSystemCullingMode)reader.ReadInt32();
RingBufferMode = (ParticleSystemRingBufferMode)reader.ReadInt32();
RingBufferLoopRange.Read(reader);
}
Looping = reader.ReadBoolean();
Prewarm = reader.ReadBoolean();
PlayOnAwake = reader.ReadBoolean();
if (HasUseUnscaledTime(reader.Version))
{
UseUnscaledTime = reader.ReadBoolean();
}
if (IsMoveWithTransformBool(reader.Version))
{
MoveWithTransform = reader.ReadBoolean() ? ParticleSystemSimulationSpace.Local : ParticleSystemSimulationSpace.World;
}
if (HasAutoRandomSeed(reader.Version))
{
AutoRandomSeed = reader.ReadBoolean();
}
if (HasUseRigidbodyForVelocity(reader.Version))
{
UseRigidbodyForVelocity = reader.ReadBoolean();
}
if (IsAlign(reader.Version))
{
reader.AlignStream();
}
if (!IsStartDelayFirst(reader.Version))
{
StartDelay.Read(reader);
reader.AlignStream();
}
if (!IsMoveWithTransformBool(reader.Version))
{
MoveWithTransform = (ParticleSystemSimulationSpace)reader.ReadInt32();
reader.AlignStream();
}
if (HasMoveWithCustomTransform(reader.Version))
{
MoveWithCustomTransform.Read(reader);
}
if (HasScalingMode(reader.Version))
{
ScalingMode = (ParticleSystemScalingMode)reader.ReadInt32();
}
if (!IsRandomSeedFirst(reader.Version))
{
RandomSeed = reader.ReadInt32();
}
InitialModule.Read(reader);
ShapeModule.Read(reader);
EmissionModule.Read(reader);
SizeModule.Read(reader);
RotationModule.Read(reader);
ColorModule.Read(reader);
UVModule.Read(reader);
VelocityModule.Read(reader);
if (HasInheritVelocityModule(reader.Version))
{
InheritVelocityModule.Read(reader);
}
ForceModule.Read(reader);
if (HasExternalForcesModule(reader.Version))
{
ExternalForcesModule.Read(reader);
}
ClampVelocityModule.Read(reader);
if (HasNoiseModule(reader.Version))
{
NoiseModule.Read(reader);
}
SizeBySpeedModule.Read(reader);
RotationBySpeedModule.Read(reader);
ColorBySpeedModule.Read(reader);
CollisionModule.Read(reader);
if (HasTriggerModule(reader.Version))
{
TriggerModule.Read(reader);
}
SubModule.Read(reader);
if (HasLightsModule(reader.Version))
{
LightsModule.Read(reader);
TrailModule.Read(reader);
}
if (HasCustomDataModule(reader.Version))
{
CustomDataModule.Read(reader);
}
}
private IEnumerator DoInitialize()
{
eventData = (SectionEventData)GameSection.GetEventData();
FieldMapTable.PortalTableData portal = Singleton <FieldMapTable> .I.GetPortalData(MonoBehaviourSingleton <FieldManager> .I.currentPortalID);
FieldMapTable.FieldMapTableData mapA = Singleton <FieldMapTable> .I.GetFieldMapData(portal.srcMapID);
FieldMapTable.FieldMapTableData mapB = Singleton <FieldMapTable> .I.GetFieldMapData(portal.dstMapID);
fromRegionID = mapA.regionId;
toRegionID = mapB.regionId;
LoadingQueue loadQueue = new LoadingQueue(this);
LoadObject loadedWorldMap = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "WorldMap", false);
LoadObject loadedRegionSpotRoot = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "RegionSpotRoot", false);
LoadObject loadedRegionSpot = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "RegionSpot", false);
LoadObject loadedPlayerMarker = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "PlayerMarker", false);
LoadObject loadedMapGlowEffectA = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "MapGlowEffectA", false);
LoadObject loadedMapGlowEffectB = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "MapGlowEffectB", false);
LoadObject loadedTelop = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "TelopOpenRegion", false);
loadQueue.CacheSE(SE_ID_LOGO, null);
loadQueue.CacheSE(SE_ID_SMOKE, null);
uint[] openedRegionids = MonoBehaviourSingleton <WorldMapManager> .I.GetOpenRegionIdListInWorldMap();
if (openedRegionids.Length == 0)
{
openedRegionids = new uint[1];
}
LoadObject[] regionAreaLOs = new LoadObject[openedRegionids.Length];
string newRegionIcon = ResourceName.GetRegionIcon(0);
string passedRegionIcon = ResourceName.GetRegionIcon(1);
int lastIndex = openedRegionids.Length - 1;
openedRegionInfo = new OpendRegionInfo[openedRegionids.Length];
for (int j = 0; j < openedRegionids.Length; j++)
{
RegionTable.Data data = Singleton <RegionTable> .I.GetData(openedRegionids[j]);
if (!data.hasParentRegion())
{
string iconName = passedRegionIcon;
if (lastIndex == j)
{
iconName = newRegionIcon;
}
LoadObject loadedObj = loadQueue.Load(RESOURCE_CATEGORY.REGION_ICON, iconName, false);
openedRegionInfo[j] = new OpendRegionInfo(data, loadedObj);
if (j != 0)
{
regionAreaLOs[j] = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "WorldMapPart" + openedRegionids[j].ToString("D3"), false);
}
}
}
LoadObject loadedMaterial = null;
if (!eventData.IsOnlyCameraMoveEvent())
{
loadedMaterial = loadQueue.Load(RESOURCE_CATEGORY.WORLDMAP, "WorldMapPartGlow" + toRegionID.ToString("D3"), false);
}
if (loadQueue.IsLoading())
{
yield return((object)loadQueue.Wait());
}
worldMapUIRoot = ResourceUtility.Realizes(loadedWorldMap.loadedObject, MonoBehaviourSingleton <AppMain> .I._transform, -1).get_gameObject();
worldMapCamera = worldMapUIRoot.get_transform().Find("Camera").GetComponent <WorldMapCameraController>();
worldMapCamera.isInteractive = false;
worldMapObject = worldMapUIRoot.get_transform().FindChild("Map");
spots = new SpotManager(loadedRegionSpotRoot.loadedObject as GameObject, loadedRegionSpot.loadedObject as GameObject, worldMapCamera._camera);
spots.CreateSpotRoot();
GameObject bg = spots.spotRootTransform.Find("BG").get_gameObject();
bg.get_gameObject().SetActive(true);
bgEventListener = UIEventListener.Get(bg);
spots.spotRootTransform.Find("TaptoSkip").get_gameObject().SetActive(true);
mapGlowEffectA = ResourceUtility.Realizes(loadedMapGlowEffectA.loadedObject, worldMapObject, -1);
mapGlowEffectA.get_gameObject().SetActive(false);
mapGlowEffectParticleA = mapGlowEffectA.GetComponent <ParticleSystem>();
mapGlowEffectB = ResourceUtility.Realizes(loadedMapGlowEffectB.loadedObject, worldMapObject, -1);
mapGlowEffectB.get_gameObject().SetActive(false);
mapGlowEffectParticleB = mapGlowEffectB.GetComponent <ParticleSystem>();
playerMarker = ResourceUtility.Realizes(loadedPlayerMarker.loadedObject, base._transform, -1);
playerMarker.get_gameObject().SetActive(false);
if (loadedMaterial != null)
{
glowMaterial = (loadedMaterial.loadedObject as Material);
}
regionAreas = (Transform[])new Transform[regionAreaLOs.Length];
for (int i = 0; i < regionAreaLOs.Length; i++)
{
LoadObject areaLO = regionAreaLOs[i];
if (areaLO != null && null != areaLO.loadedObject)
{
Transform regionArea = ResourceUtility.Realizes(areaLO.loadedObject, worldMapObject, -1);
if (i == toRegionID)
{
if (eventData.IsOnlyCameraMoveEvent())
{
regionArea.get_gameObject().SetActive(true);
}
else
{
regionArea.get_gameObject().SetActive(false);
}
mapGlowEffectA.SetParent(regionArea);
mapGlowEffectA.set_localPosition(new Vector3(0f, 0f, 0f));
mapGlowEffectB.SetParent(regionArea);
mapGlowEffectB.set_localPosition(new Vector3(0f, 0f, 0f));
ShapeModule module = mapGlowEffectParticleB.get_shape();
MeshFilter meshFilter = regionArea.GetComponent <MeshFilter>();
module.set_mesh(meshFilter.get_sharedMesh());
glowRegionTop = ResourceUtility.Realizes(areaLO.loadedObject, worldMapObject, -1);
glowRegionTop.get_gameObject().SetActive(false);
glowRegionTop.set_localPosition(glowRegionTop.get_localPosition() + new Vector3(0f, 0f, 0.001f));
glowRegionTop.set_localScale(new Vector3(1.1f, 1.1f, 1.1f));
glowRegionTop.GetComponent <Renderer>().set_material(glowMaterial);
}
else
{
regionArea.get_gameObject().SetActive(true);
}
regionAreas[i] = regionArea;
}
}
telop = ResourceUtility.Realizes(loadedTelop.loadedObject, spots.spotRootTransform, -1);
Transform closeBtn = Utility.Find(spots.spotRootTransform, "CLOSE_BTN");
if (null != closeBtn)
{
closeBtn.get_gameObject().SetActive(false);
}
if (MonoBehaviourSingleton <GameSceneManager> .I.GetCurrentSceneName() == "InGameScene")
{
MonoBehaviourSingleton <ScreenOrientationManager> .I.OnScreenRotate += InitMapSprite;
}
base.Initialize();
}
void Start()
{
_emisModule = _fireParticles.emission;
_mainModule = _fireParticles.main;
_shapeModule = _fireParticles.shape;
}
// Start is called before the first frame update
void Start()
{
collisionEvents = new List <ParticleCollisionEvent>();
partySys = GetComponent <ParticleSystem>();
shape = partySys.shape;
}
public override void Read(AssetStream stream)
{
base.Read(stream);
LengthInSec = stream.ReadSingle();
if (IsStartDelayFirst(stream.Version))
{
if (IsReadStartDelaySingle(stream.Version))
{
StartDelaySingle = stream.ReadSingle();
}
else
{
StartDelay.Read(stream);
}
}
SimulationSpeed = stream.ReadSingle();
if (IsReadStopAction(stream.Version))
{
StopAction = stream.ReadInt32();
}
if (IsRandomSeedFirst(stream.Version))
{
RandomSeed = unchecked ((int)stream.ReadUInt32());
}
Looping = stream.ReadBoolean();
Prewarm = stream.ReadBoolean();
PlayOnAwake = stream.ReadBoolean();
if (IsReadUseUnscaledTime(stream.Version))
{
UseUnscaledTime = stream.ReadBoolean();
}
if (IsMoveWithTransformBool(stream.Version))
{
MoveWithTransform = stream.ReadBoolean() ? 1 : 0;
}
if (IsReadAutoRandomSeed(stream.Version))
{
AutoRandomSeed = stream.ReadBoolean();
}
if (IsReadUseRigidbodyForVelocity(stream.Version))
{
UseRigidbodyForVelocity = stream.ReadBoolean();
}
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (!IsStartDelayFirst(stream.Version))
{
StartDelay.Read(stream);
stream.AlignStream(AlignType.Align4);
}
if (!IsMoveWithTransformBool(stream.Version))
{
MoveWithTransform = stream.ReadInt32();
stream.AlignStream(AlignType.Align4);
}
if (IsReadMoveWithCustomTransform(stream.Version))
{
MoveWithCustomTransform.Read(stream);
}
if (IsReadScalingMode(stream.Version))
{
ScalingMode = stream.ReadInt32();
}
if (!IsRandomSeedFirst(stream.Version))
{
RandomSeed = stream.ReadInt32();
}
InitialModule.Read(stream);
ShapeModule.Read(stream);
EmissionModule.Read(stream);
SizeModule.Read(stream);
RotationModule.Read(stream);
ColorModule.Read(stream);
UVModule.Read(stream);
VelocityModule.Read(stream);
if (IsReadInheritVelocityModule(stream.Version))
{
InheritVelocityModule.Read(stream);
}
ForceModule.Read(stream);
if (IsReadExternalForcesModule(stream.Version))
{
ExternalForcesModule.Read(stream);
}
ClampVelocityModule.Read(stream);
if (IsReadNoiseModule(stream.Version))
{
NoiseModule.Read(stream);
}
SizeBySpeedModule.Read(stream);
RotationBySpeedModule.Read(stream);
ColorBySpeedModule.Read(stream);
CollisionModule.Read(stream);
if (IsReadTriggerModule(stream.Version))
{
TriggerModule.Read(stream);
}
SubModule.Read(stream);
if (IsReadLightsModule(stream.Version))
{
LightsModule.Read(stream);
TrailModule.Read(stream);
}
if (IsReadCustomDataModule(stream.Version))
{
CustomDataModule.Read(stream);
}
}
