Go Home Kelsey – Alpha

Download For Windows!

Download For Linux!

Download For Mac!

By: Ben Johnson

Description

Go Home Kelsey is a simple 2D platformer I created for my friend Kelsey. The game features her running through the streets of China dodging the romantic advances made by strangers. Since this game is currently in alpha stages, only infinite run mode is available. At the moment there is only one enemy type which behaves like a hazard that must be avoided. The game also features a simple shop which the player can buy upgrades from during gameplay.

 

Controls

  • Space Bar – Jump
  • Left Mouse Button – Attack (when unlocked)

Prometheus Alpha Build

Play! – 0% Mastered

Play! – 50% Mastered

Play! – 100% Mastered

By: Ben Johnson

Description

Prometheus is a Japanese language learning game which teaches the player by teaching them new words and quizing them while they participate in combat. The game is currently in alpha stages and a few of the subsystems (such as movement) are in dire need of reworking. My plan is to migrate the game out of Unity and into Ogre3D after alpha testing has been completed and the story is further along.

 

Controls

  • Arrow/WASD keys – Move character
  • Mouse – Look
  • Mouse Wheel – Zoom
  • Space – Jump
  • E – Open PDA (out of combat only)
  • 1 – Use psy blast skill (in combat only)

 

 

Updates For Spider Swarm

Play!

By: Ben Johnson

Description

In preparation for creating my first video game trailer, I have updated some of the visual aspects for Spider Swarm to hopefully produce a better video without lying about the gameplay. While I am sure it would  have been much easier to just take the environment models and use Blender to make a full CGI trailer like many games do now a days, it felt a lot like lying to me if the footage show was not something you could actually expect to happen in gameplay. As a gamer I personally hate when games try to pull this cheap trick of not showing you what the real game is and instead just glossing it over with something mildly related. Hopefully with these updates I will be able to create a fun an interesting demo trailer to post here in the coming weeks. Thankfully most of the visual changes we possible due to the animations that came pre-made for the fantasy spider model in the Unity asset store.

 

Change Log

  • Added a basic muzzle flash for the rifle.
  • When spawning enemies burst out of the ground.
  • When dying enemies sink back into the ground after their death animation is finished.
  • Enemies now have hit animations (2 unique ones) and hit sound effects (2 unique ones).
  • Enemies now have an additional death animation and more death sound effects.
  • Enemies now have an additional attack animation and more attack sound effects.
  • Rest period now has a count down timer to keep player ready for incoming spiders.
  • Spiders are a little less likely to climb on top of each other in large numbers.
  • Spiders now use a third spawn zone.
  • Spiders now spawn in smaller groups rather than all at once per wave.
  • Added small ammo pack in the beginning of the scene.
  • Axe now uses a sound effect when swung.
  • Attacks no longer loop instantly, they now wait for their animation/sound to finish before looping.
  • Added different music for both battling and resting. Note that the battling music is from the video game Pain Killer and is not mine.
  • Lowered player max hp to 200 as the rifle makes things too easy for 500.
  • Lowered ammo boost from ammo boxes to only grant 15 shots.

 

Controls

  • W, A, S, D – Move player.
  • Q – Switch weapons
  • Mouse – Aim/Look
  • Left Mouse Button – Attack
  • Space – Jump

Beach Goblin

Description

In an attempt to learn a new character modeling process I began working on this character using instructions provided from my teacher Alex Meyers. While his approach to character modeling is quite different from my own and did not work out perfectly for me, I was pretty satisfied with the resulting character I had created. The character below is based on some reference images I got through a random google search. Besides the initial reference images, I handled the modeling, texturing, and animation on my own. I also followed along with the Boids Particle System tutorial created by “The D-dub Show” to create the goblin horde animation.

Animations

Walk Cycle

Horde Goes to the Beach

Images

Tim and Elizabeth

Description

In hopes of further improving my modeling skills I decided to cruise on over to YouTube and watch some tutorial videos. It was there that I stumbled upon the very talented D-Dub Show and his excellent tutorial series about making a Tim Burton style character in Blender. While unfortunately I had some trouble here and there with things like the hair particle system which apparently hated my characters eye brows (if I didn’t add the modifier in the incorrect order the hair would always appear on the models teeth) and character conversion (for some reason changing Tim’s base modeling into Elizabeth caused the entire rigging system to break) I think everything came out quite well. Unfortunately since Elizabeths rig completely broke I was unable to mover her around in the final renders so while she still works in her own file (not pictured here) she is pretty boring when hanging out with Tim (no only because of his creepy suspicious look).

