7DFps - End of Day 7 (End of Challenge)

So I kinda skipped a few inbetween days since last update.

In the end, I have a playable prototype (which I have fun playing :) ), although far from a complete polished game, and didn't quite manage to reach my original design.

Using Unity, I could quickly see the game improving at each passing day, which was very motivating.

Since the last post, I added enemy AI and generation, level generation, different weapons, buttons that activate doors/lights and stairs.

I spent a lot of time trying to have levels be fully procedurally generated in code, but gave up and created 3d meshes in a 3D modelling software (Wings3D), which I then imported into Unity and used to manually assemble into the final level.

It's missing sound, intro and outro screens, an end condition, better enemy and level design, and general polish, but I think it's fun to play :)


Windows Download: https://www.dropbox.com/s/x9u3c4stqj35rud/The%20Ivory%20Halls.zip
Mac Download: https://www.dropbox.com/s/ebza27yijwh2eyc/The%20Ivory%20Halls%20-%20Mac.app.zip

7DFps - End of Day 3

This is a daily diary I will keep for my "7 Day First Person Shooter" challenge entry.

This is the current state for the end of Day 3:



Since the last post, I worked on adding player collision against the world. I initially choose to integrate a java physics library.

Since I wasn't familiar with the Bullet physics library, I didn't know how to integrate it nor did I know how it would perform in the kind of environment I'm aiming to create (a procedural level that will have dynamic loading and unloading of geometry). I realized that it wouldn't be a good idea to have to deal with learning the library's api, implementing and debugging in such a short time. I briefly considered implementing a simple collision system using swept spheres, but that would also take considerable time and energy debugging. I finally decided to leave Java and Lwjgl, and go back to one of the solutions I've considered before (between Unity and Blender Game Engine, I chose to go with Unity, since I already had a prototype working before the challenge began), thus ditching shadows and visual effects (since I'm working with Unity free).

In that prototype I had Unity's default first person controller, to which I added a general shooting mechanic (raycasting, adding randomness to shots and a delay between shots), logic for a machine gun, rendering a mesh to show the shot tracers, a weapon position to fire from and a cylinder to visually show it, and a particle system that spawns where each shot hits.

From that, I added code to dynamically generate a room mesh (now, simply a cube, with corresponding physics, created in Javascript code using a new GameObject, and adding the MeshFilter, MeshRenderer and MeshCollider components, and setting the MeshCollider and MeshFilter's Mesh to the one I created, by setting its "vertices", "triangles" and "uv", and the meshFilter's "material" variables).

Today I'll add enemy logic: generation, spawning, and attacking the player.

7DFps - End of Day 1

Today I did mostly code organization (to allow me to define separate objects with individual shaders, spatial transforms, and that access a single array, and encapsulate OpenGL calls into simpler ones). With this in place, designed a placeholder room with the polygons colored using vertex colors gradients.

Started looking at libraries for collision detection and physics in 3d, using Java. Will experiment with JBullet first, also considering ode4j as an alternative.

Tomorrow i'll add physics to the camera's movement (be blocked by the world's obstacles and respond to gravity), and allow detecting "shooting" of objects (using raycasting in the physics engine's collision detection).

Made in Java + Netbeans + LWJGL library (with help from LibGDX)

7DFPS - Intro Post

Hi, I've decided to enter the "7 Day First Person Shooter" challenge at 7dfps.org, with a project called "The Ivory Halls". Here's the introductory post (video is below):


As soon as I heard about the competition (a few weeks ago), I thought that it would be a great challenge, and started designing the game and doing "pre-production" work -checking tools, languages, libraries, that would allow the implementation of that design.


Game design:
The game was specifically designed to be fully implementable in a week, by including gameplay mechanics easy to implement, but where complexity can be added, allowing for  evolution as the player progresses through the game, and giving him choices on how to play the game.


The design also included relegating the tasks that take the most time when producing a 3d game - asset creation (modelling/uv unwrapping, texturing, animating, and level design) - to a minimum, relying mostly on combining basic geometric shapes for the models and levels, doing animations based on combinations of translations,rotations and scales, and keeping textures clean (procedurally generated) or not using any, relying mostly on graphics card shaders for the visual look.


Technology:
During the pre-production phase, I've been searching for technologies that would allow me to make the game, with the main features I wanted in it (3D, procedural mesh generation, real time lighting and shader effects, basic physics, particle effects) in the quickest/easiest/most productive way possible. There was a focus on using open-source or free software, or software with demo versions.


I looked at the Unity 3D engine, which allowed for quickly developing a prototype, has good documentation and community, and is one of the most non-programmer friendly game development tools, but the free version did not allow for the use of shaders for effects such as real-time shadows and lighting, so I set it aside, looking for alternatives that would provide that feature.


I tried Blender Game Engine (which is run from inside the Blender application), which I found to be very powerful and underrated as a game development tool (allowing for lots of the sophisticated shader effects I was looking for, and being fairly easy to use, with a drag-and-drop programming style good for non-programmers), but the fact that I could not dynamically add meshes during the Game Engine execution (only use meshes previously created), and the fact that it uses Python which I dislike, made me keep looking.


Having experience and preference for developing using Java (in the Netbeans IDE), I looked at JMonkeyEngine. Very advanced with lots of features and with tutorials and code that makes it easy to start developing an FPS, but I was having problems with updates for the main platform that were supposedly the stable version, but that broke previously working features and were poorly documented, so I got tired of it and moved on.


My next stop was going closest to the metal: LWJGL - a low-level library that allows the use of OpenGL in Java (I'd rather avoid going low-level into straight programming, instead using productivity applications, but found little niggles in the options that I considered previously). I also thought it would be challenging to finally learn about the recent OpenGL API design, named "OpenGL Core", which is more complex than the previous "Immediate mode" but allows for lots of creativity. Hoping that this still allows me to develop a game in the time allotted


I will be posting a short video and report at the end of each day with what I've got completed so far. By today, I've got a simple 3d camera with first person controls, no gravity, and a couple of triangles with basic shaders: 

Thanks for visiting!

Baroque Demon Pinball - Dailies

When a Hell Knight is hit, it explodes in a cloud of green dust.

 

Baroque Devil Pinball - Early art

I'm excited about Stencylworks, it matches my vision of where programming is going in a few years.

I started working on a Pinball game I've been thinking about for a while, here's some early art:

Vector Editor - Progress update

Uploaded a couple more videos:


This one shows the grid of points created inside the shape to later do tesselation (decompose the inside of the shape into polygons), which will be shaded using vertex colors, smoothly interpolating the colors between each vertex.

The shape is built using Java's GeneralPath, the control point coordinates are converted from Catmull-Rom to Bezier using a matrix.



This shows color interpolation for those inner points, using an algorithm that I created. Works nicely for any points in any position, even for points inside the shape (which in the literature I managed to find, presented a problem for most interpolation algorithms when dealing with polygons). I'm quite happy with the solution! :)