//In a static class that holds all the Config objects

public static RichTextConfig RTSkyCellStat = new RichTextConfig() {

    ShadowColor = G.Colors.Dark,

    OutlineColor = G.Colors.Dark,

    OutlineThickness = 3,

    CharColor = G.Colors.Light,

    ShadowY = 3,

    Font = Assets.FontHud,

    MonospaceWidth = 16,

    FontSize = 28

};

public RichText TextHealth = new RichText("600", Config.RTSkyCellStat);

var wave2 = new EnemyWaveProperties()

        .Add(typeof(EnemyBitty))

        .SpawnFrom(1)

        .Add(typeof(EnemyBitty))

        .SpawnFrom(0)

        .Delay(120)

        .Add(typeof(EnemyPopcorn))

        .SpawnFrom(1)

        .Add(typeof(EnemyPopcorn))

        .Delay(120)

        .SpawnFrom(0)

        .Add(typeof(EnemyBitty))

        .Add(typeof(EnemyBitty))

        .Add(typeof(EnemyBitty));



EncounterManager.AddAction(new EncounterActionEnemyWave(wave2));

public override void Execute() {

    foreach(var wave in properties.Waves) {

        var spawner = EnemySpawner.GetSpawnerById(wave.SpawnerId);



        foreach (var waveEnemy in wave.Enemies) {

            if (Spawning) {

                if (Timer == waveEnemy.SpawnDelay) {

                    var enemy = spawner.Spawn(waveEnemy.EnemyType);

                    EnemiesSpawned.Add(enemy);

                    SpawnedFirstEnemy = true;

                }

            }

        }

    }



    if (Timer >= properties.MaxSpawnDelay) {

        Spawning = false;

    }



    if (WaitForClear && SpawnedFirstEnemy) {

        var enemiesDead = true;

        foreach (var enemy in EnemiesSpawned) {

            if (enemy.IsInScene) { // Enemy is still alive

                enemiesDead = false;

            }

        }

        if (enemiesDead) {

            Finished = true;

            EnemiesSpawned.Clear();

        }

    }

    else {

        if (Timer >= Time) {

            Finished = true;

        }

    }



    Timer++;

}

#version 120

uniform sampler2D texture;

uniform sampler2D noiseTexture;

uniform vec4 overlayColor;

uniform vec4 additiveColor;

uniform vec4 subtractiveColor;

uniform float overlayNoise;

uniform float inverted;

uniform float noiseX;

uniform float noiseY;



void main() {

	//get color of this pixel

	vec2 pixpos = gl_TexCoord[0].xy;

	vec4 pixcol = texture2D(texture, pixpos);



	vec4 outcol = abs(inverted-pixcol);

	outcol.a = pixcol.a;



	//mix in the overlay color

	outcol = mix(outcol, overlayColor, overlayColor.a);



	//add the additive color

	outcol += additiveColor * additiveColor.a;



	//subtract the subtractive color (DUH)

	outcol -= subtractiveColor;



	vec4 noiseColor = texture2D(noiseTexture, mod(pixpos, 1) + vec2(noiseX, noiseY));

	outcol = mix(outcol, noiseColor, overlayNoise);



	//reset alpha to prevent coloring transparent pixels

	outcol.a = pixcol.a;



	//output the final color

	gl_FragColor = outcol;

}

//Handle graphics

foreach (var img in Images) {

    var overlay = Util.ScaleClamp(StunEffect, 0, StunEffectMax, 0, 0.5f);

    var color = new Color(Color.Black) { A = overlay };

    var addColor = new Color(StunColor) { A = overlay };



    img.Shader.SetParameter("overlayNoise", overlay * 0.5f);

    img.Shader.SetParameter("noiseX", Rand.Float(0, 0.25f));

    img.Shader.SetParameter("noiseY", Rand.Float(0, 0.25f));



    if (StunEffect > StunEffectMax * 0.25f) {

        addColor.A = 0.5f;

        color = G.Colors.Dark;

        color.A = 0.25f;

        img.Shader.SetParameter("inverted", StunEffect % 4 > 1 ? 1 : 0);

    }

    else {

        img.Shader.SetParameter("inverted", 0);

    }



    img.Shader.SetParameter("overlayColor", color);

    img.Shader.SetParameter("additiveColor", addColor);



    img.Shake = Util.ScaleClamp(StunEffect, 0, StunEffectMax, 0, 30);

}

//set up the surface

public Surface SurfaceLighting = new Surface(Game.Instance.Width, Game.Instance.Height, new Color("379")) {

    Blend = BlendMode.Multiply

};



