Ejemplo n.º 1
0
        public unsafe override void Begin()
        {
            this.currentlyInside = HashSetPool <HealthComponent> .item;
            this.timers          = DictionaryPool <HealthComponent, Single> .item;

            Single *ptr     = stackalloc Single[1];
            var     trigger = new SphereTriggerCallbackProvider <Callbacks>();
            var     data    = new EffectData();

            this.damageMult   = this.boost * this.power;
            trigger.cb.orb    = this;
            data.genericFloat = trigger.cb.maxDuration = this.duration *= this.boost;
            data.origin       = trigger.cb.origin = this.origin;
            data.scale        = trigger.cb.minRadius = minRadius;
            ptr[0]            = trigger.cb.maxRadius = maxRadius * this.boost;
            data.genericUInt  = *((UInt32 *)ptr);
            trigger.Start();

            if (orbEffect == EffectIndex.Invalid)
            {
                orbEffect = EffectCatalog.FindEffectIndexFromPrefab(VFXModule.GetSporeOrbPrefab());
            }
            EffectManager.SpawnEffect(orbEffect, data, true);
            base.Begin();
        }
Ejemplo n.º 2
0
        protected sealed override void Init()
        {
            logSource = base.logger;
            Log.Message("Sniper initializing");
            instance = this;


            base.awake += () =>
            {
                SetModdedModule.SetModded();
                ReinCore.AddModHash(guid, Properties.Info.ver, useBuild, useRev, networkVer);
                ConfigModule.CreateAndLoadConfig(this);

                Properties.Tools.RegisterLanguageTokens();
                SoundModule.LoadBank();
                NetworkModule.SetupNetworking();

                Default <Sprite> .value = UIModule.GetUnfinishedIcon();
                UIModule.EditHudPrefab();

                PrefabModule.CreatePrefab();
                DisplayModule.CreateDisplayPrefab();

                CatalogModule.RegisterBody();
                CatalogModule.RegisterSurvivor();
                CatalogModule.RegisterDoTType();
                CatalogModule.RegisterDamageTypes();
                CatalogModule.RegisterBuffTypes();
                CatalogModule.RegisterOrbs();
                CatalogModule.RegisterOverlays();

                VFXModule.Init();

                //UnlocksCore.AddUnlockable<WIPUnlockable>(false);
            };

            base.start += () =>
            {
                //MetaCatalog.LogCatalogState();

                try
                {
                    RoR2.Console.instance.SubmitCmd(null, "spp_disable_survivor Sniper");
                } catch { }
                _ = TextureModule.GetExplosiveAmmoRamp();
                _ = TextureModule.GetPlasmaAmmoRamp();
                _ = TextureModule.GetStandardAmmoRamp();
                _ = TextureModule.GetShockAmmoRamp();
                _ = TextureModule.GetScatterAmmoRamp();
            };

            base.enable      += HooksModule.Add;
            base.disable     += HooksModule.Remove;
            base.fixedUpdate += () => dt = Time.fixedDeltaTime;
            Log.Message("Sniper loaded successfully");
        }
Ejemplo n.º 3
0
        internal static GameObject CreateShockOrbEffect()
        {
            GameObject obj = Resources.Load <GameObject>("Prefabs/Effects/OrbEffects/LightningOrbEffect").ClonePrefab("ShockOrbEffect", false);

            foreach (var r in obj.GetComponentsInChildren <Renderer>())
            {
                var cm = new CloudMaterial(r.material.Instantiate());
                cm.remapTexture.texture = TextureModule.GetShockAmmoRamp();
                r.material = cm.material;
            }
            obj.GetComponent <OrbEffect>().endEffect = VFXModule.GetShockImpactPrefab();

            return(obj);
        }
Ejemplo n.º 4
0
 static FMJContext()
 {
     _tracer = VFXModule.GetStandardAmmoTracer();
     RicochetController.ricochetEffectPrefab = VFXModule.GetRicochetEffectPrefab();
 }
