void PlayEffect(int effect_idx, float delay = 0) { if(m_current_active_effect != null) { #if !UNITY_3_5 m_current_active_effect.gameObject.SetActive(false); #else m_current_active_effect.gameObject.SetActiveRecursively(false); #endif } m_current_active_effect = m_effects[effect_idx].m_effect_sync; #if !UNITY_3_5 m_current_active_effect.gameObject.SetActive(true); #else m_current_active_effect.gameObject.SetActiveRecursively(true); #endif if(m_force_effects_to_origin) { m_current_active_effect.transform.localPosition = m_effects[effect_idx].m_position_offset; } m_current_active_effect.PlayAnimation(delay); }
public ParticleEffectInstanceManager(EffectManager effect_manager, Mesh character_mesh, bool letter_flipped, ParticleEffectSetup effect_setup, AnimationProgressionVariables progression_vars, AnimatePerOptions animate_per, ParticleEmitter particle_emitter = null, ParticleSystem particle_system = null) { m_particle_emitter = particle_emitter; m_particle_system = particle_system; m_letter_mesh = character_mesh; m_letter_flipped = letter_flipped; m_follow_mesh = effect_setup.m_follow_mesh; m_duration = effect_setup.m_duration.GetValue(progression_vars, animate_per); m_delay = effect_setup.m_delay.GetValue(progression_vars, animate_per); m_position_offset = effect_setup.m_position_offset.GetValue(progression_vars, animate_per); m_rotation_offset = Quaternion.Euler(effect_setup.m_rotation_offset.GetValue(progression_vars, animate_per)); m_rotate_with_letter = effect_setup.m_rotate_relative_to_letter; m_effect_manager_handle = effect_manager; m_active = false; if (m_particle_emitter != null) { m_transform = m_particle_emitter.transform; m_particle_emitter.emit = true; m_particle_emitter.enabled = false; } else if (m_particle_system != null) { m_transform = m_particle_system.transform; m_particle_system.playOnAwake = false; m_particle_system.Play(); #if !UNITY_3_5 && UNITY_EDITOR p_system_timer = 0; #endif } }
public virtual void Init() { m_EffectManager = new EffectManager(); m_EffectManager.LoadEffect(m_Data.EffectPath); m_EffectManager.RegisterCondition("CanActiveEffect", CanActiveEffect); m_EffectManager.RegisterExcuteMethod("ExcuteEffect", ExcuteEffect); }
void Awake() { gameManager = GameObject.Find("GameManager").GetComponent<GameManager>(); soundManager = GameObject.Find("SoundManager").GetComponent<SoundManager>(); effectManager = GameObject.Find("EffectManager").GetComponent<EffectManager>(); common = GameObject.Find("Common").GetComponent<Common>(); }
public ParticleEffectInstanceManager(ParticleEmitter p_emitter, EffectManager effect_manager, Mesh character_mesh, float delay, float duration, Vector3 position_offset, bool follow_mesh) { m_emitter = p_emitter; m_duration = duration; m_letter_mesh = character_mesh; m_delay = delay; m_position_offset = position_offset; m_follow_mesh = follow_mesh; m_effect_manager_handle = effect_manager; m_transform = m_emitter.transform; // Enable emitter m_emitter.emit = true; m_emitter.enabled = false; // Position effect according to offset m_letter_mesh.RecalculateNormals(); if(!m_letter_mesh.normals[0].Equals(Vector3.zero)) { Quaternion rotation = Quaternion.LookRotation(m_letter_mesh.normals[0], m_letter_mesh.vertices[1].Equals(m_letter_mesh.vertices[2]) ? Vector3.forward : m_letter_mesh.vertices[1] - m_letter_mesh.vertices[2]); m_transform.position = m_effect_manager_handle.m_transform.position + (rotation * m_position_offset) + (m_letter_mesh.vertices[0] + m_letter_mesh.vertices[1] + m_letter_mesh.vertices[2] + m_letter_mesh.vertices[3]) / 4; m_transform.rotation = rotation; } else { m_transform.position = m_effect_manager_handle.m_transform.position + m_position_offset + (m_letter_mesh.vertices[0] + m_letter_mesh.vertices[1] + m_letter_mesh.vertices[2] + m_letter_mesh.vertices[3]) / 4; } }
void Awake() { soundManager = GameObject.Find("SoundManager").GetComponent<SoundManager>(); effectManager = GameObject.Find("EffectManager").GetComponent<EffectManager>(); selecter = GameObject.Find("selecter").GetComponent<RectTransform>(); common = GameObject.Find("Common").GetComponent<Common>(); }
void OnGUI() { m_effect_index = GUI.SelectionGrid(new Rect((Screen.width/2f) - (Screen.width/4f), 2f * (Screen.height/3f), Screen.width/2f, 7 * (Screen.height/24f)), m_effect_index, m_effect_names, 3); m_sync_toggle = GUI.Toggle(new Rect(5 * (Screen.width/6f), 11f * (Screen.height/12f), Screen.width/7f, Screen.height/13f), m_sync_toggle, "Sync?"); if(GUI.changed) { // Effect change requested // Stop/Hide current effect #if !UNITY_3_5 m_current_active_effect.gameObject.SetActive(false); #else m_current_active_effect.gameObject.SetActiveRecursively(false); #endif m_current_active_effect = m_sync_toggle ? m_effects[m_effect_index].m_effect_sync : m_effects[m_effect_index].m_effect_random; #if !UNITY_3_5 m_current_active_effect.gameObject.SetActive(true); #else m_current_active_effect.gameObject.SetActiveRecursively(true); #endif m_current_active_effect.transform.localPosition = m_local_position; m_current_active_effect.PlayAnimation(); } #if !UNITY_EDITOR || USE_EDITOR_GUI_NAVIGATION if(GUI.Button(new Rect((Screen.width/28f), 10.5f * (Screen.height/12f), Screen.width/7f, (Screen.height/13f)), "Back")) { PlayerPrefs.SetInt("TextFx_Skip_Intro_Anim", 1); Application.LoadLevel("TitleScene"); } #endif }
public SimpleButton(string title, float width, float height, SimpleButtonColor color, bool isPressTap,string fontName) { _isPressTap = isPressTap; this.effectManager = Core.topEffectManager; _color = color; AddChild(button = new FSliceButton(width,height,_color.path,_color.path)); //button.SetPosition(0.25f,0.33f);//pixel perfect? AddChild(mainLabel = new DualLabel(fontName,title,Color.white,TOColors.TEXT_SHADOW)); mainLabel.y = 2.5f; if(_isPressTap) { button.SignalPress += (b) => DoTap(); } else { button.SignalRelease += (b) => DoTap(); } _overHighlight = new FSliceSprite("UI/ButtonHighlight",width,height,12,12,12,12); _overHighlight.alpha = 0.45f; ListenForUpdate(HandleUpdate); UpdateEnabled(); }
void Awake() { Instance = this; _fisheye = playerCamera.gameObject.GetComponent<Fisheye>(); _colorSaturation = playerCamera.gameObject.GetComponent<ColorCorrectionCurves>(); _blur = playerCamera.gameObject.GetComponent<BlurOptimized>(); }
public MonoEnvironment() { OnDispose = () => { }; EffectManager = new EffectManager(); SkillManager = new SkillList(); PropertyManager = new PropertyManager(); PluginEnvironment = new PluginEnvironment(); Attributes = new Attributes(); }
public static EffectManager Instance() { if (mEffectMgr == null) { mEffectMgr = new EffectManager(); } return mEffectMgr; }
public static EffectManager Instance() { if (!instance) { container = new GameObject(); container.name = "EffectManager"; instance = container.AddComponent(typeof(EffectManager)) as EffectManager; } return instance; }
// Use this for initialization void Start () { Instance = this; if (EffectsOriginal == null) return; for(int i = 0; i < EffectsOriginal.Length; i++) { if(EffectsOriginal[i] != null) Effects.Add(EffectsOriginal[i].name, EffectsOriginal[i]); } }
private void _SetInstance() { if (_Instance != null) { Debug.Log("cannot instantiate"); Destroy(this.gameObject); return; } _Instance = this; //DontDestroyOnLoad(this); }
public override void LoadContent() { spriteBatch = new SpriteBatch(GraphicsDevice); #region Effect の初期化 effectManager = new EffectManager(GraphicsDevice, Content); normalMapEffect = effectManager.Load<FluidSurfaceNormalMapEffect>(); normalMapEffect.SampleOffset = new Vector2(1.0f / (float) TextureSize, 1.0f / (float) TextureSize); #endregion #region 内部で使用する RenderTarget の初期化 backBufferManager = new BackBufferManager(GraphicsDevice); prevWaveMapBackBuffer = backBufferManager.Load("FluidSurfacePrevWaveMap"); prevWaveMapBackBuffer.Width = TextureSize; prevWaveMapBackBuffer.Height = TextureSize; prevWaveMapBackBuffer.MipMap = true; prevWaveMapBackBuffer.SurfaceFormat = SurfaceFormat.Vector2; prevWaveMapBackBuffer.DepthFormat = DepthFormat.None; prevWaveMapBackBuffer.MultiSampleCount = 0; prevWaveMapBackBuffer.Enabled = true; waveMapBackBuffer = backBufferManager.Load("FluidSurfaceWaveMap"); waveMapBackBuffer.Width = TextureSize; waveMapBackBuffer.Height = TextureSize; waveMapBackBuffer.MipMap = true; waveMapBackBuffer.SurfaceFormat = SurfaceFormat.Vector2; waveMapBackBuffer.DepthFormat = DepthFormat.None; waveMapBackBuffer.MultiSampleCount = 0; waveMapBackBuffer.Enabled = true; normalMapBackBuffer = backBufferManager.Load("FluidSurfaceNormalMap"); normalMapBackBuffer.Width = TextureSize; normalMapBackBuffer.Height = TextureSize; normalMapBackBuffer.MipMap = true; normalMapBackBuffer.SurfaceFormat = SurfaceFormat.Vector2; normalMapBackBuffer.DepthFormat = DepthFormat.None; normalMapBackBuffer.MultiSampleCount = 0; normalMapBackBuffer.Enabled = true; prevWaveMapBackBuffer.Begin(); { GraphicsDevice.Clear(Color.Black); } prevWaveMapBackBuffer.End(); #endregion base.LoadContent(); }
void Awake() { if (instance == null) { instance = this; } else { Debug.LogError("Duplicate EffectManager"); } DontDestroyOnLoad (this); }
public UIItemController(UIItemData data) { m_Data = data; m_GameManager = TDCGameManager.GetInstance(); m_Inventory = UIInventory.GetInstance(); m_EffectManager = new EffectManager(); m_EffectManager.LoadEffect(m_Data.EffectPath); m_EffectManager.RegisterCondition("CanActiveEffect", CanActiveEffect); m_EffectManager.RegisterExcuteMethod("PrintDebug", PrintDebug); m_EffectManager.RegisterExcuteMethod("CreateObjectEffect", CreateObjectEffect); m_EffectManager.RegisterExcuteMethod("DropItSelfEffect", DropItSelfEffect); m_EffectManager.RegisterExcuteMethod("AddValueEffect", AddValueEffect); m_EffectManager.RegisterExcuteMethod("SubtractValueEffect", SubtractValueEffect); }
private VertexColour start_colour, end_colour; // Used to store the colours for each frame #endregion Fields #region Constructors public LetterSetup(string character, int letter_idx, Mesh mesh, Vector3 base_offset, ref CustomCharacterInfo char_info, int line_num, int word_idx, EffectManager effect_manager) { m_character = character; m_mesh = mesh; m_base_offset = base_offset; m_effect_manager_handle = effect_manager; m_progression_variables = new AnimationProgressionVariables(letter_idx, word_idx, line_num); m_anim_state_vars = new AnimationStateVariables(); m_anim_state_vars.m_active_loop_cycles = new List<ActionLoopCycle>(); SetupLetterMesh(ref char_info); if (m_flipped) // flip UV coords in x axis. m_mesh.uv = new[] { mesh.uv[3], mesh.uv[2], mesh.uv[1], mesh.uv[0] }; }
void Awake() { effectManager = GameObject.Find("EffectManager").GetComponent<EffectManager>(); // 初始化键位与音频的对应关系 keyboards = new Dictionary<KeyCode,string>(); // 实例化空字典 keyboards[KeyCode.Q] = "010"; keyboards[KeyCode.Alpha2] = "015"; keyboards[KeyCode.W] = "020"; keyboards[KeyCode.Alpha3] = "025"; keyboards[KeyCode.E] = "030"; keyboards[KeyCode.R] = "040"; keyboards[KeyCode.Alpha5] = "045"; keyboards[KeyCode.T] = "050"; keyboards[KeyCode.Alpha6] = "055"; keyboards[KeyCode.Y] = "060"; keyboards[KeyCode.Alpha7] = "065"; keyboards[KeyCode.U] = "070"; keyboards[KeyCode.I] = "110"; keyboards[KeyCode.Alpha9] = "115"; keyboards[KeyCode.O] = "120"; keyboards[KeyCode.Alpha0] = "125"; keyboards[KeyCode.P] = "130"; keyboards[KeyCode.Z] = "140"; keyboards[KeyCode.S] = "145"; keyboards[KeyCode.X] = "150"; keyboards[KeyCode.D] = "155"; keyboards[KeyCode.C] = "160"; keyboards[KeyCode.F] = "165"; keyboards[KeyCode.V] = "170"; keyboards[KeyCode.B] = "210"; keyboards[KeyCode.H] = "215"; keyboards[KeyCode.N] = "220"; keyboards[KeyCode.J] = "225"; keyboards[KeyCode.M] = "230"; keyboards[KeyCode.Comma] = "240"; keyboards[KeyCode.K] = "245"; keyboards[KeyCode.Period] = "250"; keyboards[KeyCode.L] = "255"; keyboards[KeyCode.Slash] = "260"; keyboards[KeyCode.Semicolon] = "265"; keyboards[KeyCode.RightShift] = "270"; }
public Core() { instance = this; AddChild(pageContainer = new FContainer()); AddChild(topEffectManager = new EffectManager(true)); audioManager = new AudioManager(); FXPlayer.manager = audioManager.fxManager; MusicPlayer.manager = audioManager.musicManager; FXPlayer.Preload(); playerManager = new PlayerManager(); playerManager.Setup(); ShowPage(new PlayerSelectPage()); ListenForUpdate(Update); }
public Visualizer( D3D10Wrapper d3d, EffectManager effectManager ) { rootItemTree = new ItemTree( "root" ); this.d3d = d3d; streamState = new VisualizerStreamState(); textureVertexBuffer = new DynamicVertexBuffer( VertexPosition4fColor4f.SizeInBytes, 6 ); var stream = textureVertexBuffer.MapForWriteDiscard(); stream.Write( new Vector4f( 0, 0, 0, 1 ) ); stream.Write( new Vector4f( 0, 1, 0, 1 ) ); stream.Write( new Vector4f( 1, 0, 0, 1 ) ); stream.Write( new Vector4f( 1, 1, 0, 1 ) ); stream.Write( new Vector4f( 0, 1, 0, 1 ) ); stream.Write( new Vector4f( 0, 0, 0, 1 ) ); stream.Write( new Vector4f( 0, 1, 0, 1 ) ); stream.Write( new Vector4f( 0, 0, 0, 1 ) ); stream.Write( new Vector4f( 1, 0, 0, 1 ) ); stream.Write( new Vector4f( 1, 1, 0, 1 ) ); stream.Write( new Vector4f( 1, 1, 0, 1 ) ); stream.Write( new Vector4f( 1, 0, 0, 1 ) ); textureVertexBuffer.Unmap(); effect = effectManager[ "visualizer.fx" ]; opaquePass = effectManager[ "visualizer.fx", "renderOpaque", "p0" ]; opaquePassLayout = new InputLayout( d3d.Device, opaquePass.Description.Signature, VertexPosition4fColor4f.InputElements ); alphaPass = effectManager[ "visualizer.fx", "renderAlpha", "p0" ]; alphaPassLayout = new InputLayout( d3d.Device, alphaPass.Description.Signature, VertexPosition4fColor4f.InputElements ); additivePass = effectManager[ "visualizer.fx", "renderAdditive", "p0" ]; additivePassLayout = new InputLayout( d3d.Device, additivePass.Description.Signature, VertexPosition4fColor4f.InputElements ); opaqueTexturePass = effect.GetTechniqueByName( "renderTexOpaque" ).GetPassByName( "p0" ); opaqueTexturePassLayout = new InputLayout( d3d.Device, opaqueTexturePass.Description.Signature, VertexPosition4fTexture4f.InputElements ); alphaTexturePass = effect.GetTechniqueByName( "renderTexAlpha" ).GetPassByName( "p0" ); alphaTexturePassLayout = new InputLayout( d3d.Device, alphaTexturePass.Description.Signature, VertexPosition4fTexture4f.InputElements ); }
public override void Init() { base.Init(); m_EffectManager = new EffectManager(); m_ColliderLayerMask = 1 << 8 | 1 << 10 | 1 << 11 | 1 << 31; LoadFSM(); LoadEffect(); m_FSMManager.LoadFSM(m_Entity.GetFSMPath()); m_EffectManager.LoadEffect(m_Entity.GetEffectPath()); m_EffectPerTime = m_Entity.GetEffectPerTime(); m_TimeDelay = m_Entity.GetTimeDelay(); m_TimeEffect = m_Entity.GetTimeEffect(); m_EffectRadius = m_Entity.GetEffectRadius(); m_AttachTransform = this.transform; }
private void Start() { m_effect_names = new string[m_effects.Length]; var idx = 0; foreach (var effect_data in m_effects) { m_effect_names[idx] = effect_data.m_name; // Set effect to loop infinitely if (effect_data.m_effect_sync.GetAnimation(0).NumLoops > 0) effect_data.m_effect_sync.GetAnimation(0).GetLoop(0).m_number_of_loops = 0; if (effect_data.m_effect_random.GetAnimation(0).NumLoops > 0) effect_data.m_effect_random.GetAnimation(0).GetLoop(0).m_number_of_loops = 0; idx ++; } m_current_active_effect = m_effects[0].m_effect_sync; m_current_active_effect.ResetAnimation(); m_current_active_effect.transform.localPosition = m_local_position; m_current_active_effect.PlayAnimation(0.5f); }
public override void Cast(Player player) { if (!HasMana(player) || IsOnCooldown()) { return; } var friends = player.GetAlliesInRange(20f); friends.Add(player); // We want to heal self too foreach (var p in friends) { p.Heal(this.charges); } var effect = new EffectManager(); effect.PersistantEffect("Effect_HealingCircle", player.gameObject, 2f, Vector3.zero); this.charges = 0; // Debug.Log(this.damage); player.energy -= this.mana_cost; this.cooldown_time = 60 * 15; }
void UpdateFunction() { m_time_delta = Time.realtimeSinceStartup - m_old_time; if (m_previewing_anim && !m_paused) { if (font_manager == null) { font_manager = (EffectManager)target; } if (m_time_delta > 0 && !font_manager.UpdateAnimation(m_time_delta) && font_manager.ParticleEffectManagers.Count == 0) { m_previewing_anim = false; } if (font_manager.ParticleEffectManagers.Count > 0) { SceneView.RepaintAll(); } } if (m_set_text_delay > 0) { m_set_text_delay -= m_time_delta; if (m_set_text_delay <= 0) { m_set_text_delay = 0; font_manager.SetText(font_manager.m_text); } } m_old_time = Time.realtimeSinceStartup; }
private void IL_SwingZapFistMeleeHit(ILContext il) { ILCursor c = new ILCursor(il); bool ilFound = c.TryGotoNext( x => x.MatchStfld <FireProjectileInfo>(nameof(FireProjectileInfo.projectilePrefab))); if (ilFound) { c.Emit(OpCodes.Ldarg_0); c.EmitDelegate <Func <GameObject, SwingZapFist, GameObject> >((origProj, state) => { if (Scepter.instance.GetCount(state.outer.commonComponents.characterBody) < 1) { return(origProj); } var mTsf = state.outer.commonComponents.modelLocator?.modelTransform?.GetComponent <ChildLocator>()?.FindChild(state.swingEffectMuzzleString); EffectManager.SpawnEffect(LegacyResourcesAPI.Load <GameObject>("prefabs/effects/ImpactEffects/LightningStrikeImpact"), new EffectData { origin = mTsf?.position ?? state.outer.commonComponents.transform.position, scale = 1f }, true); return(projReplacer); }); } }
// Token: 0x06002D05 RID: 11525 RVA: 0x000BE0A8 File Offset: 0x000BC2A8 private void FireVoidPortal() { if (base.cachedModelTransform) { EntityState.Destroy(base.cachedModelTransform.gameObject); } if (NetworkServer.active) { Collider[] array = Physics.OverlapSphere(this.muzzleTransform.position, DeathState.deathExplosionRadius, LayerIndex.entityPrecise.mask); CharacterBody[] array2 = new CharacterBody[array.Length]; int count = 0; for (int i = 0; i < array.Length; i++) { CharacterBody characterBody = Util.HurtBoxColliderToBody(array[i]); if (characterBody && !(characterBody == base.characterBody) && Array.IndexOf <CharacterBody>(array2, characterBody, 0, count) == -1) { array2[count++] = characterBody; } } foreach (CharacterBody characterBody2 in array2) { if (characterBody2 && characterBody2.healthComponent) { characterBody2.healthComponent.Suicide(base.gameObject, base.gameObject, DamageType.VoidDeath); } } if (DeathState.deathExplosionEffect) { EffectManager.SpawnEffect(DeathState.deathExplosionEffect, new EffectData { origin = base.characterBody.corePosition, scale = DeathState.deathExplosionRadius }, true); } } }
public override void OnEnter() { base.OnEnter(); this.duration = SpinningSlashOld.baseDuration / this.attackSpeedStat; this.hasFired = false; Util.PlayScaledSound(EntityStates.Merc.GroundLight.finisherAttackSoundString, base.gameObject, 0.5f); base.PlayAnimation("FullBody, Override", "SpinSlash", "Whirlwind.playbackRate", this.duration); EffectManager.SimpleMuzzleFlash(Modules.Assets.spinningSlashFX, base.gameObject, "SwingCenter", true); HitBoxGroup hitBoxGroup = null; Transform modelTransform = base.GetModelTransform(); if (modelTransform) { hitBoxGroup = Array.Find <HitBoxGroup>(modelTransform.GetComponents <HitBoxGroup>(), (HitBoxGroup element) => element.groupName == "SpinSlash"); } this.attack = new OverlapAttack(); this.attack.attacker = base.gameObject; this.attack.inflictor = base.gameObject; this.attack.teamIndex = base.GetTeam(); this.attack.damageType = DamageType.Stun1s; this.attack.damage = SpinSlashOld.chargeDamageCoefficient * this.damageStat; this.attack.hitEffectPrefab = Modules.Assets.hitFX; this.attack.forceVector = Vector3.up * EntityStates.Toolbot.ToolbotDash.upwardForceMagnitude; this.attack.pushAwayForce = EntityStates.Toolbot.ToolbotDash.awayForceMagnitude; this.attack.hitBoxGroup = hitBoxGroup; this.attack.isCrit = base.RollCrit(); if (base.characterMotor) { base.SmallHop(base.characterMotor, 16f); } }
public override void OnInspectorGUI() { EffectManager effectManager = (EffectManager)target; DrawDefaultInspector(); EditorGUILayout.Space(); if (GUILayout.Button("Load Effects")) { effectManager.LoadEffects(); } EditorGUILayout.Space(); if (GUILayout.Button("Sort All Effects")) { effectManager.SortAllLists(); } EditorGUILayout.Space(); if (GUILayout.Button("Save Effects")) { effectManager.SaveEffects(); } }
public override void Cast(Player p) { if (!HasMana(p) || IsOnCooldown()) { return; } var enemy = p.GetEnemiesInRange(25f); foreach (var player in enemy) { Buff b = new Debuff_BlindingLight(); b.Add(player); } var effect = new EffectManager(); effect.PlayEffect("Effect_BlindingLight", p.transform.position); p.energy -= this.mana_cost; this.cooldown_time = 60 * 15; }
void OnUserEarnedReward_Revive() { // Success View Ads for Revive if (PlayerStatus.RemainReviveCount > 0) { Vibration.Vibrate(100); PlayerStatus.CurrentHP = PlayerStatus.MaxHP; PlayerStatus.RemainReviveCount -= 1; TopMostControl.Instance().StartGlobalLightEffect(Color.yellow, 2f, 0.2f); TopMostControl.Instance().GameOver(false); if (cameraController != null) { cameraController.CameraShake_Rot(3); } EffectManager.GetInstance().playEffect(playerController.GetPlayerRigidBody().transform.position, EFFECT.YELLOW_PILLAR, Vector2.zero); TopMostControl.Instance().StartBGM(SceneManager.GetActiveScene()); SoundManager.PlayOneShotSound(SoundContainer.Instance().SoundEffectsDic[GameStatics.sound_revive], SoundContainer.Instance().SoundEffectsDic[GameStatics.sound_revive].clip); Firebase.Analytics.FirebaseAnalytics.LogEvent(GameStatics.EVENT_REVIVE_ADS); } }
protected override void LoadContent() { base.LoadContent(); Art.Load(gameRef.Content); backgroundoverlay = new DrawableRectangle(GraphicsDevice, new Vector2(Game1.GAME_WIDTH, Game1.GAME_HEIGHT), Color.White, true).Texture; SpriteSheet explosionSs = new SpriteSheet(content.Load <Texture2D>("explosion"), 32, 32, gameRef.GraphicsDevice); Texture2D[] imgs = new Texture2D[] { explosionSs.GetSubImage(0, 0), explosionSs.GetSubImage(1, 0), explosionSs.GetSubImage(2, 0) }; var explode = new Animation(imgs); EffectManager.Initialize(content.Load <Texture2D>("particle"), explode); if (singlePlayer) { backgroundImage = content.Load <Texture2D>("Screen Images\\apocalypselondon"); } }
private void Awake() { instance = this; }
// Use this for initialization void Start() { //Singleton if (uniqueInstance == null) uniqueInstance = this; else Destroy(this.gameObject); }
void Start() { inst = this; }
// Use this for initialization void Awake() { I = this; }
public void Awake() { On.RoR2.SceneDirector.PopulateScene += (orig, self) => { orig(self); if (RoR2.SceneInfo.instance.sceneDef.stageOrder == 5) { SpawnShrineOfDio(self); } }; On.RoR2.ShrineHealingBehavior.FixedUpdate += (orig, self) => { if (RoR2.SceneInfo.instance.sceneDef.stageOrder != 5) { orig(self); return; } orig(self); if (clientCost == UNINITIALIZED) { int piCost = self.GetFieldValue <PurchaseInteraction>("purchaseInteraction").cost; if (piCost != clientCost) { clientCost = piCost; if (clientCost == BALANCED_MODE) { isBalancedMode = true; } else { isBalancedMode = false; } Type[] arr = ((IEnumerable <System.Type>) typeof(ChestRevealer).Assembly.GetTypes()).Where <System.Type>((Func <System.Type, bool>)(t => typeof(IInteractable).IsAssignableFrom(t))).ToArray <System.Type>(); for (int i = 0; i < arr.Length; i++) { foreach (UnityEngine.MonoBehaviour instances in InstanceTracker.FindInstancesEnumerable(arr[i])) { if (((IInteractable)instances).ShouldShowOnScanner()) { string item = ((IInteractable)instances).ToString().ToLower(); if (item.Contains("shrinehealing")) { UpdateShrineDisplay(instances.GetComponentInParent <ShrineHealingBehavior>()); } } ; } } } } }; On.RoR2.ShrineHealingBehavior.Awake += (orig, self) => { if (RoR2.SceneInfo.instance.sceneDef.stageOrder != 5) { orig(self); return; } orig(self); PurchaseInteraction pi = self.GetFieldValue <PurchaseInteraction>("purchaseInteraction"); pi.contextToken = "Offer to the Shrine of empowered Dio"; pi.displayNameToken = "Shrine of empowered Dio"; self.costMultiplierPerPurchase = 4f; pi.costType = CostTypeIndex.Money; //pi.cost = ResurrectionCost.Value * useCount; pi.cost = GetDifficultyScaledCost(ResurrectionCost); }; On.RoR2.ShrineHealingBehavior.AddShrineStack += (orig, self, interactor) => { if (RoR2.SceneInfo.instance.sceneDef.stageOrder != 5) { orig(self, interactor); return; } string resurrectionMessage = $"<color=#beeca1>{interactor.GetComponent<CharacterBody>().GetUserName()}</color> gained a <color=#beeca1>Dio</color>"; Chat.SendBroadcastChat(new Chat.SimpleChatMessage { baseToken = resurrectionMessage }); self.SetFieldValue("waitingForRefresh", true); self.SetFieldValue("refreshTimer", 2f); EffectManager.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/ShrineUseEffect"), new EffectData() { origin = self.transform.position, rotation = Quaternion.identity, scale = 1f, color = (Color32)Color.red }, true); // dio CharacterBody cb = interactor.GetComponent <CharacterBody>(); PurchaseInteraction pi = self.GetComponent <PurchaseInteraction>(); PurchaseInteraction.CreateItemTakenOrb(cb.corePosition, pi.gameObject, RoR2.RoR2Content.Items.ExtraLife.itemIndex); cb.inventory.RemoveItem(RoR2.RoR2Content.Items.ExtraLifeConsumed.itemIndex, 1); cb.inventory.GiveItem(RoR2.RoR2Content.Items.ExtraLife.itemIndex, 1); useCount++; }; On.RoR2.PurchaseInteraction.CanBeAffordedByInteractor += (orig, self, interactor) => { if (self.displayNameToken.Contains("Shrine of empowered Dio")) { if (interactor.GetComponent <CharacterBody>().inventory.GetItemCount(RoR2.RoR2Content.Items.ExtraLifeConsumed) > 0) { return(orig(self, interactor)); } return(false); } return(orig(self, interactor)); }; }
private void OnOnIngameUpdate(EventArgs args) { if (!MenuManager.IsEnable) { return; } Mode = OrbwalkingMode.Idle; var isTempest = BasicUnit as Tempest; if (isTempest != null && (Game.IsPaused || Game.IsChatOpen || !BasicUnit.IsAlive || !isTempest.IsValid)) { return; } if (OrderManager.CurrentOrder == OrderManager.Orders.DefaultCombo || (OrderManager.CurrentOrder == OrderManager.Orders.TempestCombo && (isTempest != null || !(BasicUnit is MainHero)))) { if (BasicUnit.OrbwalkingBehaviour is CanUseOrbwalking) { Mode = OrbwalkingMode.Combo; } } else if (OrderManager.CurrentOrder == OrderManager.Orders.AutoPushing) { Mode = OrbwalkingMode.Pushing; if (BasicUnit is MainHero) { return; } } else if (Mode == OrbwalkingMode.Idle) { EffectManager.Remove("attackTarget" + Owner.Handle); return; } // turning if (TurnEndTime > Game.RawGameTime) { return; } var target = GetTarget(); if ((target == null || !CanAttack(target) || UnitExtensions.IsAttackImmune(target)) && CanMove()) { if (BasicUnit.OrbwalkingBehaviour is CanUseOrbwalking) { BasicUnit.MoveAction(target); } return; } if (target != null && CanAttack(target)) { LastTarget = target; Attack(target); } if (BasicUnit.OrbwalkingBehaviour is CanUseOrbwalking) { if (LastTarget != null && LastTarget.IsValid && LastTarget.IsAlive) { EffectManager.DrawRange(LastTarget, "attackTarget" + Owner.Handle, 60, Color.Red); } else { EffectManager.Remove("attackTarget" + Owner.Handle); } } }
void Awake() { Instance = this; }
public void SetMeshState(int action_idx, float action_progress, LetterAnimation animation, AnimatePerOptions animate_per, EffectManager effect_manager) { if (action_idx >= 0 && action_idx < animation.NumActions) { SetupMesh(animation.GetAction(action_idx), action_idx > 0 ? animation.GetAction(action_idx - 1) : null, Mathf.Clamp(action_progress, 0, 1), m_progression_variables, animate_per, Mathf.Clamp(action_progress, 0, 1), effect_manager); } else { // action not found for this letter. Position letter in its default position if (mesh_verts == null || mesh_verts.Length == 0) { mesh_verts = new Vector3[4]; } for (int idx = 0; idx < 4; idx++) { mesh_verts[idx] = m_base_vertices[idx] + m_base_offset; } m_mesh.vertices = mesh_verts; m_mesh.colors = new Color[] { Color.white, Color.white, Color.white, Color.white }; } }
// Animates the letter mesh and return the current action index in use public LETTER_ANIMATION_STATE AnimateMesh(bool force_render, float timer, TextAnchor text_anchor, int lowest_action_progress, LetterAnimation animation, AnimatePerOptions animate_per, float delta_time, EffectManager effect_manager) { m_last_animate_per = animate_per; m_effect_manager_handle = effect_manager; if (animation.NumActions > 0 && m_anim_state_vars.m_action_index < animation.NumActions) { if (!m_anim_state_vars.m_active && !force_render) { return(LETTER_ANIMATION_STATE.STOPPED); } if (m_anim_state_vars.m_action_index != m_anim_state_vars.m_prev_action_index) { SetCurrentLetterAction(animation.GetAction(m_anim_state_vars.m_action_index), animate_per); m_anim_state_vars.m_started_action = false; } else if (m_current_letter_action == null) { SetCurrentLetterAction(animation.GetAction(m_anim_state_vars.m_action_index), animate_per); } m_anim_state_vars.m_prev_action_index = m_anim_state_vars.m_action_index; if (force_render) { SetupMesh(m_current_letter_action, m_anim_state_vars.m_action_index > 0 ? animation.GetAction(m_anim_state_vars.m_action_index - 1) : null, m_anim_state_vars.m_action_progress, m_progression_variables, animate_per, m_anim_state_vars.m_linear_progress, m_effect_manager_handle); } if (m_anim_state_vars.m_waiting_to_sync) { if (m_current_letter_action.m_action_type == ACTION_TYPE.BREAK) { if (!force_render && m_anim_state_vars.m_break_delay > 0) { m_anim_state_vars.m_break_delay -= delta_time; if (m_anim_state_vars.m_break_delay <= 0) { ContinueAction(timer, animation, animate_per); return(LETTER_ANIMATION_STATE.PLAYING); } } return(LETTER_ANIMATION_STATE.WAITING); } else if (lowest_action_progress < m_anim_state_vars.m_action_index_progress) { return(LETTER_ANIMATION_STATE.PLAYING); } else if (!force_render) { m_anim_state_vars.m_waiting_to_sync = false; // reset timer offset to compensate for the sync-up wait time m_anim_state_vars.m_timer_offset = timer; } } else if (!force_render && (m_current_letter_action.m_action_type == ACTION_TYPE.BREAK || (!m_anim_state_vars.m_reverse && m_current_letter_action.m_force_same_start_time && lowest_action_progress < m_anim_state_vars.m_action_index_progress))) { // Force letter to wait for rest of letters to be in sync m_anim_state_vars.m_waiting_to_sync = true; m_anim_state_vars.m_break_delay = Mathf.Max(m_current_letter_action.m_duration_progression.GetValue(m_progression_variables, animate_per), 0); return(LETTER_ANIMATION_STATE.PLAYING); } if (force_render) { return(m_anim_state_vars.m_active ? LETTER_ANIMATION_STATE.PLAYING : LETTER_ANIMATION_STATE.STOPPED); } m_anim_state_vars.m_action_progress = 0; m_anim_state_vars.m_linear_progress = 0; m_action_timer = timer - m_anim_state_vars.m_timer_offset; if ((m_anim_state_vars.m_reverse || m_action_timer > m_action_delay)) { m_anim_state_vars.m_linear_progress = (m_action_timer - (m_anim_state_vars.m_reverse ? 0 : m_action_delay)) / m_action_duration; if (m_anim_state_vars.m_reverse) { if (m_action_timer >= m_action_duration) { m_anim_state_vars.m_linear_progress = 0; } else { m_anim_state_vars.m_linear_progress = 1 - m_anim_state_vars.m_linear_progress; } } if (!m_anim_state_vars.m_started_action) { // Trigger any action onStart audio or particle effects TriggerAudioEffect(animate_per, PLAY_ITEM_EVENTS.ON_START); TriggerParticleEffects(animate_per, PLAY_ITEM_EVENTS.ON_START); m_anim_state_vars.m_started_action = true; } m_anim_state_vars.m_action_progress = EasingManager.GetEaseProgress(m_current_letter_action.m_ease_type, m_anim_state_vars.m_linear_progress); if ((!m_anim_state_vars.m_reverse && m_anim_state_vars.m_linear_progress >= 1) || (m_anim_state_vars.m_reverse && m_action_timer >= m_action_duration + m_action_delay)) { m_anim_state_vars.m_action_progress = m_anim_state_vars.m_reverse ? 0 : 1; m_anim_state_vars.m_linear_progress = m_anim_state_vars.m_reverse ? 0 : 1; if (!m_anim_state_vars.m_reverse && m_anim_state_vars.m_action_index != -1) { TriggerParticleEffects(animate_per, PLAY_ITEM_EVENTS.ON_FINISH); TriggerAudioEffect(animate_per, PLAY_ITEM_EVENTS.ON_FINISH); } int prev_action_idx = m_anim_state_vars.m_action_index; float prev_delay = m_action_delay; // Set next action index SetNextActionIndex(animation); if (m_anim_state_vars.m_active) { if (!m_anim_state_vars.m_reverse) { m_anim_state_vars.m_started_action = false; } if (!m_anim_state_vars.m_reverse && m_anim_state_vars.m_action_index_progress > m_anim_state_vars.m_action_index) { // Repeating the action again; check for unqiue random variable requests. animation.GetAction(m_anim_state_vars.m_action_index).SoftReset(animation.GetAction(prev_action_idx), m_progression_variables, animate_per, m_anim_state_vars.m_action_index == 0); } else if (m_anim_state_vars.m_reverse) { animation.GetAction(m_anim_state_vars.m_action_index).SoftResetStarts(animation.GetAction(prev_action_idx), m_progression_variables, animate_per); } // Add to the timer offset m_anim_state_vars.m_timer_offset += prev_delay + m_action_duration; if (prev_action_idx != m_anim_state_vars.m_action_index) { UpdateLoopList(animation); } else { SetCurrentLetterAction(animation.GetAction(m_anim_state_vars.m_action_index), animate_per); } } } } SetupMesh(m_current_letter_action, m_anim_state_vars.m_action_index > 0 ? animation.GetAction(m_anim_state_vars.m_action_index - 1) : null, m_anim_state_vars.m_action_progress, m_progression_variables, animate_per, m_anim_state_vars.m_linear_progress, m_effect_manager_handle); } else { // no actions found for this letter. Position letter in its default position if (mesh_verts == null || mesh_verts.Length == 0) { mesh_verts = new Vector3[4]; } for (int idx = 0; idx < 4; idx++) { mesh_verts[idx] = m_base_vertices[idx] + m_base_offset; } m_mesh.vertices = mesh_verts; m_anim_state_vars.m_active = false; } return(m_anim_state_vars.m_active ? LETTER_ANIMATION_STATE.PLAYING : LETTER_ANIMATION_STATE.STOPPED); }
public LetterSetup(string character, int letter_idx, Mesh mesh, Vector3 base_offset, ref CustomCharacterInfo char_info, int line_num, int word_idx, EffectManager effect_manager) { m_character = character; m_mesh = mesh; m_base_offset = base_offset; m_effect_manager_handle = effect_manager; m_progression_variables = new AnimationProgressionVariables(letter_idx, word_idx, line_num); m_anim_state_vars = new AnimationStateVariables(); m_anim_state_vars.m_active_loop_cycles = new List <ActionLoopCycle>(); SetupLetterMesh(ref char_info); if (m_flipped) { // flip UV coords in x axis. m_mesh.uv = new Vector2[] { mesh.uv[3], mesh.uv[2], mesh.uv[1], mesh.uv[0] }; } }
public void Recycle(string character, int letter_idx, Mesh mesh, Vector3 base_offset, ref CustomCharacterInfo char_info, int line_num, int word_idx, EffectManager effect_manager) { m_character = character; m_mesh = mesh; m_base_offset = base_offset; m_effect_manager_handle = effect_manager; m_progression_variables = new AnimationProgressionVariables(letter_idx, word_idx, line_num); SetupLetterMesh(ref char_info); if (m_flipped) { // flip UV coords in x axis. m_mesh.uv = new Vector2[] { mesh.uv[3], mesh.uv[2], mesh.uv[1], mesh.uv[0] }; } m_current_letter_action = null; }
public void Create(EffectManager manager) { this.Manager = manager; this.Manager.LightSources.Add(this); }
public void Initialize(InitParamFloatingMine initParam) { //IL_00be: Unknown result type (might be due to invalid IL or missing references) //IL_00c3: Expected O, but got Unknown //IL_0106: Unknown result type (might be due to invalid IL or missing references) //IL_010d: Unknown result type (might be due to invalid IL or missing references) //IL_0113: Unknown result type (might be due to invalid IL or missing references) //IL_0118: Unknown result type (might be due to invalid IL or missing references) //IL_011d: Unknown result type (might be due to invalid IL or missing references) //IL_012f: Unknown result type (might be due to invalid IL or missing references) //IL_0135: Unknown result type (might be due to invalid IL or missing references) //IL_013a: Unknown result type (might be due to invalid IL or missing references) //IL_014b: Unknown result type (might be due to invalid IL or missing references) //IL_015c: Unknown result type (might be due to invalid IL or missing references) //IL_0161: Expected O, but got Unknown //IL_016b: Unknown result type (might be due to invalid IL or missing references) //IL_0178: Unknown result type (might be due to invalid IL or missing references) //IL_017d: Unknown result type (might be due to invalid IL or missing references) //IL_0189: Unknown result type (might be due to invalid IL or missing references) //IL_0196: Unknown result type (might be due to invalid IL or missing references) //IL_019b: Expected O, but got Unknown //IL_01c1: Unknown result type (might be due to invalid IL or missing references) //IL_01c6: Unknown result type (might be due to invalid IL or missing references) //IL_01fa: Unknown result type (might be due to invalid IL or missing references) //IL_01ff: Expected O, but got Unknown //IL_021e: Unknown result type (might be due to invalid IL or missing references) //IL_0220: Unknown result type (might be due to invalid IL or missing references) if (initParam.atkInfo != null) { m_atkInfo = initParam.atkInfo; AttackHitInfo attackHitInfo = m_atkInfo as AttackHitInfo; if (attackHitInfo != null) { attackHitInfo.enableIdentityCheck = false; } BulletData bulletData = m_atkInfo.bulletData; if (!(bulletData == null)) { BulletData.BulletBase data = bulletData.data; if (data != null) { BulletData.BulletMine dataMine = bulletData.dataMine; if (dataMine != null) { m_attacker = initParam.attacker; m_landHitEffectName = data.landHiteffectName; m_aliveTimer = data.appearTime; m_moveSpeed = data.speed; m_slowDownRate = dataMine.slowDownRate; m_unbreakableTimer = dataMine.unbrakableTime; m_mineData = dataMine; m_isDeleted = false; m_cachedTransform = this.get_transform(); m_cachedTransform.set_parent((!MonoBehaviourSingleton <StageObjectManager> .IsValid()) ? MonoBehaviourSingleton <EffectManager> .I._transform : MonoBehaviourSingleton <StageObjectManager> .I._transform); Transform launchTrans = initParam.launchTrans; m_cachedTransform.set_position(launchTrans.get_position() + launchTrans.get_rotation() * initParam.offsetPos); m_cachedTransform.set_rotation(launchTrans.get_rotation() * initParam.offsetRot); m_cachedTransform.set_localScale(data.timeStartScale); Transform effect = EffectManager.GetEffect(data.effectName, this.get_transform()); effect.set_localPosition(data.dispOffset); effect.set_localRotation(Quaternion.Euler(data.dispRotation)); effect.set_localScale(Vector3.get_one()); m_effectObj = effect.get_gameObject(); m_effectDeleteAnimator = m_effectObj.GetComponent <Animator>(); float radius = data.radius; float height = 0f; Vector3 hitOffset = data.hitOffset; int num = 0; if (dataMine.isIgnoreHitEnemyAttack) { num |= 0xA000; } if (dataMine.isIgnoreHitEnemyMove) { num |= 0x400; } GameObject val = new GameObject("MineAttackObject"); MineAttackObject mineAttackObject = val.AddComponent <MineAttackObject>(); mineAttackObject.Initialize(m_attacker, m_cachedTransform, m_atkInfo, hitOffset, Vector3.get_zero(), radius, height, 31); mineAttackObject.SetIgnoreLayerMask(num); m_mineAttackObj = mineAttackObject; RequestMain(); } } } } }
public virtual void Initialize() { effectManager = new EffectManager(GraphicsDevice, Content); backBufferManager = new BackBufferManager(GraphicsDevice); LoadContent(); }
private IEnumerator DoStartLogoAnimation(bool tutorial_flag, Action onComplete, Action onLoop) { logo.root.set_position(Vector3.get_up() * 1000f); logo.root.set_rotation(Quaternion.get_identity()); logo.root.set_localScale(Vector3.get_one()); logo.camera.get_gameObject().SetActive(true); Material faderMat = logo.fader.get_material(); Material logoMat = logo.logo.get_material(); logo.camera.set_depth(-1f); logo.dragonRoot.SetActive(false); Color dragonPlaneColor = new Color(1f, 1f, 1f, 0f); logo.dragonPlane.get_sharedMaterial().SetColor("Color", dragonPlaneColor); if (tutorial_flag) { this.StartCoroutine(DoFadeOut()); SoundManager.RequestBGM(11, false); while (MonoBehaviourSingleton <SoundManager> .I.playingBGMID != 11 || MonoBehaviourSingleton <SoundManager> .I.changingBGM) { yield return((object)null); } yield return((object)new WaitForSeconds(2.3f)); } else { faderMat.SetColor("_Color", new Color(0f, 0f, 0f, 0f)); } effects = (GameObject[])new GameObject[titleEffectPrefab.Length]; for (int j = 0; j < titleEffectPrefab.Length; j++) { rymFX effect = ResourceUtility.Realizes(titleEffectPrefab[j], -1).GetComponent <rymFX>(); effect.Cameras = (Camera[])new Camera[1] { logo.camera }; effect.get__transform().set_localScale(effect.get__transform().get_localScale() * 10f); if (j == 1) { effect.get__transform().set_position(new Vector3(0.568f, 999.946f, 0.1f)); } else { effect.get__transform().set_position(logo.eye.get_transform().get_position()); } effects[j] = effect.get_gameObject(); } yield return((object)new WaitForSeconds(1f)); float timer4 = 0f; while (timer4 < 0.17f) { timer4 += Time.get_deltaTime(); float s = Mathf.Clamp01(timer4 / 0.17f); logo.eye.get_transform().set_localScale(Vector3.get_one() * s * 10f); logoMat.SetFloat("_AlphaRate", -1f + timer4 * 2f); yield return((object)null); } logo.dragonRoot.SetActive(true); while (timer4 < 1f) { timer4 += Time.get_deltaTime(); logoMat.SetFloat("_AlphaRate", -1f + timer4 * 2f); dragonPlaneColor.a = timer4; logo.dragonPlane.get_sharedMaterial().SetColor("Color", dragonPlaneColor); yield return((object)null); } dragonPlaneColor.a = 1f; logo.dragonPlane.get_sharedMaterial().SetColor("Color", dragonPlaneColor); timer4 = 0f; while (timer4 < 0.5f) { timer4 += Time.get_deltaTime(); logoMat.SetFloat("_BlendRate", timer4 * 2f); yield return((object)null); } logo.bg.SetActive(true); logo.effect1.SetActive(true); timer4 = 0f; Material bgMaterial = logo.bgFader.get_material(); while (timer4 < 0.7f) { timer4 += Time.get_deltaTime(); bgMaterial.set_color(new Color(1f, 1f, 1f, 1f - timer4 / 0.7f)); yield return((object)null); } if (!tutorial_flag) { onLoop?.Invoke(); while (!tutorial_flag) { yield return((object)null); } } yield return((object)new WaitForSeconds(0.3f)); if (titleUIPrefab != null) { Transform title_ui = ResourceUtility.Realizes(titleUIPrefab, MonoBehaviourSingleton <UIManager> .I.uiRootTransform, 5); if (title_ui != null) { Transform t3 = Utility.Find(title_ui, "BTN_START"); if (t3 != null) { t3.GetComponent <Collider>().set_enabled(false); } t3 = Utility.Find(title_ui, "BTN_ADVANCED_LOGIN"); if (t3 != null) { t3.get_gameObject().SetActive(false); } t3 = Utility.Find(title_ui, "BTN_CLEARCACHE"); if (t3 != null) { t3.get_gameObject().SetActive(false); } } } yield return((object)new WaitForSeconds(6f)); timer4 = 0f; while (timer4 < 0.3f) { timer4 += Time.get_deltaTime(); faderMat.SetColor("_Color", new Color(0f, 0f, 0f, timer4 / 0.3f)); yield return((object)null); } MonoBehaviourSingleton <InputManager> .I.SetDisable(INPUT_DISABLE_FACTOR.INGAME_TUTORIAL, false); for (int i = 0; i < effects.Length; i++) { EffectManager.ReleaseEffect(effects[i], true, false); } onComplete?.Invoke(); }
void SetupMesh(LetterAction letter_action, LetterAction prev_action, float action_progress, AnimationProgressionVariables progression_variables, AnimatePerOptions animate_per, float linear_progress, EffectManager effect_manager) { // construct current anchor offset vector m_anchor_offset = letter_action.AnchorOffsetStart; m_anchor_offset = new Vector3(m_anchor_offset.x * m_width, letter_action.m_letter_anchor_start == (int)TextfxTextAnchor.BaselineLeft || letter_action.m_letter_anchor_start == (int)TextfxTextAnchor.BaselineCenter || letter_action.m_letter_anchor_start == (int)TextfxTextAnchor.BaselineRight ? 0 // zero because letters are based around the baseline already. : (effect_manager.IsFontBaseLineSet ? (effect_manager.FontBaseLine + m_y_offset) - (m_anchor_offset.y * -m_height) : (m_anchor_offset.y * m_height)), // Legacy effect support when baseline isn't already set. 0); if (letter_action.m_letter_anchor_2_way) { m_anchor_offset = letter_action.AnchorOffsetEnd; m_anchor_offset = Vector3.Lerp(m_anchor_offset, new Vector3( m_anchor_offset.x * m_width, letter_action.m_letter_anchor_end == (int)TextfxTextAnchor.BaselineLeft || letter_action.m_letter_anchor_end == (int)TextfxTextAnchor.BaselineCenter || letter_action.m_letter_anchor_end == (int)TextfxTextAnchor.BaselineRight ? 0 // zero because letters are based around the baseline already. : (effect_manager.IsFontBaseLineSet ? (effect_manager.FontBaseLine + m_y_offset) - (m_anchor_offset.y * -m_height) : (m_anchor_offset.y * m_height)), // Legacy effect support when baseline isn't already set. 0), action_progress); } // Calculate Scale Vector from_vec = letter_action.m_start_scale.GetValue(progression_variables, animate_per); to_vec = letter_action.m_end_scale.GetValue(progression_variables, animate_per); if (letter_action.m_scale_axis_ease_data.m_override_default) { m_letter_scale = new Vector3(EffectManager.FloatLerp(from_vec.x, to_vec.x, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_x_ease, linear_progress)), EffectManager.FloatLerp(from_vec.y, to_vec.y, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_y_ease, linear_progress)), EffectManager.FloatLerp(from_vec.z, to_vec.z, EasingManager.GetEaseProgress(letter_action.m_scale_axis_ease_data.m_z_ease, linear_progress))); } else { m_letter_scale = EffectManager.Vector3Lerp( from_vec, to_vec, action_progress); } // Calculate Rotation from_vec = letter_action.m_start_euler_rotation.GetValue(progression_variables, animate_per); to_vec = letter_action.m_end_euler_rotation.GetValue(progression_variables, animate_per); if (letter_action.m_rotation_axis_ease_data.m_override_default) { m_letter_rotation = Quaternion.Euler ( EffectManager.FloatLerp(from_vec.x, to_vec.x, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_x_ease, linear_progress)), EffectManager.FloatLerp(from_vec.y, to_vec.y, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_y_ease, linear_progress)), EffectManager.FloatLerp(from_vec.z, to_vec.z, EasingManager.GetEaseProgress(letter_action.m_rotation_axis_ease_data.m_z_ease, linear_progress)) ); } else { m_letter_rotation = Quaternion.Euler( EffectManager.Vector3Lerp( from_vec, to_vec, action_progress) ); } // Calculate Position if (letter_action.m_start_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX || (letter_action.m_offset_from_last && prev_action != null && prev_action.m_end_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX)) { from_vec = new Vector3(-m_anchor_offset.x, m_base_offset.y, 0); } else if (letter_action.m_start_pos.m_force_position_override) { from_vec = new Vector3(-m_anchor_offset.x, 0, 0); } else { from_vec = BaseOffset; } from_vec += letter_action.m_start_pos.GetValue(progression_variables, animate_per); if (letter_action.m_end_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX || (letter_action.m_end_pos.IsOffsetFromLast && letter_action.m_start_pos.Progression == ActionPositionVector3Progression.CURVE_OPTION_INDEX)) { to_vec = new Vector3(-m_anchor_offset.x, m_base_offset.y, 0); } else if (letter_action.m_end_pos.m_force_position_override) { to_vec = new Vector3(-m_anchor_offset.x, 0, 0); } else { to_vec = BaseOffset; } to_vec += letter_action.m_end_pos.GetValue(progression_variables, animate_per); if (letter_action.m_position_axis_ease_data.m_override_default) { m_letter_position = new Vector3(EffectManager.FloatLerp(from_vec.x, to_vec.x, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_x_ease, linear_progress)), EffectManager.FloatLerp(from_vec.y, to_vec.y, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_y_ease, linear_progress)), EffectManager.FloatLerp(from_vec.z, to_vec.z, EasingManager.GetEaseProgress(letter_action.m_position_axis_ease_data.m_z_ease, linear_progress))); } else { m_letter_position = EffectManager.Vector3Lerp( from_vec, to_vec, action_progress); } // Calculate letter center position m_letter_center = new Vector3(m_width / 2, m_height / 2, 0); m_letter_center -= m_anchor_offset; m_letter_center = Vector3.Scale(m_letter_center, m_letter_scale); m_letter_center = m_letter_rotation * m_letter_center; m_letter_center += m_anchor_offset + m_letter_position; if (mesh_verts == null || mesh_verts.Length == 0) { mesh_verts = new Vector3[4]; } for (int idx = 0; idx < 4; idx++) { mesh_verts[idx] = m_base_vertices[idx]; // normalise vert position to the anchor point before scaling and rotating. mesh_verts[idx] -= m_anchor_offset; // Scale verts mesh_verts[idx] = Vector3.Scale(mesh_verts[idx], m_letter_scale); // Rotate vert mesh_verts[idx] = m_letter_rotation * mesh_verts[idx]; mesh_verts[idx] += m_anchor_offset; // translate vert mesh_verts[idx] += m_letter_position; } m_mesh.vertices = mesh_verts; // Sort out letters colour if (letter_action.m_use_gradient_start) { start_colour = letter_action.m_start_vertex_colour.GetValue(progression_variables, animate_per); } else { start_colour = new VertexColour(letter_action.m_start_colour.GetValue(progression_variables, animate_per)); } if (letter_action.m_use_gradient_end) { end_colour = letter_action.m_end_vertex_colour.GetValue(progression_variables, animate_per); } else { end_colour = new VertexColour(letter_action.m_end_colour.GetValue(progression_variables, animate_per)); } if (!m_flipped) { m_mesh.colors = new Color[] { Color.Lerp(start_colour.top_right, end_colour.top_right, action_progress), Color.Lerp(start_colour.top_left, end_colour.top_left, action_progress), Color.Lerp(start_colour.bottom_left, end_colour.bottom_left, action_progress), Color.Lerp(start_colour.bottom_right, end_colour.bottom_right, action_progress) }; } else { m_mesh.colors = new Color[] { Color.Lerp(start_colour.top_left, end_colour.top_left, action_progress), Color.Lerp(start_colour.bottom_left, end_colour.bottom_left, action_progress), Color.Lerp(start_colour.bottom_right, end_colour.bottom_right, action_progress), Color.Lerp(start_colour.top_right, end_colour.top_right, action_progress) }; } }
private void Awake() { sight = transform.Find("Sight").GetComponent <Sight>(); attackRange = transform.Find("AttackRange").GetComponent <AttackRange>(); effectManager = GetComponentInChildren <EffectManager>(); }
public void AddEffect(bool isStay = false) { if (!m_PackageBoxAttr.HasValue || m_DropItemState == DropItemState.None) { return; } if (m_DropItemState == DropItemState.Born) { EffectController bornFxInstance = EffectManager.GetInstance().CreateEffect(m_PackageBoxAttr.Value.RefreshGfx, EffectManager.GetEffectGroupNameInSpace(false)); bornFxInstance.transform.position = gameObject.transform.position; WwiseUtil.PlaySound((int)WwiseMusic.DropItem_Bron, false, bornFxInstance.transform.position); bornFxInstance.SetCreateForMainPlayer(false); m_StayFxInstance = EffectManager.GetInstance().CreateEffect(m_PackageBoxAttr.Value.ContinuousGfx, EffectManager.GetEffectGroupNameInSpace(false)); m_StayFxInstance.transform.SetParent(gameObject.transform, false); m_StayFxInstance.SetCreateForMainPlayer(false); } else if (m_DropItemState == DropItemState.Stay && isStay) { m_StayFxInstance = EffectManager.GetInstance().CreateEffect(m_PackageBoxAttr.Value.ContinuousGfx, EffectManager.GetEffectGroupNameInSpace(false)); m_StayFxInstance.transform.SetParent(gameObject.transform, false); m_StayFxInstance.SetCreateForMainPlayer(false); } else if (m_DropItemState == DropItemState.Gather) { RemoveStayFx(); m_GatherFxInstance = EffectManager.GetInstance().CreateEffect(m_PackageBoxAttr.Value.PickUpGfx, EffectManager.GetEffectGroupNameInSpace(false)); m_GatherFxInstance.transform.position = gameObject.transform.position; m_GatherFxInstance.SetCreateForMainPlayer(false); } }
private void LateUpdate() { //IL_0012: Unknown result type (might be due to invalid IL or missing references) //IL_006d: Unknown result type (might be due to invalid IL or missing references) //IL_0073: Unknown result type (might be due to invalid IL or missing references) //IL_0084: Unknown result type (might be due to invalid IL or missing references) //IL_0089: Unknown result type (might be due to invalid IL or missing references) //IL_0099: Unknown result type (might be due to invalid IL or missing references) //IL_009e: Unknown result type (might be due to invalid IL or missing references) //IL_00b9: Unknown result type (might be due to invalid IL or missing references) //IL_00e2: Unknown result type (might be due to invalid IL or missing references) //IL_00e7: Unknown result type (might be due to invalid IL or missing references) //IL_013d: Unknown result type (might be due to invalid IL or missing references) //IL_0142: Unknown result type (might be due to invalid IL or missing references) //IL_0183: Unknown result type (might be due to invalid IL or missing references) //IL_018a: Expected O, but got Unknown //IL_0190: Unknown result type (might be due to invalid IL or missing references) //IL_01cd: Unknown result type (might be due to invalid IL or missing references) //IL_01d2: Unknown result type (might be due to invalid IL or missing references) //IL_01d6: Unknown result type (might be due to invalid IL or missing references) //IL_01db: Unknown result type (might be due to invalid IL or missing references) //IL_01e2: Unknown result type (might be due to invalid IL or missing references) //IL_01e7: Unknown result type (might be due to invalid IL or missing references) //IL_01e8: Unknown result type (might be due to invalid IL or missing references) //IL_01ed: Unknown result type (might be due to invalid IL or missing references) //IL_020e: Unknown result type (might be due to invalid IL or missing references) //IL_0219: Unknown result type (might be due to invalid IL or missing references) //IL_022f: Unknown result type (might be due to invalid IL or missing references) //IL_0234: Unknown result type (might be due to invalid IL or missing references) //IL_0247: Unknown result type (might be due to invalid IL or missing references) //IL_024c: Unknown result type (might be due to invalid IL or missing references) //IL_0251: Unknown result type (might be due to invalid IL or missing references) //IL_0252: Unknown result type (might be due to invalid IL or missing references) //IL_0257: Unknown result type (might be due to invalid IL or missing references) //IL_0259: Unknown result type (might be due to invalid IL or missing references) //IL_025a: Unknown result type (might be due to invalid IL or missing references) //IL_025c: Unknown result type (might be due to invalid IL or missing references) //IL_0261: Unknown result type (might be due to invalid IL or missing references) //IL_0269: Unknown result type (might be due to invalid IL or missing references) //IL_0270: Unknown result type (might be due to invalid IL or missing references) //IL_0280: Unknown result type (might be due to invalid IL or missing references) //IL_0285: Unknown result type (might be due to invalid IL or missing references) //IL_029d: Unknown result type (might be due to invalid IL or missing references) //IL_02be: Unknown result type (might be due to invalid IL or missing references) //IL_02ef: Unknown result type (might be due to invalid IL or missing references) if (targetObject == null) { this.get_gameObject().SetActive(false); } else { if (animEventProcessor != null) { animEventProcessor.Update(); } switch (animationStep) { case AnimationStep.MOVE_TO_TARGET_POS: { animationTimer += Time.get_deltaTime(); Vector3 position2 = Vector3.Lerp(dropPos, targetPos, animationTimer / MOVE_TO_TARGET_TIME); float x = position2.x; Vector3 position3 = _transform.get_position(); position2._002Ector(x, position3.y, position2.z); _transform.set_position(position2); if (animationTimer >= MOVE_TO_TARGET_TIME) { animationStep = AnimationStep.DROP_TO_GROUND; } break; } case AnimationStep.DROP_TO_GROUND: { AnimatorStateInfo currentAnimatorStateInfo2 = animator.GetCurrentAnimatorStateInfo(0); if (currentAnimatorStateInfo2.get_fullPathHash() == endAnimHash) { targetPoint = this.GetComponent <TargetPoint>(); animationStep = AnimationStep.NONE; } if (isRare) { SoundManager.PlayOneShotUISE(10000061); } else { SoundManager.PlayOneShotUISE(10000062); } break; } case AnimationStep.OPEN: { AnimatorStateInfo currentAnimatorStateInfo = animator.GetCurrentAnimatorStateInfo(0); if (currentAnimatorStateInfo.get_fullPathHash() == openAnimHash && currentAnimatorStateInfo.get_normalizedTime() > 0.99f) { animationStep = AnimationStep.NONE; if (effect != null) { EffectManager.ReleaseEffect(effect.get_gameObject(), true, false); } this.get_gameObject().SetActive(false); } break; } case AnimationStep.GET: if (distanceAnim.IsPlaying()) { moveTime += Time.get_deltaTime(); Bounds bounds = targetObject._collider.get_bounds(); Vector3 center = bounds.get_center(); Vector3 val = _transform.get_position() - center; float magnitude = val.get_magnitude(); if (distance < magnitude) { distance = magnitude; } val = val.get_normalized() * distance * (1f - distanceAnim.Update()); Vector3 val2 = Quaternion.AngleAxis(moveTime * speedAnim.Update(), Vector3.get_up()) * val; Vector3 position = center + val2; _transform.set_position(position); Vector3 localScale = Vector3.get_one() * scaleAnim.Update(); if (distanceAnim.IsPlaying()) { _transform.set_localScale(localScale); } } else { Transform val3 = EffectManager.GetEffect("ef_btl_mpdrop_01", null); val3.set_position(_transform.get_position()); rymFX component = val3.GetComponent <rymFX>(); if (component != null) { component.AutoDelete = true; component.LoopEnd = true; } this.get_gameObject().SetActive(false); } break; } } }
void Awake() { if (Inst == null) Inst = this; }
public void Shutdown() { Destroy(gameObject); instance = null; }
private void Awake() { effectManager = GameObject.Find("GameManager").GetComponent <EffectManager>(); }
private void DrawGUIWindow(out int edited_action, out bool start_of_action) { // Set out parameters to a default value start_of_action = true; edited_action = -1; // Check whether a EffectManager object is selected if (Selection.gameObjects.Length == 1) font_manager = Selection.gameObjects[0].GetComponent<EffectManager>(); if (font_manager == null) return; DrawEffectEditorPanel(); if (!ignore_gui_change) { start_of_action = editing_start_state; edited_action = edited_action_idx; } }
public override void FixedUpdate() { base.FixedUpdate(); if ((base.fixedAge - this.prevShot) > this.duration) { if (bulletCount > 0) { this.prevShot = base.fixedAge; bulletCount--; base.AddRecoil(-3f * this.recoil, -4f * this.recoil, -0.5f * this.recoil, 0.5f * this.recoil); Ray aimRay = base.GetAimRay(); muzzleName = "MuzzlePistol"; Util.PlaySound(FireBarrageScepter.attackSoundString, base.gameObject); if (BanditReloaded.BanditReloaded.useOldModel) { base.PlayAnimation("Gesture, Additive", "FireRevolver"); base.PlayAnimation("Gesture, Override", "FireRevolver"); } else { base.PlayAnimation("Gesture, Additive", "FireSideWeapon", "FireSideWeapon.playbackRate", 0.5f); } if (FireBarrageScepter.effectPrefab) { EffectManager.SimpleMuzzleFlash(FireBarrageScepter.effectPrefab, base.gameObject, muzzleName, false); } float bulletSpread = bulletCount <= 0 ? 0f : FireBarrageScepter.spread; if (base.isAuthority) { new BulletAttack { owner = base.gameObject, weapon = base.gameObject, origin = aimRay.origin, aimVector = aimRay.direction, minSpread = bulletSpread, maxSpread = bulletSpread, force = FireBarrageScepter.force, falloffModel = BulletAttack.FalloffModel.None, tracerEffectPrefab = FireBarrageScepter.tracerEffectPrefab, muzzleName = muzzleName, hitEffectPrefab = FireBarrageScepter.hitEffectPrefab, isCrit = this.isCrit, HitEffectNormal = true, radius = 0.4f, maxDistance = FireBarrageScepter.maxDistance, procCoefficient = 1f, damage = FireBarrageScepter.damageCoefficient * this.damageStat, damageType = DamageType.ResetCooldownsOnKill | DamageType.SlowOnHit, smartCollision = true }.Fire(); base.characterBody.SetSpreadBloom(FireBarrage.spread * 0.8f, false); } } else if (base.fixedAge - prevShot > endLag) { if (this.animator) { this.animator.SetLayerWeight(this.bodySideWeaponLayerIndex, 0f); } Transform transform = base.FindModelChild("SpinningPistolFX"); if (transform) { transform.gameObject.SetActive(false); } earlyExit = false; this.outer.SetNextState(new ExitRevolver()); return; } } }
public override void OnEnter() { base.OnEnter(); Ray aimRay = base.GetAimRay(); this.duration = this.baseDuration; Util.PlaySound(DiggerPlugin.Sounds.Backblast, base.gameObject); base.StartAimMode(0.6f, true); base.characterMotor.disableAirControlUntilCollision = false; float angle = Vector3.Angle(new Vector3(0, -1, 0), aimRay.direction); if (angle < 60) { base.PlayAnimation("FullBody, Override", "BackblastUp"); } else if (angle > 120) { base.PlayAnimation("FullBody, Override", "BackblastDown"); } else { base.PlayAnimation("FullBody, Override", "Backblast"); } if (NetworkServer.active) { base.characterBody.AddBuff(RoR2Content.Buffs.HiddenInvincibility); } if (base.isAuthority) { Vector3 theSpot = aimRay.origin + 2 * aimRay.direction; BlastAttack blastAttack = new BlastAttack(); blastAttack.radius = 14f; blastAttack.procCoefficient = 1f; blastAttack.position = theSpot; blastAttack.attacker = base.gameObject; blastAttack.crit = Util.CheckRoll(base.characterBody.crit, base.characterBody.master); blastAttack.baseDamage = base.characterBody.damage * BackBlast.damageCoefficient; blastAttack.falloffModel = BlastAttack.FalloffModel.None; blastAttack.baseForce = 500f; blastAttack.teamIndex = TeamComponent.GetObjectTeam(blastAttack.attacker); blastAttack.damageType = DamageType.Stun1s; blastAttack.attackerFiltering = AttackerFiltering.NeverHit; BlastAttack.Result result = blastAttack.Fire(); EffectData effectData = new EffectData(); effectData.origin = theSpot; effectData.scale = 15; EffectManager.SpawnEffect(DiggerPlugin.DiggerPlugin.backblastEffect, effectData, false); base.characterMotor.velocity = -80 * aimRay.direction; Compacted?.Invoke(result.hitCount); } }
public static IEnumerator SendAirstrike(UnturnedPlayer uCaller, Vector3 Position) { Vector3 callerPosition = new Vector3(); List <Vector3> StrikeList = new List <Vector3>(); Instance.Vectors.Add(Position); EffectManager.sendEffect(Instance.Configuration.Instance.AirstrikeLocationEffectID, EffectManager.INSANE, GetGround(Position).Value); if (Instance.Configuration.Instance.LogAirstrikes) { callerPosition = uCaller.Position; AirstrikeCount += 1; } if (Instance.Configuration.Instance.BroadcastAirstrikes) { UnturnedChat.Say($"Incomming Airstrike in {Instance.Configuration.Instance.StartDelay} Seconds! The Location is marked on your Map! Get into cover!", Color.yellow); } foreach (SteamPlayer sPlayer in Provider.clients) { UnturnedPlayer uPlayer = UnturnedPlayer.FromSteamPlayer(sPlayer); uPlayer.Player.quests.askSetMarker(uPlayer.CSteamID, true, Position); } yield return(new WaitForSeconds(Instance.Configuration.Instance.StartDelay)); Instance.Vectors.Remove(Position); DateTime beforeStrike = DateTime.Now; for (int i = 0; i < Instance.Configuration.Instance.StrikeCount; i++) { yield return(new WaitForSeconds(UnityEngine.Random.Range(Instance.Configuration.Instance.StrikeDelayMin, Instance.Configuration.Instance.StrikeDelayMax))); Vector3 airstrikeLocation = new Vector3(UnityEngine.Random.Range(Position.x - Instance.Configuration.Instance.DamageIntensity, Position.x + Instance.Configuration.Instance.DamageRadius), Position.y + 300, UnityEngine.Random.Range(Position.z - Instance.Configuration.Instance.DamageRadius, Position.z + Instance.Configuration.Instance.DamageRadius)); Ray airstrikeRay = new Ray(airstrikeLocation, Vector3.down); if (Physics.Raycast(airstrikeRay, out RaycastHit Hit)) { EffectManager.sendEffect(Instance.Configuration.Instance.StrikeExplosionEffectID, EffectManager.INSANE, Hit.point); List <EPlayerKill> killList = new List <EPlayerKill>(); DamageTool.explode(Hit.point, Instance.Configuration.Instance.DamageIntensity, EDeathCause.MISSILE, uCaller.CSteamID, 200, 200, 200, 200, 200, 200, 200, 200, out killList, EExplosionDamageType.CONVENTIONAL, 32, true, false, EDamageOrigin.Rocket_Explosion, ERagdollEffect.NONE); killList.Clear(); if (Instance.Configuration.Instance.LogAirstrikes) { StrikeList.Add(Hit.point); } } } DateTime afterStrike = DateTime.Now; if (Instance.Configuration.Instance.LogAirstrikes) { LogAirstrike($"[{DateTime.Now.ToString("yyy/MM/dd h:mm:ss tt")}]\n\nUser:\n{uCaller.DisplayName} [{uCaller.Id}].\n\nAirstrike Start Delay:\n{Instance.Configuration.Instance.StartDelay} seconds.\n\nStrikes:\n{Instance.Configuration.Instance.StrikeCount}.\n\nAverage Strike Time:\n{(Instance.Configuration.Instance.StrikeDelayMin + Instance.Configuration.Instance.StrikeDelayMax) / 2} seconds.\n\nCaller Position:\n{callerPosition}.\n\nAirstrike Location:\n{Position}.\n\nDistance from Caller:\n{(int)Vector3.Distance(callerPosition, Position)}M.\n\nDamage Intensity:\n{Instance.Configuration.Instance.DamageIntensity}.\n\nStrike Radius:\n{Instance.Configuration.Instance.DamageRadius}M.\n\nAirstrikes this Uptime: {AirstrikeCount}.\n\nThis Airstrike lasted {Math.Round((afterStrike - beforeStrike).TotalSeconds, 2)} Seconds.", StrikeList); StrikeList.Clear(); } if (Instance.Configuration.Instance.BroadcastAirstrikes) { UnturnedChat.Say("The Airstrike is over!", Color.yellow); } foreach (SteamPlayer sPlayer in Provider.clients) { UnturnedPlayer uPlayer = UnturnedPlayer.FromSteamPlayer(sPlayer); uPlayer.Player.quests.askSetMarker(uPlayer.CSteamID, false, Position); } yield return(new WaitForSeconds(Instance.Configuration.Instance.LocationFadeTime)); EffectManager.askEffectClearByID(Instance.Configuration.Instance.AirstrikeLocationEffectID, uCaller.CSteamID); }
void Awake() { button = GetComponent<Button>(); audioManager = GameObject.Find("AudioManager").GetComponent<AudioManager>(); effectManager = GameObject.Find("EffectManager").GetComponent<EffectManager>(); }