//set up the light

public Image ImageLight = new Image(Assets.ImageLight1) {

    Blend = BlendMode.Add

};



//add the surface to an entity to render it

//this happens in an object's initialization

AddGraphicGUI(SurfaceLighting);



//render light to the surface

//this happens in a Render() function

Draw.SetTarget(SurfaceLighting);

ImageLight.Color = Color.White;

Draw.Graphic(ImageLight, Input.MouseX, Input.MouseY);

ImageLight.Color = Color.Red;

Draw.Graphic(ImageLight, Input.MouseX + 500, Input.MouseY);

ImageLight.Color = Color.Blue;

Draw.Graphic(ImageLight, Input.MouseX - 500, Input.MouseY);

Draw.ResetTarget();

public virtual void PushAway() {

    if (Hitbox != null) {

        if (Overlap(X, Y, (int)Tags.Enemy)) {

            var e = Overlapped as Enemy;

            if (e.Mass >= Mass) {

                var push = new Vector2(X - Overlapped.X, Y - Overlapped.Y);



                if (push.X == 0 && push.Y == 0) {

                    push = new Vector2(Rand.Float(-1, 1), Rand.Float(-1, 1));

                }



                push.Normalize(pushAwayForce);

                pushAwaySpeed += push;

            }

        }

    }



    var length = Util.Approach((float)pushAwaySpeed.Length, 0, pushAwayForce * 0.5f);



    pushAwaySpeed.Normalize(length);





    X += (float)pushAwaySpeed.X * 0.01f;

    Y += (float)pushAwaySpeed.Y * 0.01f;

}

using Otter;

using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;



namespace CoroutineExample {

    class CoroutineScene : Scene {



        public Image ImageBox = Image.CreateRectangle(50);



        public Color NextColor = Color.White;

        public Color CurrentColor = Color.White;



        public CoroutineScene() : base() {

            // Center that box.

            ImageBox.CenterOrigin();



            // Gotta draw the box.

            AddGraphic(ImageBox);



            // Set the box position.

            ImageBox.X = 100;

            ImageBox.Y = 100;

        }



        public override void Begin() {

            base.Begin();



            // Start the coroutine, yo.

            Game.Coroutine.Start(MainRoutine());

        }



        /// <summary>

        /// The main coroutine to execute.  This will move the box around and change its color.

        /// </summary>

        /// <returns>Whatever a coroutine thing returns.  Sometimes 0 I guess.</returns>

        IEnumerator MainRoutine() {

            // Wait for 30 frames.

            yield return Coroutine.Instance.WaitForFrames(30);

            // Set the next color.

            NextColor = Color.Red;

            // Move the box to the top right.

            yield return MoveBoxTo(540, 100);



            // Wait for 30 frames.

            yield return Coroutine.Instance.WaitForFrames(30);

            // Set the next color.

            NextColor = Color.Yellow;

            // Move the box to the bottom right.

            yield return MoveBoxTo(540, 380);



            // Wait for 30 frames.

            yield return Coroutine.Instance.WaitForFrames(30);

            // Set the next color.

            NextColor = Color.Green;

            // Move the box to the bottom left.

            yield return MoveBoxTo(100, 380);



            // Wait for 30 frames.

            yield return Coroutine.Instance.WaitForFrames(30);

            // Set the next color.

            NextColor = Color.Cyan;

            // Move the box to the top left.

            yield return MoveBoxTo(100, 100);

            

            // Start a new coroutine.

            Game.Coroutine.Start(MainRoutine());

        }



        IEnumerator MoveBoxTo(float x, float y) {

            // Used to determine the completion.

            var initialDistance = Util.Distance(ImageBox.X, ImageBox.Y, x, y);



            float currentDistance = float.MaxValue;

            while (currentDistance > 1) {

                currentDistance = Util.Distance(ImageBox.X, ImageBox.Y, x, y);



                // Determine the completion of the movement from 0 to 1.

                var completion = Util.ScaleClamp(currentDistance, 0, initialDistance, 1, 0);



                // Lerp the color of the box.

                ImageBox.Color = Util.LerpColor(CurrentColor, NextColor, completion);



                // Spin the box along with its movement.

                ImageBox.Angle = Util.ScaleClamp(completion, 0, 1, 0, 360);



                // Actually move the box.

                ImageBox.X = Util.Approach(ImageBox.X, x, 5);

                ImageBox.Y = Util.Approach(ImageBox.Y, y, 5);



                // Wait until next frame.

                yield return 0;

            }



            // Done moving.  Update the color.

            CurrentColor = NextColor;

        }

    }

}