While working on this series I learned a lot about modeling including facial animation, rigging, texture painting, clothing creation, and much much more. I highly recommend the Tim Burton Style character video to anyone who may be unfamiliar with character modeling in Blender and is willing to deal with Blenders seemingly endless list of bugs.

Images

Anime Girl

Description

While experimenting with character design ideas for a game I am working on I decided to try a quick design exercise and googled reference images for characters. While filtering through the numerous results I eventually found an interesting pencil sketched charactered that I decided I wanted to reproduce. After downloading the image I immediately began modeling and sculpting until I eventually had a pretty accurate reproduction of the base character. Sadly it was at this point I began modeling the clothing and my fears were realized, I had accidently modeled an anime school girl. Regretfully it was a bit late in the design process to change the character and I was too busy the sketch new clothing for someone elses image (not to mention I am not exactly good a drawing characters) so I pushed on. The both fortunate and unfortunate result is below. This quick exercise in modeling taught me one valuable lesson, make sure you know what you are modeling before you start, otherwise you have a lot of awkward explaining to do when you finish.

Images

Serial Plane Cat

Description

While trying my best to recreate an anime cat named Chi (pictured below), I was assigned the task of creating a serial plane structure for class. Immediately I was reminded of those old wooden 3D T-Rex puzzles where you have to put together the planes on a metal stand to make the T-Rex skeleton and decided to adjust my model using boolean modifiers to create the same effect on the cat. While the original model has yet to be finished (I haven’t had much time to adjust the rigging or create a texture) I do plan on one day using a non-serial planed version of this model as a template object for games (maybe as an enemy, NPC, or even a character).

Images

Swarm

Play!

By: Ben Johnson

Description

Swarm is a simple game where a player is trapped in a graveyard with nothing more than a gun, an axe, and an endless horde of spiders to fight. In the game you start with no ammo and must fight with your axe until the spiders begin dropping ammo packs, but beware as the spiders will fight back if you get to close to them. While this game may seem simple, it was designed as a test for using the built in Unity FPS controller with a basic weapon system. Using the scripts created for this program it would be relatively simple to create an FPS game with multiple weapons, ammo types, and abilities. All assets used in this game are not my property and were taken from the Unity store. You can find them all under the free assets sections.

Known Bugs

  • In order to pick up both weapons you must first pick up one, hit q to switch to the empty slot, and the you can pick up the other.
  • Gun is missing a muzzle flash. While it would not be hard to add one, I’ve moved on from this project as it was just a test and I’d rather not continue tweaking it unless it is a major fix.

Controls

  • W, A, S, D – Move player.
  • Q – Switch weapons
  • Mouse – Aim/Look
  • Left Mouse Button – Attack
  • Space – Jump

Images

The Great Rhombicuboctahedron

Description

While in an elementary 3D modeling course I came across this confusing disaster of a polyhedron is called the great rhombicuboctahedron which essentially means “super complex shape that no one will ever use of any sane reason ever”.  For a course assignment I decided to recreate this shape in blender as it seemed to be not only one of the most complicated shapes in art but also that it might have some uses in an RPG game or possibly even an FPS (similar to the cube in Doom 3). While I have no immediate use for this shape I am still hoping that I can either find a way to incorporate it into a game I am working on in a way that makes or that someday someone else will either suggest to me or find a use for this monstrosity.

Images

Camera Relative Movement

Description

In many older 3D games (such as Mario 64 and the Legend of Zelda: Ocarina of Time)  for consoles like the N64 and Playstation games used a simple movement scheme called camera relative movement. In camera relative movement the player moves according to where the camera is. For example if the player holds the left button, the players avatar will run to the left in a circle around the camera. Using the two C# scripts at the bottom of this post you can do the same in just about any Unity project so long as you assign the proper variables and create the scripts necessary to interact with the player. An example of these scripts in action can be found at: Adventure Game Test.

Code

CameraRelativeMovement.cs

using UnityEngine;
using System.Collections;

public class CameraRelativeMovement : MonoBehaviour
{
    public Transform targetCamera;
    public Transform lookAtTarget;
    public Transform watchTarget;        
    public float forwardDirection;
    public float sideDirection;
    public float maxSpeed = 10.0f;        

    private CharacterMovement movement;
    private Transform myTransform;

    // Use this for initialization
    void Awake()
    {
        myTransform = transform;
        movement = GetComponent<CharacterMovement>();
    }

