Exemplo n.º 1
0
        public void Start()
        {
            Shader glowshader = ShaderCache.Acquire("Brave/LitTk2dCustomFalloffTiltedCutoutEmissive");

            foreach (Transform transform in base.transform)
            {
                if (TransformList.Contains(transform.name))
                {
                    tk2dSprite sproot = transform.GetComponent <tk2dSprite>();
                    if (sproot != null)
                    {
                        sproot.usesOverrideMaterial     = true;
                        sproot.renderer.material.shader = glowshader;
                        sproot.renderer.material.EnableKeyword("BRIGHTNESS_CLAMP_ON");
                        sproot.renderer.material.SetFloat("_EmissivePower", EmissivePower);
                        sproot.renderer.material.SetFloat("_EmissiveColorPower", EmissiveColorPower);
                    }
                }
            }
            this.beamcont = base.GetComponent <BasicBeamController>();
            BasicBeamController beam = this.beamcont;

            beam.sprite.usesOverrideMaterial = true;
            BasicBeamController component = beam.gameObject.GetComponent <BasicBeamController>();
            bool flag  = component != null;
            bool flag2 = flag;

            if (flag2)
            {
                component.sprite.renderer.material.shader = glowshader;
                component.sprite.renderer.material.EnableKeyword("BRIGHTNESS_CLAMP_ON");
                component.sprite.renderer.material.SetFloat("_EmissivePower", EmissivePower);
                component.sprite.renderer.material.SetFloat("_EmissiveColorPower", EmissiveColorPower);
            }
        }
Exemplo n.º 2
0
/*AUTO SCRIPT*/
/*AUTO SCRIPT*/ public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
/*AUTO SCRIPT*/ {
/*AUTO SCRIPT*/ if (list == null)
/*AUTO SCRIPT*/ {
/*AUTO SCRIPT*/ list  = EditorUtility.GetPropertyObject <TransformList>(property);
/*AUTO SCRIPT*/ rList = new ReorderableList(list, typeof(Transform), true, false, true, true);
/*AUTO SCRIPT*/                         // rList.onAddCallback += data => { list.Add(defaultVal); };
/*AUTO SCRIPT*/                         // rList.onChangedCallback += data=> {
/*AUTO SCRIPT*/                         // };
/*AUTO SCRIPT*/ }
/*AUTO SCRIPT*/
/*AUTO SCRIPT*/ numLines = 3 + list.Count;
/*AUTO SCRIPT*/ var title  = new GUIContent($" {label.text}");
/*AUTO SCRIPT*/ var height = base.GetPropertyHeight(property, label);
/*AUTO SCRIPT*/ var rect   = new Rect(position.x, position.y, position.width, height);

/*AUTO SCRIPT*/ EditorGUI.BeginChangeCheck();
/*AUTO SCRIPT*/ rList.DoList(rect);
/*AUTO SCRIPT*/ EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), title);
/*AUTO SCRIPT*/
/*AUTO SCRIPT*/ if (EditorGUI.EndChangeCheck())
            {
/*AUTO SCRIPT*/ property.serializedObject.ApplyModifiedProperties();
            }
/*AUTO SCRIPT*/
/*AUTO SCRIPT*/ }
Exemplo n.º 3
0
 public AttackController(Transform owner, AttackBehaviour attackBehaviour, TransformList enemiesList)
 {
     this.owner           = owner;
     this.attackBehaviour = attackBehaviour;
     this.enemiesList     = enemiesList;
     targets = new Transform[attackBehaviour.TargetLimit];
 }
Exemplo n.º 4
0
        public bool StartTLS(string strServer)
        {
            /// Negotiate TLS, don't return until it's done
            /// (We would use SslStream in normal .NET, but that's not available here)
            /// TLS is implement as a message filter
            TLStrans = new xmedianet.socketserver.TLS.TLSClientTransform(this);
            TransformList.Add(TLStrans);
            TLStrans.Activate();

            return(false);
        }
