1.1 - An angles module
I often run into all kinds of problems that have to do with angles. I have found, or made solutions for many of these problems, but it would maybe be a good idea to have a stand alone module with some, if not all of these methods as they come up. For example there is figuring out what direction a current angle should change to face a target angle, when doing so there are two angles and two directions, but it would be nice to know which way would be faster. That is just one of many little things that will come up with angles, and this module aims to help address at least some of them.
There are many games that follow a kind of system where a period of time goes by, and a wave of enemies enters a game world area that must be completely destroyed. Many of them are a little fun, and addictive, so having a system like this worked out is a good first step for making a few games that make use of this.
This is a simple game prototype idea that came to mind that I put together in a single day. It is a game where a bunch of display objects will spawn in one area of a canvas, and then move to another display object in the canvas that are of two kinds of types. One type of display object is will represent an egg, while the other will represent a bomb. When the player clicks and holds down on the canvas the player character object will begin eating whatever is thrown at it, eggs will result in a gain of score, while a bomb will result in game over.
1.4 - A canvas module
1.5 - Digital Art invaders
This is the third digital art project that I have made while experiment with a whole new thought process that has to do with plaining out that the core of an idea is and finish that idea in just a few days. The general idea here is to have a bunch of fixed units that will spawn at the center of the canvas, and a bunch of other invading units that spawn from outside of the canvas and move to the center to attack these fixed units. Speaking of units some additional things that I worked out in this example is a new object pool library, as well as a system on top of that that is used to create and manage units.
1.9 - An exp point system
This is my first attempt at making a module, reusable experience point system that I can take with me from one project to the next. I have used this system in a few of my canvas examples, but I am not happy with it. Still I would say that I have managed to get a few things solid with this system to say the least. I think that a good experience point system should provide at least two pure functions that will both return a kind of standard level object. One pure function where the experience points are know, but the level is not, and another that will work where the level is known, but the experience point values are not known.
1.10 - Fizz buzz
1.11 - A game framework example
1.12 - Grid Game Unit Movement
In this example I have a grid and I am working out some basic logic when it comes to moving those units around in the grid. There is a bit to it actually when it comes to making a system for this sort of thing from the ground up. However what is also great about it is that it is not so hard to get something working, and once I have a basic system for the kinds of games that I have in mind I can use it to not just make one game but a few taking this system with me to each new project. However as of this writing this one is still a work in progress that I have not put as much time into as I would have liked to. I do have a lot of other things going on that get in the way of me working much of this stuff out.
1.13 - Grid Module
In this post I am just going over the source code of a basic grid module.
This is a starting point for a simple idle game idea that is just another basic mine type theme. The general idea is that it will have some kind of space theme, and involve ships going back and form from planets back to a home base of sorts. This seems to me a common theme when it comes to these kinds of games as I see a lot of them on the open web.
1.15 - wild plant grid idle game
This is another idle game prototype that I might work on more at one point or another. The idea was to just have a grid of cells in which plants grow.
1.16 - Item probability
1.17 - A log once method
One thing that I would like to have as part of a basic utility library that I take with me from one project to another is a log once, or call once type method. When first starting out with the basic of debugging there is using the console.log method to log things out to the javaScriot console as they happen. I do not think that this is such a bad way to go about debugging, and I still find myself doing it, however there are some things to gain from starting to use my own system for logging things that are going on.
In this example I am working out a simple map system that will set some options for a main game state create method. In other words this is a simple system for having a collection of display objects in a canvas where each display object is for a level in a game, when the player clicks on one of these display objects they then progress to another state of the application that will be used to set additional settings, or progress directly to the game state. The display object in the map contains properties that will be passed to the game create method that will set up the state of the game object.
One great thing about nodejs is that I am using the same programing language that is used in web pages to create scripts that will run in an operating system environment. So with that said it should be possible to design some of my modules in a way so that they will work in a nodejs and browser environment without me having to hack over the code a little first.
This is a module where I am working out some basic core logic for something that I might use in a future game or two. It is a module that makes use of ratios as a way to set what kind of object it is. This idea then is to use ratios and point values as a way to set other object properties. These orb objects can then be used in a few different ideas I have for games, many of which are tower defense type games, and other kinds of strategy games.
1.22 - A percent module experiment
So there is having a simple expression like 3 \/ 4 that will result in a value between 0 and 1 that will be \0.25. In other words there is having a numerator and denominator value and getting a fraction between the two. However if a numerator value starts at 0 and approaches the denominator value as a fixed static rate, then the change happens along a straight line when graphed.
1.23 - Player unit grid
This is a new object pool library at least when compared to the project to which this is based on that I stated a while back. It is yet another object pool library, but this time I address a core problem that I ran into with the older one, making this one centered around the idea that it is a point in space that I am moving around first and foremost.
1.25 - Ratio module
This is a module that I made as a foundation for my orb module, which in turn might sever to be another modules that I will be using in at least one if not more canvas games. As the name suggests it has to do with ratios, and there is a great deal that comes up when working with them. For example say I have a set of numbers like 5,20,0,15 and I want a function that will return 1,4,0,3 when I pass the previous set of numbers to it. This module provides such a method that helps with this, and there are a whole bunch of other methods like that as well.
1.26 - Rotate and fire example
This is an example where I worked out some basic logic for a turret defense game when it comes to how the turrets will behave when it comes to rotation and fire control. For example I could make it so that when a player clicks an area of a canvas a turret is just set to an angle that points to that location and then it fires a shot for every click of the canvas. However another way to program this kind of game is to have a rotation rate, as well as a fire rate, and for the turret to only fire once it gets within a certain angular range of the target location that was clicked.
1.27 - Skill Point System
This is a skill point system that I put together to make use of in some canvas examples that might call for such a system. The general idea here is that in a game where there is an experience point system on each level some skill points will be given to the player. These skill points can then be invested into upgrades that have various effects on a main game state object.
1.28 - Sort planets
A simple sort of planets objects example that I might use if a future game if I ever get around to it. The idea of this example is that I just wanted to make a simple fun little example that makes use of the array sort method to which I wrote a quick blog post on. I wanted to go at least one step beyond just having a simple copy and paste hello world style example of array sort, and with that goal in mind I guess this example is more or less just that. I am not sure if I will every get around to expanding on this by making a real game based off of it, but in any case I all ready have an interesting starting point for something here to say the least.
1.29 - Tax brackets
A tax brackets example that helps me to get a general idea of how a progressive tax system works when it comes to things like income tax. I would not use this as a way to do ones own taxes of course, but it is a module that I might use in one form or another in some kind of game where I might want a module such as this.
1.30 - Test Module
1.32 - Trade Sim
This is a simple trade simulator module that I might use as a starting point for a more advanced version that could be used in a game. The general idea here is that the player has a way to buy items as a certain rate, and then sell them at another rate later on. Depending if the rate goes up or down they will stand to gain or lose money. I have come across this kind of feature in games here and there in the past and I think it is a nice feature to have in certain types of games, so I made a simple starting point for this kind of feature.
1.33 - A turn based RPG game
1.34 - utils module
1.35 - Zig Zag Arc
Another basic example that makes use of some methods I work out in my percent module example. This is a canvas example that makes use of functions in my percent module that result in zig zag like movement across the canvas. This is then just one of many applications of the percent modules that I had in mind.