    // Update is called once per frame
    void Update()
    {
        Vector2 input = new Vector2(sideDirection, forwardDirection);
        float speedScale = input.magnitude;

        if (speedScale > 1.0f)
        {
            speedScale = 1.0f;
        }

        Vector3 moveRequest = GetMovementRequest(input);

        if (lookAtTarget != null)
        {
             Vector3 direction = lookAtTarget.position - transform.position;
             direction.y = 0.0f;
             movement.RequestRotateTowards(direction.normalized);
        }
        else
        {
             movement.RequestRotateTowards(moveRequest.normalized);
        }

        if (watchTarget != null)
        {
            movement.RequestWatch(watchTarget.position);
        }
        else
        {
            movement.RequestWatch();
        }

        movement.RequestMovement(moveRequest, speedScale * maxSpeed);
    }

    private Vector3 GetMovementRequest(Vector2 input)
    {
        Vector3 forward = myTransform.position - targetCamera.position;
        Vector3 right = Vector3.Cross(myTransform.up, forward);
        Vector3 moveRequest = input.y * forward + input.x * right;
        moveRequest.y = 0;
        return moveRequest;
    }
}

CameraMovement.cs

using UnityEngine;
using System.Collections;
public class CameraMovement : MonoBehaviour
{
    public float movementDamping = 5.0f;
    public float rotationDamping = 5.0f;

    private Transform myTransform;

    // Use this for initialization
    void Awake()
    {
        myTransform = transform;
    }

    public void SpringToTarget(Transform target, float preferredDistance, float preferredHeight)
    {
        float distance = Vector2.Distance(new Vector2(target.position.x, target.position.z),
                                          new Vector2(myTransform.position.x, myTransform.position.z));
        Vector3 moveDirection = target.position - myTransform.position;
        moveDirection.y = 0.0f;
        moveDirection = moveDirection.normalized * (distance - preferredDistance) + myTransform.position;
        moveDirection.y = target.position.y + preferredHeight;
        MoveToPosition(target.position, moveDirection);
    }

    public void SpringToTargetWithConstantOffset(Transform target, float preferredDistance, float preferredHeight)
    {
        float distance = Vector2.Distance(new Vector2(target.position.x, target.position.z),
                                          new Vector2(myTransform.position.x, myTransform.position.z));
        float z = Mathf.Sin(myTransform.rotation.y) * distance;
        float x = Mathf.Cos(myTransform.rotation.y) * distance;

        Vector3 moveDirection = new Vector3(x, 0, z);
        moveDirection.y = 0.0f;
        moveDirection = target.position - moveDirection.normalized * preferredDistance;
        moveDirection.y = target.position.y + preferredHeight;
        MoveToPosition(target.position, moveDirection);
    }

    // returns true if camera is pretty much behind the target
    public bool MoveBehindTarget(Transform target, float preferredDistance, float preferredHeight)
    {
        Vector3 moveDirection = target.forward;
        moveDirection.y = 0;
        moveDirection = moveDirection.normalized * -preferredDistance + target.position;
        moveDirection.y += preferredHeight;
        MoveToPosition(target.position, moveDirection);
        return (myTransform.position - moveDirection).magnitude < 0.5f;
    }

    public void RotateAroundPoint(Vector3 target, float rotation)
    {
        Vector3 forward = myTransform.position - target;
        Vector3 right = Vector3.Cross(myTransform.up, forward);
        float distance = Vector3.Distance(myTransform.position, target);

        Vector3 targetPosition = forward + right * rotation;
        targetPosition = targetPosition.normalized * distance;
        targetPosition.y = myTransform.position.y;
        targetPosition.x += target.x;
        targetPosition.z += target.z;
        MoveToPosition(target, targetPosition);
    }

    public void LookAtTarget(Vector3 direction)
    {
        transform.rotation = Quaternion.Slerp(myTransform.rotation, Quaternion.LookRotation(direction), rotationDamping * Time.deltaTime);
    }

    private void MoveToPosition(Vector3 lookAtTarget, Vector3 targetPosition)
    {
        Vector3 direction = (targetPosition - lookAtTarget).normalized;
        float distance = Vector3.Distance(lookAtTarget, targetPosition);

        RaycastHit hit;
        if (Physics.Raycast(lookAtTarget, direction, out hit, distance) &&
            (hit.collider.CompareTag("Wall") || hit.collider.CompareTag("Door")))
        {
            myTransform.position = Vector3.Lerp(myTransform.position, hit.point, movementDamping * Time.deltaTime);
        }
        else
        {
            myTransform.position = Vector3.Lerp(myTransform.position, targetPosition, movementDamping * Time.deltaTime);
        }
    }
}