I don't usually like this sort of anime, but this one has a certain je ne sais quoi about it that I find humorous.

Disabling the internet works wonders.

I- I never thought of that!  There's only 12 major backbone routers that all web traffic goes through, if a significant number of people the world over were infected with playing my game software, a strategic concerted timed blast of traffic at a single node might do the trick, then 11 more times, and repeat...  That's just crazy enough to work!

Oh, wait, no I'd have to make the game first.  Damn, almost had it.

I guess she is a dreamcast 

Makes sense.  The other one sounds just like an Xbox 360: "I will be eight this year."   

Watching: Time of Eve (Ivu no Jikan)





Indeed.

Working on a palette editing tool for reduced palette images.

Specifically: Batch image processing for re-indexing large sets of limited palette (color quantized) graphics from one palette set into another palette.  Currently working out a 3D color space "similarity" (distance) calculation that's closer to human perception of color, with fudge factors (weights) for preferred smallest difference per color axis.  Eg: remap an image and prefer closest hue and lightness over saturation.

I removed a square root and work with distance squared for comparisons, but now I have to compensate because the color distances don't scale linearly...

I can do a simple batch remap in GIMP, but I need to take into account multiple destination palettes for the color difference to due to banded (quantized) lighting level palettes.  Otherwise bits of stuff can end up "glowing in the dark" or changing hue under darker palettes.

I focus best best with something mildly distracting: Nothing with vocals when coding; No TV, people talking, or music with lyrics.  Perhaps the words interfere with the linguistic side of my brain?  However, when doing art-ish things I can listen to podcasts or even audio-books.

What seems to work best for me when coding is instrumentals, everything from classical music to pounding electro.

Rather than having a repetitious sound track I'll eventually tire of, and then get mired in the trap of deciding a "favorite song" to put at the end: Instead I listen to online streaming stations.  These typically have familiar melodies in an unpredictable order, or even new renditions of old favorites, like

, a cover of various inspiring Megaman tunes (discovered via rainwave.cc - VG Covers station).  Familiar music tends to sink into the background for me, but new stuff may demand too much attention if I end up really liking it.

