kevroy314 / asternoids Goto Github PK

The player should be knocked back slightly when shooting.

Enemies should have HP and be able to withstand multiple bullet hits. They should check each bullet to determine how much damage it has done. This should use the angle of collision, velocity of collision, and bullet damage property.

This part should be easy as it is just a random star map (possibly with cool anomalies and stuff later).

Non-star ideas include:
-Rouge Planets
-Nebula
-Pulsar
-Quazar
-Black Holes

The player should be knocked back hit.

This algorithm should take as input a random seed and produce a starfield which has clumps. These clumps are labeled as different superclusters. These names should be roughly 3-10 characters long and no more than two words. Each label will have a suffix word, Supercluster. Some empty spaces can be labeled similarly but with a suffix word, Void.

Most importantly, every random seed input should produce precisely one map. Each map will be unique.

The player should be able to strafe as well as move forward and back.

See about adding more permanence by leaving even more expended objects/deleted in the scene. This may not apply if the initial implementation of permanence was done properly.

When bullets hit things, they should look like they hit something via a collision animation.

This part involves the user having selected a galactic quadrant (different galaxies may have different quadrant layouts) and taking the image from the previous galaxy, blowing it up, and giving the user sector options to select. This is the only step in which the previous layer should be absolutely identical in look to the current one. Not sure how to do this yet. Luckily, this means we're really just making a starfield of the right shape for the previous item.

There should be a lot of enemies on the screen. The game should run smoothly with at least 100 enemies.

Seems to have something to do with the collision detection system. Although Physics collisions are disabled, the box colliders may still be triggering. Need to figure out how to disable this detection completely.

Enemies should die fairly easily (but not in 1 hit) so the player can defeat hordes of them.

Things which are destroyed should leave evidence that they have been destroyed.

Bullets should animate when:
-Being fired
-Hitting something

Bullets should make a sound when:
-Being fired
-Hitting something

Basically, finish the game. For this issue to be closed, the player needs a way to win or lose.

Try to push performance to allow for 200+ enemies.

Make the enemies faster. This could, perhaps, be in the form of having "elite" enemies the player fights, or by making the enemies just generally faster. Gotta play with enemy performance a bit to find a good balance.

This may not apply. The idea is if the player is holding an item, the motion of that item should slightly lag behind the player motion.

Enemies should be knocked back a little when hit.

All objects should animate when they do something and have a sound effect when there is an impact.

Anything that shoots shouldn't do it perfectly. Lower accuracy of all shooting objects.

When enemies are hit, they should flash or perform some animation to show they player they have been hit.

Could be an issue with the planet hitbox or the application of forces to objects which are already in a collision with the planet. Either way, it's usually coupled with a large lag spike.

Generate a random (but consistent) galaxy supercluster field with a circular shape and even density. This will serve as the first level the user see. Each supercluster region should have a name laid out in a grid (which should be drawn on a separate layer). This will function as the initial GUI selection screen.

Bullets should go reasonably fast. This means fast enough that nothing can outrun them and they're hard (but not impossible) to dodge, but slow enough that they stay in orbit in the system.

Player should be able to shoot fairly fast.

The camera should lag behind the player while following slightly to feel "smoother".

Similarly to the previous layer up, a very clumpy layer should be generated with unique names with suffix, Cluster or Groups. The names may also conform to NGC XXXX where the X represents a random number.

As per the previous layer, these superclusters should be random but unique based on an input seed produced by the previous layer.

Make each sound effect better, specifically more bassy.

Enemies should animate when:
-Spawning?
-Moving? (they're always moving... this may not make sense)
-Getting hit

Enemies should produce sound effects when:
-Exploding/dieing
-Spawning?

There should be some animation to show the player that their controls are working and they are accelerating.

The camera should lead in the direction the player is facing slightly.

When enemies or other things the player is shooting are destroyed, make them spontaneously blow up!

One first step which needs to be accomplished is to generate random pronounceable strings for various layers/regions etc. The algorithm should be able to take a desired name length range as input and produce a pronounceable string as output. This should then be generalized to allow generation of random sets of pronounceable strings of lengths decided by simple probability distribution.

A robust name generator will help in creating a layered procedural map.

Add extra weapons other than the default gun.

Objects should animate when they're hit by stuff. This includes players and enemies at least.

The player (and enemies, if that system works) mussel should flash when a bullet is fired. This should be handled through an animation being imposed on the bullet when it leaves the player/enemy.

Bullets should be larger than is reasonable for the size of the player.

Make the gun fire faster and make the camera kick when the gun fires. This could be handled through screenshake mechanics and additional weapons.

Push the permanence by making the game remember when a player has beat a specific encounter. This will cross over with the idea of "meaning" in the game.

This part is probably going to be the hardest. Galaxies should be of any of the types of galaxies in this list of morphologies http://en.wikipedia.org/wiki/Galaxy#Types_and_morphology and should be randomly generated as either a Dwarf or full galaxy based on the previous input seed. This may require a subsystem to determine based on the seed input range what type should be used. This also may be a non-seed related deterministic input from the previous layer.

A local group should be a sparse group of dot stars (representing dwarf galaxies) and large galaxies. It may be simpler to just represent all of them as small dots. Each small dot should either have a unique name, a name with a suffix, Dwarf, a NGC XXXX or MXX or IC XXXX designation or may be part of a small group (Name A, Name B, Name C). These should, once again, be randomly generated but unique based on a previous seed.

Provide a means to vary the size of explosions based on the situation and make them spontaneously be different sizes.

Not sure why, but the planet collision radius seems to make the bullet animations happen almost exclusively inside the planet unless they hit the planet on a sharp tangent. Increasing the hit radius fixes this, but makes collisions look wrong for other objects. The animation may just need to execute with a slight offset. This shouldn't matter too much since the bullets are being destroyed immediately after.

When someone shoots, they should produce a mussel flash.

There should be some animation to show the player that their controls are working and they are accelerating.

Ship should animate when:
-Moving
-Getting Hit

Ship should make sound effect when:
-Moving? Not sure if that will sound good...

Try implementing a small (20ms) sleep when enemies die.

Enemies should be capable of shooting bullets. These bullet collisions should be used to determine player HP reduction on hit. Not sure if this will cause too many game objects, if so, this feature can be removed.

When things explode or shots are fired by the player, the screen should shake in proportion to the impact of the event.