DirectX based Game:

9/24/2015: Major updates:

Since last time, I've decided to switch back to 2D. I am still using C++ and DirectX to make my game, and now it's sort of a tactical combat based game. I have a bit to show for, but since I will probably put these previous updates into archive, I won't quite post everything right at the moment. Stay tuned!

2/5/2015: Hammers

    I have been working on this project since the last update, but instead of writing here I have been posting a lot of photos to Facebook. Since last time, I have added support for maps created with the Hammer editor (made by Valve). There's still a lot of work to be done in this area, but as long as the geometry is simple I currently can make it work.

Here's some photos!: (Click to enlarge, some are rather big)

(Above: My first test in the edtiror. Seems to work!)

(Above: I found some bugs in texturing, and fixed them. A texture like this is really helpful in finding those sort of bugs).

(Above: My first multi-textured map. Since I don't use Valve's textures, I made it randomly select from some of mine. This is also a test of a more complex map, which worked as well).

(Above: Here's some point lighting in HLSL. The light is at the same position as the cube, and the HLSL controls the lighting effect on the valve map. You can also see instead of randomizing textures, I unified them based on the names used in the Hammer editor).

    That's about it for now, next coming up I'll have more info about the HLSL, sound, and other stuff. Thanks for reading!

10/13/2014: A large update:

It's been a long while since I've updated this page. Let's fix that!

    Since last time, a lot has happened. A whole semester of projects came and went, and boy were they time consuming. Even now, I've got projects, but nothing like last semester. That was really something. I was still working on this (very briefly) during the semester. I have photos dated spring through summer, so I thought I'd get the old stuff out of the way before moving on to new topics. These are actually dated as last November, apparently these were dark times, when I didn't know how to push the 'print screen' key...



As shown above, when I was working in C# using managed DirectX I was still able to work out a lot of the technical implementations regarding terrain and dungeon generation. There was also a bit of HLSL bump mapping and other shader effects going on. Good stuff.

    That was around the time I made the switch to C++. I was doing a lot of "hacky" workarounds at the time that weren't really satisfactory. At the time, the project was heading in a direction I didn't want to go. I was trying to do too much all at once, and on top of it, wasn't using barebones DirectX for full effect.

    This also means I've taken a large step back. Starting again from nothing, I have no terrain, no hlsl support, no lighting, etc. It's where I want to be though, doing too much all at once would get me nowhere. I wanted the game to be simpler, and not so much of a graphics test as it was just a fun little game. I wasn't interested in learning the finer works of HLSL bump map shader effeciency, but more-so could I get a game out of it all. Sticking with C# left me in this weird limbo where I was tied to using fancy effects/shaders and spend too much of my time worrying about that stuff, and not enough time getting stuff done. So I began anew, in C++.

    Fast forward to today, and here's what I've got now:


(The hand is ripped from an Elder Scrolls screenshot, which is made by Bethesda, not me!)

    The dungeon is generated via python script, which takes a simple, raw text file input (designed by the user, which I'll go into detail about) and spits out a map that the game can read in. Then in game, we select basically "load map from file" and it reads in the map and generates the vertices and indices and such, producing what you see above.

    The pattern I decided to use was based on a simple number system, which basically numbers the combinations of where walls could be on a particular tile. So far, there are sixteen noteworthy combinations:

they do!

    Then using this system, I draw out a simple map in paint, what I want it to look like:


    And based on where the red lines show up, I assign each cube a number. As you might be able to tell from the text at the bottom, I then copy those numbers into a raw text file and go from there. You might be able to imagine other ways I could potentially automatically generate this data, and other ways I could have the player design maps. There's a lot of mobility here.

    Finally, I've got a short youtube demo showing off my progress in action. Enjoy!:

2/20/2014: Render more stuff! (Updated)

So Last time I was working in 3D, I was messing around with XNA. Basically since then, XNA has been discontinued, and we won't see it coming back for the Xbox One. This is sad, but I'm looking to move on and keep making games.

    Now that I'm revisiting my 3D game project, I decided to write the game in C# C++ using DirectX. For now, this page will serve as a blog view, updated pretty regularly.

    Basically if you have read the front page, you'll know already that I have rendered more shapes. I decided to add a simple set of axes set about the origin, as well as begun to work on a simple ramped (sloped?) model. The ramp is textured and translated to coords (2,2) at what I'd call its origin, but without reference that point might be confusing. Anyway, I am planning on moving on to its collision detection next, essentially defining a boundingslope which will apply to all sloped objects in the future.

    I have also put transforms into the model class, so we can rotate and translate (later scale, maybe) each model. I have also loaded all current models into a vector which will essentially later form the basis for the Map class.

    For now, I'll attach a screenshot of what it looks like:


2/12/2014: Render the cube!

    I recently got textures loaded and properly attached to vertices. Below is a little sample:

da cube, boy

    I am currently working on loading models from file. What I mean is, defining a custom file format for my models and importing them / making them. I plan on doing the same for terrain meshes, and then finally doing the standard old loading of fbx and other model files.

    So other stuff that works?
    -DirectInput from Keyboard
    -Rotation translation of camera
    -Collision via custom bounding boxes
    -Probably some other stuff I'm forgetting.

    More updates soon I hope!

1/31/2014: Second, delayed update:
    I had made good progress on the project. I made the mistake of posting it to facebook rather than here. I will refrain, however, from re-posting it here because as you might have read above, I am switching the project to be written in C++ rather than C#. This is essentially because after writing in C# for a few years now, I feel I have a lot less to learn by just doing what I would consider 'easy' than to build up experience in a language that I have only minor experience in. Also, C++ is basically considered the 'industry standard' for making games as it is, though I wouldn't mind seeing that change, it's still very necessary to be proficient in C++ to get work in dev roles.

    Since last time, I learned to define meshes, load them, and then display them. I learned about HLSL and lighting, and finally began importing models created in Blender. Things with this project are likely to be identical, though I'm looking to use 3dsMax as I seem to prefer it. This also means being able to load .fbx files, but from what I understand, this isn't much trouble to do.

    The project's rebirth has already got me a blue window where I've done a lot of the backend work getting the graphics device linked up and drawing. There are currently no vertices in the vertex buffer, or meshes to display, but the game is ready for those assets to be imported and loaded. I also have input handling detection, and a few other interfaces/classes worked out that aren't visually apparent at the moment, but will be entirely useful. More to come soon, as I will try to update this somewhat regularly throughout this semester. (And beyond?)

10/9/2013: First update:
    I started working on a game project about two weeks ago, but I was getting discouraged that XNA would not be continuing forward for next gen. After all, I've learned a majority of my game making experience through the XNA framework, and made a few games now that use it at the core. But now that it is no longer, I decided to reboot the project before I got any further (and things got messy).

    It took me a good few hours, and a lot of trial and error, but I have produced a demo similar to the state I was in before the DirectX translation. Essentially we have a dungeon generator which throws together a group of polygons and renders them to the window. The user can pan and rotate around the object in 3D space. Left to do is add back walls and ceilings, and re-add colision detection, though those shouldn't be too difficult. I also plan on getting my XML parser hooked in soon, so I can load maps from file. But for now, here's a screenshot of what I've got:

first image