I may neither need or desire distractions when trying to work out some hard problem (like efficient object space coordinates of picking rays in a hierarchy of planes for a free floating animated 3D menuing system, or modeling a generic bot-part that has style yet won't look too out of place on several chassis), but for most of what I consider normal or easy work I do benefit from a mild musical distraction.

It's as if when I leave my mind with available CPUs, so to speak, that part of me wanders off into more interesting things, so as not to be uselessly consuming power like so many spare cores when playing a single threaded game.  Left unchallenged with mere code-monkey work causes my mind's painter to dream up fantastic landscapes, but modeling blades of wicked grass for said landscape may cause my analytical CPU to start solving the physics problem of 2D gameplay on arbitrarily oriented 3D blades of said grass.

If I find myself outright procrastinating it's usually a result of me studying some interesting scientific findings or marveling at a newly discovered collection of art after racing off on a game related tangent -- Electrical paint that you pour out to make a charging/healing zone!  Oh, What were the components in that paint-on battery tech, again?  Cranking up the volume and filling the screens with code / editing tools does seem to keep me on task.

As with most dealings involving electro-chemical computers: Expect your mileage to vary.

Today I had just enough time to make a very basic in-engine palette editor.


@JakobProgsch: Cool!  Software Rasterizers Rock.  Keep it up!

I started developing a

in Java years ago, but gave up on it -- didn't perform as well as I needed it to since Java's VM doesn't use the system's native floats (it emulates the FPU using integer math, which is way slower than the same code in C or C++).

Today I created an Import/Export feature for some of our existing font formats.  This one's an importer for the Eternity Engine's CONCHARS lump (EE is a Doom 'sourceport'), which I can find no other image importer/exporter for, even among WAD tools.  Of course we can use common image formats too, this just adds support for some more obscure formats.

All the devs on our project are or were classic Doom modders.  It would be a shame to let all those original assets we made go to waste.  Bonus, once the game editor's out other modders can import resources from their existing WADS to use in new mods... Not that I expect anyone to make user generated content for our game, but if I've got to make the editing tools anyway might as well let the end users have 'em too.

Eventually I'll get around to replacing that hard to read glowing placeholder font...  Yes, the BG skybox looks like actual crap on purpose.  It's for the same reason the menu font is hard to read: To motivate us to make the replacements.

How does one make all those cool effects? :<

Loops, math, and particles, I assume!

Yep. That's pretty much it.  Start with some simple vector math and work your way up.  Also, additive blending, additive blending everywhere -- it's cheap and doesn't need depth-sorting.

This minigame is implemented completely within my engine's 3D-HUD API (using placeholder-images) -- it's really just to stress test the GUI & event systems in use in a larger game (it's tucked in the other game's level editor as an easter egg).

The particle swarm for the beam is simply a spherical distribution of particles that interpolate appearances as they get closer to the center point, animated via basic Newtonian gravity equation -- If the particle cloud were much larger you'd see some start orbiting, but since they're so near to the intangible center point of a much larger mass they whip around and past -- a gravity slingshot.  It's very inefficient managing all that in a component hierarchy; I really wouldn't recommend adding gravity physics or thousands of animated label items to a GUI -- the tree view of the menu's properties brings my system to its knees.

The "beam" needs a lot more work, but it's just two triangles \|/ (instead of one, to prevent texture warping) with a wrapped/tile-repeating scrolling texture -- part of the Virgon (Galactic) Lexicon.  You don't have to invent a language with highly OCR-able glyphs and Reverse Polish Notation grammar that's easy for machine intelligences to read and understand just to make the effect, I'm just using it as a placeholder graphic.

Since I slept it's a new day for me, so: Today I made image frame delta compression multi-threaded.  Theoretically, up to 4096 cores, but I'm only able to verify 8.  It's about 6x faster for me to encode a GIF video now. I should be able to use the same worker-thread pool in the WebM encoder too...



13MB .GIF clip.
This is a longer recording, so I made it lower-res (also to test out variable res output). It shows a bigger chain destroyed, and the animation of the next pieces, as well as a glimpse of the 3D menu the game is in.

This is something I made today in Javascript and HTML5.  I've been wanting to make a rouguelike for ages so I did this in my little capsule hotel room in Japan.  The river and house are my first dips into procedural generation.  I'm looking to add curvature to the river and more rooms to the house in the next few days.  I am also loving working with Javascript.  The only real problems I'm stuck on are what to do about reading external data and lagless input (which I believe can be fixed with JQuery?)

Sweet.  I did some JS+HTML game coding about a decade ago in the early HTML4.01 days (to teach myself JavaScript). The new HTML5 canvas & audio tags are really nice.  The trick to less input lag is to do the input update logic (move the player, whatever) in the onKeyDown event, but that's kind of hackish...  Alternatively I set input flags in the event handler and used a "main loop" function that updates every 10ms { setInterval( mainLoop, 10 ) }, and only draws a new frame if input was received or the desired frame delay has passed (use wall clock time via Date() to update animations since interval callbacks can be quite stuttery).

JQuery is a bit much, IMO, just test for "element.attachEvent()" and use it in IE, for everything else "element.addEventListener()" -- You'll write two sets of event flag setting functions, but it's much faster than JQuery's complete event system re-implementation, which is kinda slow since it adds layers between the browser and your code that the aforementioned selective event registry technique avoids.

To load external data back in the day you could add an IFRAME and point it to a .JS file that could update the main window's variables, but today's browsers disallow that sort of thing -- You can get around it a bit by using the window.name hack (which gets around cross-domain context restrictions).  My Snack-Man JS game used base 64 encoding and stored all the level data in text strings in its single JS file.  Today I'd recommend an AJAX call to load some XML or JSON document.  Browsers provide XML DOM access to JS similar to the page's DOM, for externally loaded resources.  JSON is nice too, you don't have to walk a DOM to get at your data -- Fetch some JSON encoded data as a text file, then parse it with the browser's JSON parser -- Or, just eval() the fetched text into a var if you can trust the source. This is less secure since you're loading arbitrary JS code, but has the added benefit of being able to encode functionality as well as data: You could load an Enemy that has new behaviors not pre-defined in your main .JS files... helpful for bosses.  You can also construct and append a <script> tag to the current document too -- that's how many JS Bookmarklettes pull in all their extra data and code.

Pretty.

Neat.  That makes all kinds of nutty Moiré effects on my laptop screen when I scroll.

[Click for GIF of the combo being destroyed - 4.4MB]

Finally had time off my "day"-job to get some game coding done.


Click for GIF of the combo being destroyed - 4.4MB

Today I made demo record/playback so the engine can output image streams w/o a screen recorder.  Currently only directly encodes to .GIF, but I'm ~40% finished with my own WebM compatible encoder implementation.

it seems that the free alternative is to dump your frames

Yep. That's what I do.  I record a demo, then play it back and pass each frame to an internal encoder to produce in-game video format (just record deltas between frames, compress sub region deltas via fast Fourier transform).  Otherwise, pass the frames to ffmpeg or Web-M if I'm going to upload the video somewhere -- Takes a LOT less space to pass the frames over STDIN to ffmpeg than to snapshot each frame first, then run the video encoder.

The benefit of recording a demo, then replaying it is that the game engine can cooperate with the video encoder -- The game doesn't have to run at 60FPS, it can just pretend to while it dumps each frame to the encoder.  This type of encoding play-back runs slower than real time, but the resulting video is smooth and of highest quality.

The only way a true high-quality hologram would be possible is through a nanomachine swarm, and that's really far off.

Careful with "only" -- Broad statements like that are almost always wrong.  A "true" hologram by definition uses interference patterns of light to create 3D images -- High Quality is subjective, but with sufficient film and lasers I can create holograms with higher resolution than any "HD" display has today.

When I was a teen I used to do holography.  Mostly double reference beam holography because it's visible in ordinary light -- These were the sort of mono-cromatic-rainbow holograms, as seen on the security seal of some bank cards and currency.  I would sometimes make single exposure holograms, but those have to be only a single color and if you want to project the hologram it needs to be recreated by diffusing a laser beam through the film, so it would typically be only red or only green.  The benefit over double reference beam holograms was that they were brighter, and not dependent on ambient light.  So, I've been making holograms for decades without using any nano technology...  Just some lasers, lenses, mirrors and holographic film (and a sand box to insulate the equipment from any external vibrations which ruin the exposure).  This type of holography uses a film like old cameras used to -- it isn't in motion like a video.  Also, my helium-xenon laser is expensive to operate to regenerate the holograms (shine the diffused laser light through the film).

That was a few decades ago.  Advancements in laser technology have allowed DIY Full-Color Holograms to be made relatively cheaply.

Holograms will take the same path that photographic images will take: Single frame shots;  A chain of single frames to create a motion video via projector (movies);  Hardware technology to recreate arbitrary holograms (like computer monitors, but 3D).  We're at the last leg of this step. Current consumer 3D screens are stereoscopic ie they use two different 2D images, but there are true holographic displays in the works.

It's not impossible.  It takes a bunch of expensive polarized light, not nano machines...  Like the DIY Kickstarter project I linked to above shows, holography is getting cheaper every year.  Holograms encode a layer of 3D information (light reflection vectors) in a 2D interference pattern, they don't require nano machines.  If you're talking about things that you can feel as well as see, then look into

.  Scientists have actually used

, like Doctor Who's Sonic Screwdriver.

There are prototypes of displays that can generate arbitrary holograms, others use reflections on spinning mirrors, yet others are using laser induced plasma to form 3D images.

Here's some tips: Don't wait till you're out of college to start working on your games.  Make some "practice" games first, in your free time if you have any.  Typically one's first game won't be a blockbuster, so don't get too discouraged.  For me, if I put off working on gamedev stuff till after _X_ then it never gets done.  Try to make it a mandatory part of your life, even if only 6hrs per week;

Commit and complete.

Today I created a silly puzzle game mode where you try to top out and a beam destroys your blocks if they match various rules.



Been busy with my "day job", but I lurk here and the workin' on thread daily.  Just wanted to say thanks to all the folks posting stuff.  You inspire me to put in a bit of game work even when I think I'm completely out of juice.

Forgot to scale particle generation positions by the cell width.  Also, I forgot to tell them to stop generating.

@SIGVATR, each build bumps the image name one number -- I don't keep a ton of images, just save over the same one.  If something crazy happens I'll have a somewhat recent frame to analyze...  Like this:



This one didn't cause a crash, I just forgot to 'git submodule update' the script/data repo before launching.

[a]

C and C++ are statically compiled languages.  They're strongly typed.  They make a point to be extremely fucking type savvy -- Except when they're just out to fuck with you, then they're just lazy elitist type snobs.

Consider the following:

Code:

int i = 4;
int d = -2;
unsigned int k = 10;

if ( k > i ) puts( "k is greater than i." );
else puts( "k is less than or equal to i." );

if ( k > d ) puts( "k is greater than d." );
else puts( "k is less than or equal to d." );

Which results in the following:

Code:

k is greater than i.
k is less than or equal to d.

That's right, 10 is less than or equal to -2.  Wait, what?

The type promotion rules specify that the signed value will be promoted to an unsigned value during the compare, so on a 32 bit machine -2 is treated as 4,294,967,294... which really is greater than 10.

No sane person would ever expect a statement like this to return true if a is positive number, and b is negative:

Code:

if ( a < b ) return true;
return false;

The problem is that the folks who created C were insane and lazy.

It's entirely possible to make the damn compare signs ACTUALLY WORK.
(Even my "toy" scripting language has working comparators.)

The compiler KNOWS the types are dissimilar, so it KNOWS it's about to fuck you over.  It could generate extra code to make their language constructs actually work, but: Lazy.

For instance, when comparing values of dissimilar signs they could generate an additional check to ensure the signed value (b) is non negative:

Code:

if ( a < b && b > 0 ) return true;
return false;

Down in the ASM, they'd only have to insert one CMP / JMP instruction pair after the first compare to make such comparisons work -- Any computed values would be in the registers anyhow.  If you've ever seen how much extra machine code is generated by doing pointer math, then you'd realize one compare & jump instruction pair is fucking trivial, even to the most "efficiency" focused fools.

In truth, this is an edge case in the language that the original implementers overlooked; Many years ago, after this trap bit a few folks enough times to complain and want it changed, the language designers just stuck their noses in the air and said: "Deal with it."

Even though I've known about this little pitfall since my "Hello World" days, I still chased down a bug for three hours that was staring me in the face the whole time -- Until I looked up the types of the vars, and facepalmed.

I just got so spoiled coding in other languages not created by assholes that I got used to having basic boolean logic that's actually logical.

Also, The Standard doesn't say what type a "char" will be -- It could be a signed or unsigned byte, it's arbitrarily up to the compiler...  How do you write correct comparison logic if you CAN'T know the fucking type?!  "Just don't compare chars" -- ugh, I'm getting sick of this "Deal with it." bullshit.

[play]

What makes a game is play.

What makes a good game is good play.

[depend]

This sort of fills the gap between compo and mammoth-colabo.  I like the idea.  I hope it does become a series because many folks are too busy on their own projects (myself included), but could spare time on something fun between projects.

The only requirement for me to contribute to any project (game or otherwise) is that it must be cross platform (Win, Mac & Lin in the least)...  I don't dismiss arguments against multi-platform projects, I just don't find single platform projects worth working on.

In my experience, the main problem these types of collaborations face are scale and scheduling.  'Design by committee' invariably causes the planning stages to drag on, and agreeing on a schedule of milestones always takes a huge amount of compromise.  It can be done, but it takes discipline to enforce a time limit, especially when it's your baby on the chopping block.

Furthermore, the gameplan shouldn't depend on any but the dedicated core team to complete the goals.  Welcoming transient contributors is great, but depending on them to meet a schedule is a recipe for disaster.  It's better to have such contributions get you to the goal sooner (so you can add more polish), than to watch your schedule fall apart and end up begging for work.

While running in debug mode, I always save every 2048th frame to disk so when a crash like this happens I can show you folks...



The rainbow pattern in the grid is actually my memory allocator's boundary violation padding -- Freed memory should have a perfect pattern in it otherwise somethings written outside of where it should be writing... If I see the pattern in allocated memory, something's gone horribly wrong.

Video driver caused a Kernel panic half a second afterwards.