Exemplo n.º 5
0
        public void Initialize(int bounces, float damageReductionPerBounce, float jumpRadius, TransformList enemiesAlive)
        {
            totalBounces  = bounces;
            currentBounce = 1;
            this.damageReductionPerBounce = damageReductionPerBounce;
            this.jumpRadius   = jumpRadius;
            this.enemiesAlive = enemiesAlive;

            projectile = GetComponent <Projectile>();
            projectile.SetDeathBehaviour(this);
            currentTarget = projectile.Target;
            initialized   = true;
        }
Exemplo n.º 6
0
        public void Initialize(int shatterAmount, float jumpRadius, float damageReductionOnShatter, AttackBehaviour shatterAttackBehaviour, TransformList enemiesAlive)
        {
            this.shatterAmount            = shatterAmount;
            this.damageReductionOnShatter = damageReductionOnShatter;
            this.jumpRadius             = jumpRadius;
            this.shatterAttackBehaviour = shatterAttackBehaviour;
            this.enemiesAlive           = enemiesAlive;

            projectile = GetComponent <Projectile>();
            projectile.SetDeathBehaviour(this);
            currentTarget = projectile.Target;

            initialized = true;
        }
Exemplo n.º 7
0
    public override void OnInspectorGUI()
    {
        GUILayoutOption width70 = GUILayout.Width(70);
        GUILayoutOption width40 = GUILayout.Width(40);

        // basic setup block
        GUILayout.Label("Destination", EditorStyles.boldLabel);
        if (transformList == null)
        {
            transformList = (TransformList)target;
        }
        GUILayout.BeginHorizontal();
        transformList.usePosition     = GUILayout.Toggle(transformList.usePosition, "Position", width70);
        transformList.useRotation     = GUILayout.Toggle(transformList.useRotation, "Rotation", width70);
        transformList.useScale        = GUILayout.Toggle(transformList.useScale, "Scale", GUILayout.Width(50));
        transformList.targetTransform = (Transform)(EditorGUILayout.ObjectField(transformList.targetTransform, typeof(Transform), true));
        GUILayout.EndHorizontal();

        // config block
        GUILayout.BeginHorizontal();
        transformList.autoSave   = GUILayout.Toggle(transformList.autoSave, "Auto Save", GUILayout.Width(80));
        transformList.isExpanded = GUILayout.Toggle(transformList.isExpanded, "Expand	", GUILayout.Width(60));
        GUILayout.Label("ID", GUILayout.Width(20));
        transformList.id = GUILayout.TextField(transformList.id);
        GUILayout.EndHorizontal();

        // save load block
        GUILayout.BeginHorizontal();
        if (GUILayout.Button("Save"))
        {
            transformList.saveSet();
        }
        if (GUILayout.Button("Load"))
        {
            transformList.loadSet();
        }
        GUILayout.EndHorizontal();
        GUILayout.Space(10);

        // info block
        GUILayout.Label(" At step " + (transformList.currentStep + 1) + " of " + transformList.transforms.count + "  (" + transformList.transforms.labels[transformList.currentStep] + ")");
        GUILayout.Space(10);

        // store remove update block
        GUILayout.BeginHorizontal();
        if (GUILayout.Button("Update Current"))
        {
            transformList.updateCurrent();
        }
        if (transformList.transforms.count < 100 && GUILayout.Button("Add Current"))
        {
            transformList.storeCurrent();
        }
        if (GUILayout.Button("Remove Current"))
        {
            transformList.remove(transformList.currentStep);
        }
        GUILayout.EndHorizontal();

        // playstatus
        transformList.jumpOrAnimate = GUILayout.Toolbar(transformList.jumpOrAnimate, new string[] { "Animate", "Jump", "Pause" });

        // forward backward block
        GUILayout.BeginHorizontal();
        if (GUILayout.Button("<<"))
        {
            gotoPrev();
        }
        if (GUILayout.Button(">>"))
        {
            gotoNext();
        }
        if (GUILayout.Button("Random"))
        {
            transformList.gotoRandom();
        }
        GUILayout.EndHorizontal();

        // speedslider block
        GUILayout.Label("Smoothness " + transformList.speed.ToString("F"));
        transformList.speed = GUILayout.HorizontalSlider(transformList.speed, 0, 1.5f);
        GUILayout.BeginHorizontal();
        GUILayout.Label("Interval  (" + (transformList.interval * (1 - transformList.randomFactor)).ToString("F") + "s to " + (transformList.interval * (1 + transformList.randomFactor)).ToString("F") + "s)", GUILayout.Width(200));
        transformList.randomFactor = GUILayout.HorizontalSlider(transformList.randomFactor, 0, 1);
        GUILayout.EndHorizontal();
        transformList.interval = GUILayout.HorizontalSlider(transformList.interval, 0.1f, 10f);

        // Details block
        if (transformList.isExpanded)
        {
            GUILayout.Space(40);
            for (int i = 0; i < transformList.transforms.count; i++)
            {
                GUILayout.BeginHorizontal();
                if (i > 0)
                {
                    if (GUILayout.Button("Up", EditorStyles.miniButton, width40))
                    {
                        transformList.swap(i, i - 1);
                    }
                }
                else
                {
                    GUILayout.Button(" ", EditorStyles.centeredGreyMiniLabel, width40);
                }
                if (i + 1 < transformList.transforms.count)
                {
                    if (GUILayout.Button("Dn", EditorStyles.miniButton, width40))
                    {
                        transformList.swap(i, i + 1);
                    }
                }
                else
                {
                    GUILayout.Button(" ", EditorStyles.centeredGreyMiniLabel, width40);
                }
                if (GUILayout.Button("X", EditorStyles.miniButton, width40))
                {
                    transformList.remove(i);
                }
                if (transformList.currentStep != i)
                {
                    if (GUILayout.Button("", EditorStyles.foldout, width40))
                    {
                        transformList.GoToStep(i);
                    }
                }
                else
                {
                    GUILayout.Label("ACT", width40);
                }
                transformList.transforms.labels[i] = GUILayout.TextField(transformList.transforms.labels[i]);

                GUILayout.EndHorizontal();
            }
        }

        //   GUILayout.Space(100);
        //   DrawDefaultInspector();
    }