Ejemplo n.º 5
0
        internal void CreateAndAddSkin(CharacterModel model, String nameToken, String unlockableName, Sprite icon)
        {
            var rampTex = this.knifeTrail.OutputTextureAndDispose();

            using (var skin = Skin.Create(model))
            {
                var snipermeshInd   = -1;
                var throwkinfeInd   = -1;
                var knifeInd        = -1;
                var railgunInd      = -1;
                var gaussgunInd     = -1;
                var ammomeshInd     = -1;
                var armormeshInd    = -1;
                var bodymeshInd     = -1;
                var cloakmeshInd    = -1;
                var emismeshInd     = -1;
                var classicRifleInd = -1;
                var classicMeshInd  = -1;

                CharacterModel.RendererInfo[] rendInfos = skin.rendererInfos;
                for (Int32 i = 0; i < rendInfos.Length; ++i)
                {
                    CharacterModel.RendererInfo info = rendInfos[i];
                    Renderer smr = info.renderer;
                    switch (smr.name)
                    {
                    default:
#if ASSERT
                        Log.Warning(String.Format("{0} is not a handled renderer name", smr.name));
#endif
                        info.defaultMaterial = null;
                        break;

                    case "SniperMesh":
                        info.defaultMaterial = null;
                        snipermeshInd        = i;
                        break;

                    case "ThrowKnife":
                        info.defaultMaterial = this.throwknifeMat;
                        throwkinfeInd        = i;
                        break;

                    case "Knife":
                        info.defaultMaterial = this.isTrash ? null : this.knifeMat;
                        knifeInd             = i;
                        break;

                    case "RailGun":
                        info.defaultMaterial = this.isTrash ? null : this.railMat;
                        railgunInd           = i;
                        break;

                    case "GaussGun":
                        info.defaultMaterial = null;
                        gaussgunInd          = i;
                        break;

                    case "AmmoMesh":
                        info.defaultMaterial = this.isTrash ? null : this.ammoMat;
                        ammomeshInd          = i;
                        break;

                    case "ArmorMesh":
                        info.defaultMaterial = this.isTrash ? null : this.armorMat;
                        armormeshInd         = i;
                        break;

                    case "BodyMesh":
                        info.defaultMaterial = this.isTrash ? null : this.bodyMat;
                        bodymeshInd          = i;
                        break;

                    case "CloakMesh":
                        info.defaultMaterial = this.isTrash ? null : this.cloakMat;
                        cloakmeshInd         = i;
                        break;

                    case "EmissionMesh":
                        info.defaultMaterial = this.isTrash ? null : this.emisMat;
                        emismeshInd          = i;
                        break;

                    case "ClassicRifle":
                        info.defaultMaterial = !this.isTrash ? null : this.railMat;
                        classicRifleInd      = i;
                        break;

                    case "ClassicMesh":
                        info.defaultMaterial = !this.isTrash ? null : this.armorMat;
                        classicMeshInd       = i;
                        break;
                    }
                    rendInfos[i] = info;
                }
                skin.rendererInfos = rendInfos;



                skin.projectileGhostReplacements = new[]
                {
                    new SkinDef.ProjectileGhostReplacement
                    {
                        projectilePrefab = ProjectileModule.GetKnifeProjectile(),
                        projectileGhostReplacementPrefab = ProjectileGhostModule.GetKnifeGhost(this.throwknifeMat, MaterialModule.GetKnifeTrailMaterial(rampTex).material),
                    },
                };

                if (this.isTrash)
                {
                    skin.gameObjectActivations = new[]
                    {
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = false,
                            gameObject     = rendInfos[armormeshInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = false,
                            gameObject     = rendInfos[ammomeshInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = false,
                            gameObject     = rendInfos[bodymeshInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = false,
                            gameObject     = rendInfos[cloakmeshInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = false,
                            gameObject     = rendInfos[emismeshInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = false,
                            gameObject     = rendInfos[railgunInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = false,
                            gameObject     = rendInfos[knifeInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = true,
                            gameObject     = rendInfos[classicMeshInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = true,
                            gameObject     = rendInfos[classicRifleInd].renderer.gameObject,
                        }
                    };
                }
                else
                {
                    skin.gameObjectActivations = new[]
                    {
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = true,
                            gameObject     = rendInfos[armormeshInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = true,
                            gameObject     = rendInfos[ammomeshInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = true,
                            gameObject     = rendInfos[bodymeshInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = true,
                            gameObject     = rendInfos[cloakmeshInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = true,
                            gameObject     = rendInfos[emismeshInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = true,
                            gameObject     = rendInfos[railgunInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = true,
                            gameObject     = rendInfos[knifeInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = false,
                            gameObject     = rendInfos[classicMeshInd].renderer.gameObject,
                        },
                        new SkinDef.GameObjectActivation
                        {
                            shouldActivate = false,
                            gameObject     = rendInfos[classicRifleInd].renderer.gameObject,
                        }
                    };
                }

                skin.icon           = icon;
                skin.nameToken      = nameToken;
                skin.unlockableName = unlockableName;
            }

            var index    = model.GetComponent <ModelSkinController>().skins.Length - 1;
            var material = MaterialModule.GetSlashMaterial(rampTex);

            VFXModule.AddKnifePickupSlash((UInt32)index, material);
        }