I moved to a new URL! Check it out!

posts dated from: april 2014

Dev Log: Quick Lighting Test

Dev Log: Quick Lighting Test
As a quick experiment I wanted to see how Otter would be equipped to handle a simple lighting set up. The basic set up is just a big render texture that is filled with a dark color with a blend mode set to multiply. Then light is rendered to the render texture with a blend mode of additive. The result is a layer of shadow that can have light rendered to it.

Image


The code for this set up right now is pretty straight forward as well. I'm using a black and white image for the light. Just a black rectangle with a white radial gradient in the center.

Here's some sample code to show how this effect is achieved with Otter!
//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();
otter dev log gamedev programming csharp
Posted April 16th 2014 4:58 PM (General)
4 Comments

Doodle Post

Image
doodles
Posted April 11th 2014 2:05 PM (Doodle)
No Comments

Dev Log: Pathfinding Fun

Image


Like a cat chasing a laser pointer, I have some basic enemies chasing paths through the skies.

Right now I'm using A* and although I don't really know what is going on that much, I have a system that enemies can use to find paths to their destinations. Normally I wouldn't bother with any sort of path finding, but for this game I want enemies to have to intelligently navigate through obstacles that the player is deploying, so my usual "make up a path finding function that doesn't actually path find but sometimes works out" function wont cut it.

What I have currently is a pretty straight forward set up:
- One PathFinder instance in my Scene. It extends Entity so that it can be updated by the scene automatically.
- Enemies request a path from PathFinder and also register a callback Action with the request.
- The PathFinder instance adds the request to the queue.
- Every update the PathFinder will take the top item of the queue and start the path finding process.
- The actual A* algorithm and calculations are run on a BackgroundThread so that the game can continue while this is going on.
- When the path is done calculating the callback is fired, and the enemy now knows about its path.
- It chases down the nodes that were added to its path.

I made a quick change to the A* algorithm as well under the sage advice of Chevy Ray: I'm using a maximum movement value that will stop the algorithm if the move costs become too high. The result is that the algorithm will return a partial path to the final target instead of the entire path (which could take a long time to calculate in a set of nodes with a lot of open spaces.) So with this in mind the rest of my logic looks like this:

- When the enemy reaches the last node, it checks to see if its close to its intended target.
- If not it requests a new path to its target.
- If it is then it will enter its attack behavior, whatever that is.

So far this seems to be working out pretty well. I have a lot of work to do with how enemies will end up treating their path nodes in regards to their actual movement. Right now they just try to move toward each node, but with a lot of nodes together they end up having some trouble, like that wiggling in the animation above. Something like an averaged out path between a lot of nodes might work better... hmm!
gamedev dev log programming stratoforce
Posted April 9th 2014 4:11 AM (General)
4 Comments

Doodle Post

Image
doodles
Posted April 4th 2014 10:06 AM (Doodle)
No Comments

Doodle Post

Image
doodles
Posted April 2nd 2014 7:13 PM (Doodle)
3 Comments

Dev Log: Anti-clumping Made Easy

Image


Starting to get back into a bit of a groove on this game thing. One little fun thing to work on was the enemy anti-clumping code. I don't want any enemies to stack on top of each other (although it would be smart of them to do so in order to conceal their numbers.) With a short bit of code I can have enemies push each other away, similar to how babies and rocks push away from each other in Offspring Fling.
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;

}
Pretty neat! This is actually pretty similar to the original code in the prototype many many years ago, except now it's in fancy C# instead of GML. Enemies will call PushAway() every update.
dev log gamedev csharp programming
Posted April 2nd 2014 11:24 AM (General)
No Comments
« newer posts
older posts »