Exemplo n.º 8
0
        public void Statistcs_ListGeneralizeMeanBlockAlgorithmTest()
        {
            var target = new ListGeneralizedMeanAlgorithm <int, double>(
                i => i,
                d => d,
                (d, i) => d / i,
                new DoubleField());
            var blockNumber = 2500;

            var integerSequence = new List <int>();

            for (var i = 1; i < 5500; ++i)
            {
                integerSequence.Add(i);
                var expected = (i + 1) / 2.0;
                var actual   = target.Run <double>(
                    integerSequence,
                    blockNumber,
                    (j, k) => j / (double)k,
                    (d1, d2) => d1 * d2);
                Assert.IsTrue(Math.Abs(expected - actual) < 0.001);
            }

            var n = 1000500;

            for (var i = 5500; i <= n; ++i)
            {
                integerSequence.Add(i);
            }

            var outerExpected = (n + 1) / 2.0;
            var outerActual   = target.Run <double>(
                integerSequence,
                blockNumber,
                (j, k) => j / (double)k,
                (d1, d2) => d1 * d2);

            Assert.AreEqual(outerExpected, outerActual);

            var integerDomain = new BigIntegerDomain();
            var fractionField = new FractionField <BigInteger>(integerDomain);
            var fracTarget    = new ListGeneralizedMeanAlgorithm <int, Fraction <BigInteger> >(
                i => new Fraction <BigInteger>(i, 1, integerDomain),
                d => d,
                (d, i) => d.Divide(i, integerDomain),
                fractionField);

            var fractionExpected = new Fraction <BigInteger>(n + 1, 2, integerDomain);
            var fractionActual   = fracTarget.Run <Fraction <BigInteger> >(
                integerSequence,
                blockNumber,
                (j, k) => new Fraction <BigInteger>(j, k, integerDomain),
                (d1, d2) => d1.Multiply(d2, integerDomain));

            Assert.AreEqual(fractionExpected, fractionActual);

            // Teste com alteração da função directa
            fracTarget.DirectFunction = i => new Fraction <BigInteger>(new BigInteger(i) * i, 1, integerDomain);
            fractionExpected          = new Fraction <BigInteger>(
                (new BigInteger(n) + BigInteger.One) * (2 * new BigInteger(n) + 1), 6, integerDomain);
            fractionActual = fracTarget.Run <Fraction <BigInteger> >(
                integerSequence,
                blockNumber,
                (j, k) => new Fraction <BigInteger>(j, k, integerDomain),
                (d1, d2) => d1.Multiply(d2, integerDomain));

            // Teste com transformação
            var transformedTarget = new ListGeneralizedMeanAlgorithm <BigInteger, Fraction <BigInteger> >(
                i => new Fraction <BigInteger>(i, 1, integerDomain),
                d => d,
                (d, i) => d.Divide(i, integerDomain),
                fractionField);
            var transformedSeq = new TransformList <int, BigInteger>(
                integerSequence,
                i => new BigInteger(i) * i);
            var transformedExpected = new Fraction <BigInteger>(
                (new BigInteger(n) + BigInteger.One) * (2 * new BigInteger(n) + 1), 6, integerDomain);
            var transformedActual = transformedTarget.Run <Fraction <BigInteger> >(
                transformedSeq,
                blockNumber,
                (j, k) => new Fraction <BigInteger>(j, k, integerDomain),
                (d1, d2) => d1.Multiply(d2, integerDomain));

            Assert.AreEqual(transformedExpected, transformedActual);
        }
