next »

[SeaWyrm]

Got rid of some nasty invisible triangles in my slope collision, no sweat. I'd been worried that I'd forgotten everything I ever knew about lines ever. Turned out it was just a couple of <s that should have been >s.   

[SodiumEyes]

Spent the last while working on physics and rendering systems. Finally put them all together and now I have some test objects bouncing around with custom collision geometry (created using a custom utility program), all rendered with HDR lighting and shadow cascades.

[kamac]

Tried to load a BMP with a custom function for the first time,

it worked! 

[eddietree]

sunday evening speed coding. made in two hours using html5 canvas and javascript

http://illogictree.com/games/obsidian/

[kamac]

sunday evening speed coding. made in two hours using html5 canvas and javascript

http://illogictree.com/games/obsidian/

I sense MATHS.

[ChevyRay]

Decided that it was a great idea to code a bunch of progress on FlashPunk 2 while drunk last night...

Unexpectedly, I woke up to find out that I added two very tough important features, and had left a bunch of completely legible comments for myself explaining how things work.

 

Not sure how, but I am a happy programmer.

[nikki]

^ 

can't remember where but somewhere on this board is a thread that even has some scientific proof for the -drunk coding is better- theorem   

[Gunhead]

lol, the last time we stayed in for a late code/art session and got drunk, almost nothing done.

Other than the act of drinking of course.

[Sergi]

That's because you didn't reach the Ballmer's Peak.

[Muz]

Quadrupled Eclipse's loading time by turning off my antivirus :D

[InfiniteStateMachine]

I hope ou mean cut down to 25% of its loading time 

[Muz]

I hope ou mean cut down to 25% of its loading time 

er, yeah, I meant speed

[Sergi]

So it only takes like 10 minutes now?

[InfiniteStateMachine]

lmaoooooo 

[RalenHlaalo]

Just rewrote my renderer (again). It's based on OpenGLES2, but the interface is implementation independent. Unlike my previous iteration, this one runs in its own thread. It was my first (non-college assignment) experience with threading. You can check it out here if you like. Feel free to leave some critical comments, so then we can talk about it and hopefully I'll learn something

[AlexStv]

I'm a learning programming and game design and just finished writing my own A* pathfinder for a unity stealth game I'm working on. Node based navigation, backtracking when the path gets stuck down a dead end and streamlining of the path when it's done. All that's left is smoothing the result. 

[st33d]

Err, hate to break this to you but A* doesn't get stuck in dead ends.

[AlexStv]

Hmm, I may have written something not as A* based as I originally intended but from what I've read, while plotting the path it would be possible for A* to choose a path that, while seeming to be the shortest route, doesn't actually lead to the target if there are walls blocking off the path further down, then if all the nodes that lead there are already on the closed list it won't be able to find a path out that isn't blocked by walls so it would need to backtrack it's way out until there are other nodes to choose from and try those instead. I may have misunderstood A* though but whatever my code is it works well for the levels I have.
My main reference was this: http://www.policyalmanac.org/games/aStarTutorial.htm and it specifically mentions dead ends and labeling them as such to avoid them although my levels contain far too many dead ends to label them all so I need a more automatic fix.
Edit: I don't want to clog up the happy programmer thread with my problems though

[zacaj]

I think in the most basic version of A* you don't lead the expansion in any direction, it just spreads on every side.  Realizing dead ends might be important if you used something to expand in the direction of the goal

[st33d]

 

Guys.

A* expands in the direction of the goal because the formula is:

f = g + h

Where f is the value of the node, g is the total physical distance to walk to the node and h is the distance to the node as the crow flies.

This means that A*'s open and closed lists expand towards the goal and start to skip back to alternatives as that growth meets dead ends. This behaviour occurs because of the relationship between the open and closed lists.

The open list is the list of nodes you are considering routes from, the closed is the list of examine nodes that you are done with.

There isn't a "basic" version of A* that behaves differently - that's not A*. What you would have if the node network grew organically would be Dijkstra's algorithm or Best First Search. Both useful in different ways, but not A*.

Knowing the difference is very important if you want to find help on debugging your AI. I raise the point because I've made this mistake myself long in the past.