That's not to say you couldn't (and shouldn't) use both an object pool and this id system.

You can also pool unused ids (if a bullet dies [and there's no way to go back in time] it could get added to a list that would be safe to pull from).

The biggest problem I see with this id system, is how do you handle two bullets shot by different players at the same time? 

I just don't think that's going to work.  The design of a fps level is intrinsically linked with the gameplay, i.e. a good Quake 3 level wouldn't be a good Counter Strike level and vice versa.  You just aren't going to find a one-size-fits-all FPS level out there.  I think the first step would be to design a good FPS level with just basic primitives, and then swapping out the primitives with contextual objects (e.g. column or tree for a cylinder, house for a cube).

Well, it depends on a lot things but something like:

Code:

float timeOfLastHorizontalInput = 99;
float dashTimeout = 0.25;
float deadzone = 0.1;
float lastDirection = 0;
bool stoppedPressing = false;

void update(float deltaTime){
  float horizontalInput = GetInputAxis("Horizontal"); //Assumes -1 to 1 scale
  // This could also be something like -GetInput("Left") + GetInput("Right") or however input is handled


  float absHorizontalInput = Math.abs(horizontalInput);
  float currentDirection = Math.sign(horizontalInput);

  timeOfLastHorizontalInput += deltaTime;

  if (absHorizontalInput > deadzone){
    if (stoppedPressing && timeOfLastHorizontalInput <= dashTimeout && lastDirection == currentDirection){
      //DO DASH
    }
    lastDirection = currentDirection;
    timeOfLastHorizontalInput = 0;
    stoppedPressing = false;
  }
  else {
    stoppedPressing = true;
  }
}

That's a quickly paraphrased version of what I implemented in Unity.  Depending on how you get input, you'll have to change it around (and it might be easier, since Unity doesn't have a convenient way to get JustPressed information for horizontal and vertical input).

Caveat, as this is just a quick from memory paraphrase, I won't claim that this actually works, but it should be close.

I've implemented dashing, but there are a lot of ways one can go about it.  Are you going for the standard "Double tap in a direction" or something else?

Hmm... well this is a weird request.  There are a lot of ways to do this, so perhaps you should be more specific.  What properties do you want this mapping to have? 

What Rusk said to do is just a very bad hashing algorithm, which got me thinking that you could use a good hashing algorithm.  But that's only if you want some sort of pseudo-random response.

So, yeah, if you want a good answer, you will need to offer up more information.  How is this being used? What is your intention with it?

I will say that combat in the Gods of War series is a very different experience on the hardest difficulties.  Button mashing is no longer a viable strategy, and parrying and evasion become much more important. 

That being said, I'm not sure that it even makes sense to compare the combat systems.  They are both aiming for such different things, that it's almost without meaning to compare the two.

And as Derek says, ignoring combat, DS is just a much more interesting and rich game than GoW.

@Elk
I'm sure there will be enough other people heaping on the praise, but goddamn that is fucking awesome.  I know the word awesome is completely trite and overused, but I mean it in the literal sense here.  I am quite literally in awe of that work.

Just a quick note that's a bit off topic, but you might want to look into proportional navigation.  Instead of changing angle to look at the current position of the target, you want to minimize the LOS rate to properly lead the target.

Sure. It's not for everyone, but that's not necessarily a bad thing surely.

*scoff* Games must be made for the lowest common denominator, obviously.


Just played through The Knife of Dunwall DLC twice.  I feel a bit cheated for the money, not because it wasn't fun but because it feels like they deliberately split up the content to make more money. The ending feels more like the ending of Act 1 than any sort of proper ending. But getting a bit of Daud's tale is nice, and it allows them to rejigger the abilities a bit in ways that completely change how the game plays.  The biggest difference being that while holding down the button for Daud's Blink, it stops time if you aren't moving.  This allows for a much more precise style of play, where you can blink to the perfect spot every time, kill a dude, and then blink out perfectly, before anyone sees you.

I think you should just pick a language, any language, and try to get the feel of it.  If this is your first time programming, you probably won't be making a game for a while (or it will be a long uphill battle).  This is ok. 

If you stick with programming, you will probably acquire a large smattering languages (at least I have) and will find them to be useful for different things.  There is no perfect language, and in the end you will use the one that works best for you for the problems you want to solve.

I like C#, as it offers a lot of benefits common in newer languages, while still having a syntax that is relatively transferable to C++, Java, and to a lesser extent C.  Personally, I'm not a fan of Python, but that's my own personal taste, and I would never tell someone to stay away from it just because I'm not a fan.  The only way that I found that I wasn't a fan was by using it.

So, like I said, pick a language and stick with it.  If you want the shortest path to making a game, I'd recommend Javascript (don't know a ton about HTML5, but I'm sure there are some good frameworks out there) or AS3 (with FlashDevelop and Flixel/FlashPunk). Otherwise, I think that C# (with MonoGame or Unity) or python (with pygame or pyglet) would be good places to start.

I finished it last night.  It was amazing how little of the game I remembered.  Essentially my memory was:
Medical -> -> Twist -> -> Fight Many -> Fight Final Boss

Here are my thoughts:

- The audio is fantastic.  Pretty much everything is telegraphed by noise and hearing the Many talk is just creepy as hell.  Similarly, hearing a protocol droid say hello to you when you are a melee heavy build causes you to find an escape route fast.

- The game is very uneven in its difficulty.  The beginning is very hard when all you have is access to a wrench (and a pistol that seems to degrade with every shot), but by the time you make it through engineering, the game becomes much easier.  Also, while I disliked how ubiquitous the respawn spots were in Bioshock, the uneven spacing of them in SS2 makes the beginning of every level a bit shitty, as it can really suck to die before you find one. 

- It's funny how telegraphed the twist is.  In Bioshock, I think it feels like a legitimate surprise, but in SS2, if you even halfway listen to what Xerxes says and know anything about SS1, you can pretty easily guess where the game is going.  Honestly, the twist makes very little sense and just seems more like a "cool" idea that Ken Levine had. Why then?  Why just keep going along with your puppetmaster after the reveal?  Of all of the ideas that got revisited in Bioshock, this is the one that Bioshock legitimately improved upon.

- The final third (? quarter?  everything in the Rickenbacker really) sucks.  The final bits are completely linear and feel rushed.  This is actually the biggest similarity with Bioshock 1.  Both hit their climax ~2 hours early and then just kind of mope on to the end.   

- The backtracking sucks too, as there's really no need for it.  Nothing new happens, hell, most enemies have already been cleared out of the areas you go back to (except for the respawns).  I mean, it was relatively quick and painless, but it was just tedious and unnecessary.

- Leveling up was annoying as it is pretty cryptic and until you get a feel for what enemies you are going to be facing, you have no idea if the decisions you are making are the correct ones.  The beginning "4 years" feels just like college.  You learn a bunch of random stuff and you have no idea what will actually be useful until you get into the real world.

Jittered grid might be ok, but I still say that if you want a non-regular pattern, go with Poisson Disk sampling.  It'll guarantee spacing constraints and regularity in a way that a jittered grid can't.

If natural is what you are going for, Poisson Disk sampling is probably the thing for you.

It's more offensive because zombies aren't real, but the systemic objectification of women is. There is nothing inherently offensive about the naked human form, but it's tricky tread to ground and you've handled it poorly.  Your use of nudity is obviously designed to play into standard heterosexual white male fantasies, with no point other than titillation.  And honestly, we have enough heterosexual white male power fantasies floating around.

This also isn't to say that violence isn't offensive or that it can't be more offensive than the objectification of women, but in your specific example, the objectification is the more repugnant.  This is for a couple reasons:
1) The actual graphics of your game aren't detailed enough to convey anything beyond generic cartoon violence.
2) Similar to 1, the in-game graphics aren't detailed enough to convey what the main character is.  Until I saw the "cover-art" I thought the main character was a generic robot.  Following that, the violence of what appears to be non-human on non-human is less offensive than that of graphic violence committed to a human.
3) The cover art is ludicrously gratuitous. You keep throwing out the word mature, but I'm not sure you understand what it means.  There is nothing mature about something seemingly designed to titillate 13 year old heterosexual boys.

I got it last night and played a bit this morning.

I remembered reading about SS2 mods a while back, and decided to check them out.  The only one that I can recommend with no reservations is SHTUP, as it just replaces some of the textures with higher-res versions.  Beyond that, there aren't a ton that don't seem to start to make more drastic changes to the game.

- I like the torch system

- The varied enemies seem pretty cool.  I liked the armored back-stab resistant dudes and the axe thrower dude.

- The enemies punching down walls seems like an attempt to reduce cheesing.  Not sure how I feel about this.

- The game looks pretty much just like Dark Souls except for better shadows, tonemapping, more particles, and everything is more orange.

- The mansion of the dragons looks pretty sweet.  Skeleton dragon was totally cool, and I like the tense, quiet feeling.

I made a day/night cycle (not for a platformer), but generally, it's a bunch of data points in time that I interpolate between. 

Each point contains:

Sun Intensity
Sun Color
Sun Azimuth
Sun Elevation
Sky Light Intensity
Horizon Sky Color
Zenith Sky Color
Sun Azimuthal Extent (bad name, but the extend that the sun color bleeds into the sky azimuthally [think orange glow around sun at sunset])
Sun Elevation Extent (see above)
Moon Intensity
Moon Color
Moon Azimuth
Moon Elevation

That "design" is horrible and you are horrible.

You can also try to look for a programmer partner in Collaborations or Unpaid Work.

Artists tend to have the highest success rate of people joining with them, but the thing to remember about partnerships is that they are just that, partnerships, and if one tries to enforce an employer/employee relationship when money isn't exchanging hands it tends to go sour fast.  Also, and this is no offense to you, but ideas are easy, execution is hard, and it is much easier to imagine a fun game than to make one.

Also, if you are going to be doing this a lot, you would typically want to check to see if the distance squared is greater than the sum of the radii squared to save yourself a square root.

i.e.
change

Code:

Point difference = new Point(circle1.x-circle2.x,circle1.y-circle.y);
Boolean doesIntersect = Math.Sqrt(difference.x*difference.x+difference.y*difference.y) < (circle1.radius+circle2.radius);

to

Code:

Point difference = new Point(circle1.x-circle2.x,circle1.y-circle.y);
Number radiusSum = (circle1.radius+circle2.radius);
Boolean doesIntersect = difference.x*difference.x+difference.y*difference.y < radiusSum*radiusSum;