Exemplo n.º 9
0
        public void Statistcs_ListGeneralizeMeanAlgorithmTest()
        {
            var target = new ListGeneralizedMeanAlgorithm <int, double>(
                i => i,
                d => d,
                (d, i) => d / i,
                new DoubleField());

            var integerSequence = new List <int>();

            for (var i = 1; i < 5000; ++i)
            {
                integerSequence.Add(i);
                var expected = (i + 1) / 2.0;
                var actual   = target.Run(integerSequence);
                Assert.AreEqual(expected, actual);
            }

            var n = 1000000;

            for (var i = 5000; i <= n; ++i)
            {
                integerSequence.Add(i);
            }

            var outerExpected = (n + 1) / 2.0;
            var outerActual   = target.Run(integerSequence);

            Assert.AreEqual(outerExpected, outerActual);

            var bigIntegerDomain = new BigIntegerDomain();
            var fractionField    = new FractionField <BigInteger>(bigIntegerDomain);
            var fractionTarget   = new ListGeneralizedMeanAlgorithm <int, Fraction <BigInteger> >(
                i => new Fraction <BigInteger>(i, 1, bigIntegerDomain),
                d => d,
                (d, i) => d.Divide(i, bigIntegerDomain),
                fractionField);
            var fractionExpected = new Fraction <BigInteger>(n + 1, 2, bigIntegerDomain);
            var fractionActual   = fractionTarget.Run(integerSequence);

            Assert.AreEqual(fractionExpected, fractionActual);

            // Teste com alteração da função directa
            fractionTarget.DirectFunction = i => new Fraction <BigInteger>(new BigInteger(i) * i, 1, bigIntegerDomain);
            fractionExpected = new Fraction <BigInteger>(
                (new BigInteger(n) + BigInteger.One) * (2 * new BigInteger(n) + 1), 6, bigIntegerDomain);
            fractionActual = fractionTarget.Run(integerSequence);
            Assert.AreEqual(fractionExpected, fractionActual);

            // Teste com transformação
            var transformedTarget = new ListGeneralizedMeanAlgorithm <BigInteger, Fraction <BigInteger> >(
                i => new Fraction <BigInteger>(i, 1, bigIntegerDomain),
                d => d,
                (d, i) => d.Divide(i, bigIntegerDomain),
                fractionField);
            var transformedSeq = new TransformList <int, BigInteger>(
                integerSequence,
                i => new BigInteger(i) * i);
            var transformedExpected = new Fraction <BigInteger>(
                (new BigInteger(n) + BigInteger.One) * (2 * new BigInteger(n) + 1), 6, bigIntegerDomain);
            var transformedActual = transformedTarget.Run(transformedSeq);

            Assert.AreEqual(transformedExpected, transformedActual);
        }